opening hours
4.1.1
Com spatie/opening-hours você cria um objeto que descreve o horário de funcionamento de uma empresa, que pode ser consultado por dias open ou closed ou datas específicas, ou usado para apresentar os horários por dia.
spatie/opening-hours pode ser usado diretamente no Carbon graças ao cmixin/business-time para que você possa se beneficiar dos recursos de horário de funcionamento diretamente em seus objetos de data aprimorados.
Um conjunto de horários de funcionamento é criado através da passagem de um horário regular e de uma lista de exceções.
// Add the use at the top of each file where you want to use the OpeningHours class:
use Spatie OpeningHours OpeningHours ;
$ openingHours = OpeningHours:: create ([
' monday ' => [ ' 09:00-12:00 ' , ' 13:00-18:00 ' ],
' tuesday ' => [ ' 09:00-12:00 ' , ' 13:00-18:00 ' ],
' wednesday ' => [ ' 09:00-12:00 ' ],
' thursday ' => [ ' 09:00-12:00 ' , ' 13:00-18:00 ' ],
' friday ' => [ ' 09:00-12:00 ' , ' 13:00-20:00 ' ],
' saturday ' => [ ' 09:00-12:00 ' , ' 13:00-16:00 ' ],
' sunday ' => [],
' exceptions ' => [
' 2016-11-11 ' => [ ' 09:00-12:00 ' ],
' 2016-12-25 ' => [],
' 01-01 ' => [], // Recurring on each 1st of January
' 12-25 ' => [ ' 09:00-12:00 ' ], // Recurring on each 25th of December
],
]);
// This will allow you to display things like:
$ now = new DateTime ( ' now ' );
$ range = $ openingHours -> currentOpenRange ( $ now );
if ( $ range ) {
echo " It's open since " . $ range -> start (). "n" ;
echo " It will close at " . $ range -> end (). "n" ;
} else {
echo " It's closed since " . $ openingHours -> previousClose ( $ now )-> format ( ' l H:i ' ). "n" ;
echo " It will re-open at " . $ openingHours -> nextOpen ( $ now )-> format ( ' l H:i ' ). "n" ;
}O objeto pode ser consultado para um dia da semana, que retornará um resultado baseado na programação regular:
// Open on Mondays:
$ openingHours -> isOpenOn ( ' monday ' ); // true
// Closed on Sundays:
$ openingHours -> isOpenOn ( ' sunday ' ); // falseTambém pode ser consultado para uma data e hora específicas:
// Closed because it's after hours:
$ openingHours -> isOpenAt ( new DateTime ( ' 2016-09-26 19:00:00 ' )); // false
// Closed because Christmas was set as an exception
$ openingHours -> isOpenOn ( ' 2016-12-25 ' ); // falseEle também pode retornar matrizes de horários de funcionamento de uma semana ou de um dia:
// OpeningHoursForDay object for the regular schedule
$ openingHours -> forDay ( ' monday ' );
// OpeningHoursForDay[] for the regular schedule, keyed by day name
$ openingHours -> forWeek ();
// Array of day with same schedule for the regular schedule, keyed by day name, days combined by working hours
$ openingHours -> forWeekCombined ();
// OpeningHoursForDay object for a specific day
$ openingHours -> forDate ( new DateTime ( ' 2016-12-25 ' ));
// OpeningHoursForDay[] of all exceptions, keyed by date
$ openingHours -> exceptions ();Na construção, você pode definir um sinalizador para tempos de transbordamento ao longo dos dias. Por exemplo, para uma boate aberta até as 3h da manhã de sexta e sábado:
$ openingHours = Spatie OpeningHours OpeningHours:: create ([
' overflow ' => true ,
' friday ' => [ ' 20:00-03:00 ' ],
' saturday ' => [ ' 20:00-03:00 ' ],
], null );Isso permite que a API se aprofunde nos dados do dia anterior para verificar se o horário de funcionamento está aberto em seu intervalo de tempo.
Você pode adicionar dados nas definições e recuperá-los:
$ openingHours = OpeningHours:: create ([
' monday ' => [
' data ' => ' Typical Monday ' ,
' 09:00-12:00 ' ,
' 13:00-18:00 ' ,
],
' tuesday ' => [
' 09:00-12:00 ' ,
' 13:00-18:00 ' ,
[
' 19:00-21:00 ' ,
' data ' => ' Extra on Tuesday evening ' ,
],
],
' exceptions ' => [
' 2016-12-25 ' => [
' data ' => ' Closed for Christmas ' ,
],
],
]);
echo $ openingHours -> forDay ( ' monday ' )-> data ; // Typical Monday
echo $ openingHours -> forDate ( new DateTime ( ' 2016-12-25 ' ))-> data ; // Closed for Christmas
echo $ openingHours -> forDay ( ' tuesday ' )[ 2 ]-> data ; // Extra on Tuesday eveningNo exemplo acima, os dados são strings, mas podem ser qualquer tipo de valor. Assim, você pode incorporar várias propriedades em um array.
Por conveniência de estrutura, o par dados-horas pode ser uma matriz totalmente associativa, portanto o exemplo acima é estritamente equivalente ao seguinte:
$ openingHours = OpeningHours:: create ([
' monday ' => [
' hours ' => [
' 09:00-12:00 ' ,
' 13:00-18:00 ' ,
],
' data ' => ' Typical Monday ' ,
],
' tuesday ' => [
[ ' hours ' => ' 09:00-12:00 ' ],
[ ' hours ' => ' 13:00-18:00 ' ],
[ ' hours ' => ' 19:00-21:00 ' , ' data ' => ' Extra on Tuesday evening ' ],
],
// Open by night from Wednesday 22h to Thursday 7h:
' wednesday ' => [ ' 22:00-24:00 ' ], // use the special "24:00" to reach midnight included
' thursday ' => [ ' 00:00-07:00 ' ],
' exceptions ' => [
' 2016-12-25 ' => [
' hours ' => [],
' data ' => ' Closed for Christmas ' ,
],
],
]); Você pode usar o separador to especificar vários dias de uma vez, para a semana ou para exceções:
$ openingHours = OpeningHours:: create ([
' monday to friday ' => [ ' 09:00-19:00 ' ],
' saturday to sunday ' => [],
' exceptions ' => [
// Every year
' 12-24 to 12-26 ' => [
' hours ' => [],
' data ' => ' Holidays ' ,
],
// Only happening in 2024
' 2024-06-25 to 2024-07-01 ' => [
' hours ' => [],
' data ' => ' Closed for works ' ,
],
],
]);A última ferramenta de estrutura é o filtro, que permite passar fechamentos (ou referência de função/método chamável) que tomam uma data como parâmetro e retornam as configurações para a data especificada.
$ openingHours = OpeningHours:: create ([
' monday ' => [
' 09:00-12:00 ' ,
],
' filters ' => [
function ( $ date ) {
$ year = intval ( $ date -> format ( ' Y ' ));
$ easterMonday = new DateTimeImmutable ( ' 2018-03-21 + ' .( easter_days ( $ year ) + 1 ). ' days ' );
if ( $ date -> format ( ' m-d ' ) === $ easterMonday -> format ( ' m-d ' )) {
return []; // Closed on Easter Monday
// Any valid exception-array can be returned here (range of hours, with or without data)
}
// Else the filter does not apply to the given date
},
],
]); Se um callable for encontrado na propriedade "exceptions" , ele será adicionado automaticamente aos filtros para que você possa misturar filtros e exceções no array de exceções . O primeiro filtro que retornar um valor não nulo terá precedência sobre os próximos filtros e a matriz de filtros terá precedência sobre os filtros dentro da matriz de exceções .
Aviso: Faremos um loop em todos os filtros para cada data a partir da qual precisamos recuperar o horário de funcionamento e não podemos predicar nem armazenar em cache o resultado (pode ser uma função aleatória), portanto, você deve ter cuidado com filtros, muitos filtros ou processos longos dentro dos filtros pode ter um impacto significativo no desempenho.
Ele também pode retornar o próximo DateTime aberto ou fechado de um determinado DateTime .
// The next open datetime is tomorrow morning, because we’re closed on 25th of December.
$ nextOpen = $ openingHours -> nextOpen ( new DateTime ( ' 2016-12-25 10:00:00 ' )); // 2016-12-26 09:00:00
// The next open datetime is this afternoon, after the lunch break.
$ nextOpen = $ openingHours -> nextOpen ( new DateTime ( ' 2016-12-24 11:00:00 ' )); // 2016-12-24 13:00:00
// The next close datetime is at noon.
$ nextClose = $ openingHours -> nextClose ( new DateTime ( ' 2016-12-24 10:00:00 ' )); // 2016-12-24 12:00:00
// The next close datetime is tomorrow at noon, because we’re closed on 25th of December.
$ nextClose = $ openingHours -> nextClose ( new DateTime ( ' 2016-12-25 15:00:00 ' )); // 2016-12-26 12:00:00Leia a seção de uso para ver a API completa.
Spatie é uma agência de webdesign com sede em Antuérpia, Bélgica. Você encontrará uma visão geral de todos os nossos projetos de código aberto em nosso site.
Investimos muitos recursos na criação dos melhores pacotes de código aberto. Você pode nos apoiar comprando um de nossos produtos pagos.
Agradecemos muito que você nos envie um cartão postal de sua cidade natal, mencionando qual(is) de nossos pacotes você está usando. Você encontrará nosso endereço em nossa página de contato. Publicamos todos os cartões postais recebidos em nosso mural virtual de cartões postais.
Você pode instalar o pacote via compositor:
composer require spatie/opening-hours O pacote só deve ser usado através da classe OpeningHours . Há também três classes de objetos de valor usadas, Time , que representa um único horário, TimeRange , que representa um período com início e fim, e openingHoursForDay , que representa um conjunto de TimeRange s que não podem se sobrepor.
SpatieOpeningHoursOpeningHoursOpeningHours::create(array $data, $timezone = null, $toutputTimezone = null): SpatieOpeningHoursOpeningHoursMétodo de fábrica estático para preencher o conjunto de horários de funcionamento.
$ openingHours = OpeningHours:: create ([
' monday ' => [ ' 09:00-12:00 ' , ' 13:00-18:00 ' ],
// ...
]); Se nenhum fuso horário for especificado, OpeningHours apenas assumirá que você sempre passa objetos DateTime que já possuem o fuso horário correspondente à sua programação.
Se você passar um $timezone como um segundo argumento ou através da chave de array 'timezone' (pode ser um objeto DateTimeZone ou uma string ), então as datas passadas serão convertidas para este fuso horário no início de cada método, então se o método retorna um objeto de data (como nextOpen , nextClose , previousOpen , previousClose , currentOpenRangeStart ou currentOpenRangeEnd ), então ele é convertido de volta ao fuso horário original antes da saída para que o objeto pode refletir um momento no horário local do usuário, enquanto OpeningHours pode permanecer em seu próprio fuso horário comercial.
Alternativamente, você também pode especificar o fuso horário de entrada e saída (usando o segundo e o terceiro argumento) ou usando uma matriz:
$ openingHours = OpeningHours:: create ([
' monday ' => [ ' 09:00-12:00 ' , ' 13:00-18:00 ' ],
' timezone ' => [
' input ' => ' America/New_York ' ,
' output ' => ' Europe/Oslo ' ,
],
]);OpeningHours::mergeOverlappingRanges(array $schedule) : array Por questões de segurança, criar o objeto OpeningHours com intervalos sobrepostos lançará uma exceção, a menos que você passe explicitamente 'overflow' => true, na definição da matriz de horário de funcionamento. Você também pode mesclá-los explicitamente.
$ ranges = [
' monday ' => [ ' 08:00-11:00 ' , ' 10:00-12:00 ' ],
];
$ mergedRanges = OpeningHours:: mergeOverlappingRanges ( $ ranges ); // Monday becomes ['08:00-12:00']
OpeningHours:: create ( $ mergedRanges );
// Or use the following shortcut to create from ranges that possibly overlap:
OpeningHours:: createAndMergeOverlappingRanges ( $ ranges );Nem todos os dias são obrigatórios, caso falte um dia será definido como fechado.
OpeningHours::fill(array $data): SpatieOpeningHoursOpeningHours O mesmo que create , mas não estático.
$ openingHours = ( new OpeningHours )-> fill ([
' monday ' => [ ' 09:00-12:00 ' , ' 13:00-18:00 ' ],
// ...
]);OpeningHours::forWeek(): SpatieOpeningHoursOpeningHoursForDay[] Retorna uma matriz de objetos OpeningHoursForDay para uma semana normal.
$ openingHours -> forWeek ();OpeningHours::forWeekCombined(): array Retorna uma série de dias. A chave da matriz é o primeiro dia com o mesmo horário, os valores da matriz são dias que possuem o mesmo horário de trabalho e o mesmo objeto OpeningHoursForDay .
$ openingHours -> forWeekCombined ();OpeningHours::forWeekConsecutiveDays(): array Retorna uma matriz de dias concatenados, dias adjacentes com as mesmas horas. A chave da matriz é o primeiro dia com o mesmo horário, os valores da matriz são dias que possuem o mesmo horário de trabalho e o mesmo objeto OpeningHoursForDay .
Atenção : dias consecutivos são considerados de segunda a domingo sem looping (segunda não é consecutiva a domingo) independente da ordem dos dias nos dados iniciais.
$ openingHours -> forWeekConsecutiveDays ();OpeningHours::forDay(string $day): SpatieOpeningHoursOpeningHoursForDay Retorna um objeto OpeningHoursForDay para um dia normal. Um dia é uma string minúscula do nome do dia em inglês.
$ openingHours -> forDay ( ' monday ' );OpeningHours::forDate(DateTimeInterface $dateTime): SpatieOpeningHoursOpeningHoursForDay Retorna um objeto OpeningHoursForDay para uma data específica. Procura uma exceção naquele dia, caso contrário retorna o horário de funcionamento com base na programação normal.
$ openingHours -> forDate ( new DateTime ( ' 2016-12-25 ' ));OpeningHours::exceptions(): SpatieOpeningHoursOpeningHoursForDay[] Retorna uma matriz de todos os objetos OpeningHoursForDay para exceções, codificados por uma string de data Ymd .
$ openingHours -> exceptions ();OpeningHours::isOpenOn(string $day): boolVerifica se a empresa está aberta (contém pelo menos 1 intervalo de horário de funcionamento) em um dia da programação regular.
$ openingHours -> isOpenOn ( ' saturday ' );Se a string fornecida for uma data, ele verificará se está aberto (contém pelo menos 1 intervalo de horário de funcionamento) considerando a programação diária normal e possíveis exceções.
$ openingHours -> isOpenOn ( ' 2020-09-03 ' );
$ openingHours -> isOpenOn ( ' 09-03 ' ); // If year is omitted, current year is used instead OpeningHours::isClosedOn(string $day): boolVerifica se o negócio está fechado em um dia do horário normal.
$ openingHours -> isClosedOn ( ' sunday ' );OpeningHours::isOpenAt(DateTimeInterface $dateTime): boolVerifica se o negócio está aberto em um dia específico, em um horário específico.
$ openingHours -> isOpenAt ( new DateTime ( ' 2016-26-09 20:00 ' ));OpeningHours::isClosedAt(DateTimeInterface $dateTime): boolVerifica se o negócio está fechado em um dia específico, em um horário específico.
$ openingHours -> isClosedAt ( new DateTime ( ' 2016-26-09 20:00 ' ));OpeningHours::isOpen(): boolVerifica se a empresa está aberta no momento.
$ openingHours -> isOpen ();OpeningHours::isClosed(): boolVerifica se o negócio está fechado no momento.
$ openingHours -> isClosed ();OpeningHours::isAlwaysOpen(): boolVerifica se o negócio está aberto 24 horas por dia, 7 dias por semana, sem exceções e sem filtros.
if ( $ openingHours -> isAlwaysOpen ()) {
echo ' This business is open all day long every day. ' ;
}OpeningHours::isAlwaysClosed(): boolVerifica se o negócio nunca está aberto, não tem exceções e nem filtros.
OpeningHours aceita array ou lista vazia com todos os dias da semana vazios sem preconceitos.
Se não for um estado válido no seu domínio, você deverá usar este método para lançar uma exceção ou mostrar um erro.
if ( $ openingHours -> isAlwaysClosed ()) {
throw new RuntimeException ( ' Opening hours missing ' );
}OpeningHours::nextOpenOpeningHours::nextOpen(
?DateTimeInterface $ dateTime = null ,
?DateTimeInterface $ searchUntil = null ,
?DateTimeInterface $ cap = null ,
) : DateTimeInterface` Retorna o próximo DateTime aberto do DateTime fornecido ( $dateTime ou from now se este parâmetro for nulo ou omitido).
Se um objeto DateTimeImmutable for passado, um objeto DateTimeImmutable será retornado.
Defina $searchUntil como uma data para lançar uma exceção se nenhum horário de abertura puder ser encontrado antes desse momento.
Defina $cap como uma data para que, se nenhum horário de abertura for encontrado antes desse momento, $cap seja retornado.
$ openingHours -> nextOpen ( new DateTime ( ' 2016-12-24 11:00:00 ' ));OpeningHours::nextCloseOpeningHours::nextClose(
?DateTimeInterface $ dateTime = null ,
?DateTimeInterface $ searchUntil = null ,
?DateTimeInterface $ cap = null ,
) : DateTimeInterface` Retorna o próximo DateTime de fechamento do DateTime fornecido ( $dateTime ou from now se este parâmetro for nulo ou omitido).
Se um objeto DateTimeImmutable for passado, um objeto DateTimeImmutable será retornado.
Defina $searchUntil como uma data para lançar uma exceção se nenhum horário fechado puder ser encontrado antes desse momento.
Defina $cap como uma data para que, se nenhum horário fechado for encontrado antes desse momento, $cap seja retornado.
Se o agendamento estiver sempre aberto ou sempre fechado, não há mudança de estado a ser encontrada e, portanto, nextOpen (mas também previousOpen , nextClose e previousClose ) lançará um MaximumLimitExceeded Você pode capturá-lo e reagir de acordo ou pode usar os métodos isAlwaysOpen / isAlwaysClosed para antecipar tal caso.
$ openingHours -> nextClose ( new DateTime ( ' 2016-12-24 11:00:00 ' ));OpeningHours::previousOpenOpeningHours::previousOpen(
?DateTimeInterface $ dateTime = null ,
?DateTimeInterface $ searchUntil = null ,
?DateTimeInterface $ cap = null ,
) : DateTimeInterface` Retorna DateTime aberto anterior do DateTime fornecido ( $dateTime ou from now se este parâmetro for nulo ou omitido).
Se um objeto DateTimeImmutable for passado, um objeto DateTimeImmutable será retornado.
Defina $searchUntil como uma data para lançar uma exceção se nenhum horário de abertura puder ser encontrado após esse momento.
Defina $cap como uma data para que, se nenhum horário de abertura for encontrado após esse momento, $cap seja retornado.
$ openingHours -> previousOpen ( new DateTime ( ' 2016-12-24 11:00:00 ' ));OpeningHours::previousCloseOpeningHours::previousClose(
?DateTimeInterface $ dateTime = null ,
?DateTimeInterface $ searchUntil = null ,
?DateTimeInterface $ cap = null ,
) : DateTimeInterface` Retorna DateTime de fechamento anterior do DateTime fornecido ( $dateTime ou from now se este parâmetro for nulo ou omitido).
Se um objeto DateTimeImmutable for passado, um objeto DateTimeImmutable será retornado.
Defina $searchUntil como uma data para lançar uma exceção se nenhum horário fechado puder ser encontrado após esse momento.
Defina $cap como uma data para que, se nenhum horário fechado for encontrado após esse momento, $cap seja retornado.
$ openingHours -> nextClose ( new DateTime ( ' 2016-12-24 11:00:00 ' ));OpeningHours::diffInOpenHours(DateTimeInterface $startDate, DateTimeInterface $endDate) : floatRetorne a quantidade de tempo aberto (número de horas como um número flutuante) entre 2 datas/horas.
$ openingHours -> diffInOpenHours ( new DateTime ( ' 2016-12-24 11:00:00 ' ), new DateTime ( ' 2016-12-24 16:34:25 ' ));OpeningHours::diffInOpenMinutes(DateTimeInterface $startDate, DateTimeInterface $endDate) : floatRetorna a quantidade de tempo aberto (número de minutos como um número flutuante) entre 2 datas/horas.
OpeningHours::diffInOpenSeconds(DateTimeInterface $startDate, DateTimeInterface $endDate) : floatRetorna a quantidade de tempo aberto (número de segundos como um número flutuante) entre 2 datas/horas.
OpeningHours::diffInClosedHours(DateTimeInterface $startDate, DateTimeInterface $endDate) : floatRetorna a quantidade de tempo fechado (número de horas como um número flutuante) entre 2 datas/horas.
$ openingHours -> diffInClosedHours ( new DateTime ( ' 2016-12-24 11:00:00 ' ), new DateTime ( ' 2016-12-24 16:34:25 ' ));OpeningHours::diffInClosedMinutes(DateTimeInterface $startDate, DateTimeInterface $endDate) : floatRetorna a quantidade de tempo fechado (número de minutos como um número flutuante) entre 2 datas/horas.
OpeningHours::diffInClosedSeconds(DateTimeInterface $startDate, DateTimeInterface $endDate) : floatRetorna a quantidade de tempo fechado (número de segundos como um número flutuante) entre 2 datas/horas.
OpeningHours::currentOpenRange(DateTimeInterface $dateTime) : false | TimeRange Retorna uma instância SpatieOpeningHoursTimeRange do intervalo aberto atual se a empresa estiver aberta, falso se a empresa estiver fechada.
$ range = $ openingHours -> currentOpenRange ( new DateTime ( ' 2016-12-24 11:00:00 ' ));
if ( $ range ) {
echo " It's open since " . $ range -> start (). "n" ;
echo " It will close at " . $ range -> end (). "n" ;
} else {
echo " It's closed " ;
} Os métodos start() e end() retornam instâncias SpatieOpeningHoursTime . As instâncias Time criadas a partir de uma data podem ser formatadas com informações de data. Isso é útil para intervalos que ultrapassam a meia-noite:
$ period = $ openingHours -> currentOpenRange ( new DateTime ( ' 2016-12-24 11:00:00 ' ));
if ( $ period ) {
echo " It's open since " . $ period -> start ()-> format ( ' D Gh ' ). "n" ;
echo " It will close at " . $ period -> end ()-> format ( ' D Gh ' ). "n" ;
} else {
echo " It's closed " ;
}OpeningHours::currentOpenRangeStart(DateTimeInterface $dateTime) : false | DateTime Retorna uma instância DateTime da data e hora desde quando a empresa foi aberta, se a empresa estiver aberta, e falsa se a empresa estiver fechada.
Observação: a data pode ser o dia anterior se você usar intervalos noturnos.
$ date = $ openingHours -> currentOpenRangeStart ( new DateTime ( ' 2016-12-24 11:00:00 ' ));
if ( $ date ) {
echo " It's open since " . $ date -> format ( ' H:i ' );
} else {
echo " It's closed " ;
}OpeningHours::currentOpenRangeEnd(DateTimeInterface $dateTime) : false | DateTime Retorna uma instância DateTime da data e hora até quando a empresa estará aberta se a empresa estiver aberta, falsa se a empresa estiver fechada.
Observação: a data pode ser o dia seguinte se você usar intervalos noturnos.
$ date = $ openingHours -> currentOpenRangeEnd ( new DateTime ( ' 2016-12-24 11:00:00 ' ));
if ( $ date ) {
echo " It will close at " . $ date -> format ( ' H:i ' );
} else {
echo " It's closed " ;
}OpeningHours::createFromStructuredData(array|string $data, $timezone = null, $outputTimezone = null): SpatieOpeningHoursOpeningHoursMétodo de fábrica estático para preencher o conjunto com uma matriz https://schema.org/OpeningHoursSpecification ou string JSON.
dayOfWeek suporta array de nomes de dias (com sabor do Google) ou array de URLs de dias (especificação oficial do schema.org).
$ openingHours = OpeningHours:: createFromStructuredData ( ' [
{
"@type": "OpeningHoursSpecification",
"opens": "08:00",
"closes": "12:00",
"dayOfWeek": [
"https://schema.org/Monday",
"https://schema.org/Tuesday",
"https://schema.org/Wednesday",
"https://schema.org/Thursday",
"https://schema.org/Friday"
]
},
{
"@type": "OpeningHoursSpecification",
"opens": "14:00",
"closes": "18:00",
"dayOfWeek": [
"Monday",
"Tuesday",
"Wednesday",
"Thursday",
"Friday"
]
},
{
"@type": "OpeningHoursSpecification",
"opens": "00:00",
"closes": "00:00",
"validFrom": "2023-12-25",
"validThrough": "2023-12-25"
}
] ' );OpeningHours::asStructuredData(strinf $format = 'H:i', string|DateTimeZone $timezone) : arrayRetorna um OpeningHoursSpecification como uma matriz.
$ openingHours -> asStructuredData ();
$ openingHours -> asStructuredData ( ' H:i:s ' ); // Customize time format, could be 'h:i a', 'G:i', etc.
$ openingHours -> asStructuredData ( ' H:iP ' , ' -05:00 ' ); // Add a timezone
// Timezone can be numeric or string like "America/Toronto" or a DateTimeZone instance
// But be careful, the time is arbitrary applied on 1970-01-01, so it does not handle daylight
// saving time, meaning Europe/Paris is always +01:00 even in summer time.SpatieOpeningHoursOpeningHoursForDay Esta classe é somente leitura. Ele implementa ArrayAccess , Countable e IteratorAggregate para que você possa processar a lista de TimeRange s de maneira semelhante a um array.
SpatieOpeningHoursTimeRange Objeto de valor que descreve um período com hora de início e de término. Pode ser convertido em uma string no formato H:iH:i .
SpatieOpeningHoursTime Objeto de valor que descreve uma única vez. Pode ser convertido em uma string no formato H:i .
Você pode converter o formato OpenStreetMap para o objeto OpeningHours usando osm-opening-hours (graças a mgrundkoetter)
Consulte CHANGELOG para obter mais informações sobre o que mudou recentemente.
composer test Consulte CONTRIBUINDO para obter detalhes.
Se você encontrou um bug relacionado à segurança, envie um email para [email protected] em vez de usar o rastreador de problemas.
Você é livre para usar este pacote, mas se ele chegar ao seu ambiente de produção, agradecemos muito que você nos envie um cartão postal de sua cidade natal, mencionando quais de nossos pacotes você está usando.
Nosso endereço é: Spatie, Kruikstraat 22, 2018 Antuérpia, Bélgica.
Publicamos todos os cartões postais recebidos no site da nossa empresa.
A licença MIT (MIT). Consulte Arquivo de licença para obter mais informações.
