/**
* @param ReservationSeries $reservationSeries
* @return ReservationRuleResult
*/
public function Validate($reservationSeries)
{
$userId = $reservationSeries->UserId();
$resourceId = $reservationSeries->ResourceId();
$isOk = !empty($userId) && !empty($resourceId);
return new ReservationRuleResult($isOk, Resources::GetInstance()->GetString('InvalidReservationData'));
}
/**
* @param Reservation $instance
* @param ReservationSeries $series
* @param IReservedItemView $existingItem
* @param BookableResource[] $keyedResources
* @return bool
*/
protected function IsInConflict(Reservation $instance, ReservationSeries $series, IReservedItemView $existingItem, $keyedResources)
{
if ($existingItem->GetId() == $instance->ReservationId() || $series->IsMarkedForDelete($existingItem->GetId()) || $series->IsMarkedForUpdate($existingItem->GetId())) {
return false;
}
return parent::IsInConflict($instance, $series, $existingItem, $keyedResources);
}
/**
* @param ReservationSeries $reservation
* @return void
*/
public function Notify($reservation)
{
$owner = $this->_userRepo->LoadById($reservation->UserId());
if ($this->ShouldSend($owner)) {
$message = $this->GetMessage($owner, $reservation, $this->_attributeRepo);
ServiceLocator::GetEmailService()->Send($message);
} else {
Log::Debug('Owner does not want these types of email notifications. Email=%s, ReferenceNumber=%s', $owner->EmailAddress(), $reservation->CurrentInstance()->ReferenceNumber());
}
}
/**
* @param ReservationSeries $reservationSeries
*/
function Notify($reservationSeries)
{
$instance = $reservationSeries->CurrentInstance();
$owner = $this->userRepository->LoadById($reservationSeries->UserId());
foreach ($instance->UnchangedParticipants() as $userId) {
$participant = $this->userRepository->LoadById($userId);
$message = new ParticipantUpdatedEmail($owner, $participant, $reservationSeries, $this->attributeRepository);
ServiceLocator::GetEmailService()->Send($message);
}
}
/**
* @param ReservationSeries $reservation
* @return ReservationRuleResult
*/
public function Validate($reservation)
{
$reservation->UserId();
$permissionService = $this->permissionServiceFactory->GetPermissionService();
$resourceIds = $reservation->AllResourceIds();
foreach ($resourceIds as $resourceId) {
if (!$permissionService->CanAccessResource(new ReservationResource($resourceId), $reservation->BookedBy())) {
return new ReservationRuleResult(false, Resources::GetInstance()->GetString('NoResourcePermission'));
}
}
return new ReservationRuleResult(true);
}
/**
* @param ReservationSeries $reservationSeries
* @return ReservationRuleResult
*/
public function Validate($reservationSeries)
{
$quotas = $this->quotaRepository->LoadAll();
$user = $this->userRepository->LoadById($reservationSeries->UserId());
$schedule = $this->scheduleRepository->LoadById($reservationSeries->ScheduleId());
foreach ($quotas as $quota) {
if ($quota->ExceedsQuota($reservationSeries, $user, $schedule, $this->reservationViewRepository)) {
Log::Debug('Quota exceeded. %s', $quota->ToString());
return new ReservationRuleResult(false, Resources::GetInstance()->GetString('QuotaExceeded'));
}
}
return new ReservationRuleResult();
}
/**
* @param ReservationSeries $reservationSeries
*/
function Notify($reservationSeries)
{
$owner = null;
$instance = $reservationSeries->CurrentInstance();
foreach ($instance->UnchangedInvitees() as $userId) {
if ($owner == null) {
$owner = $this->userRepository->LoadById($reservationSeries->UserId());
}
$invitee = $this->userRepository->LoadById($userId);
$message = new InviteeAddedEmail($owner, $invitee, $reservationSeries, $this->attributeRepository);
ServiceLocator::GetEmailService()->Send($message);
}
}
/**
* @param ReservationSeries $reservationSeries
* @return ReservationRuleResult
*/
public function Validate($reservationSeries)
{
$resources = Resources::GetInstance();
$errorMessage = new StringBuilder();
$result = $this->attributeService->Validate(CustomAttributeCategory::RESERVATION, $reservationSeries->AttributeValues());
$isValid = $result->IsValid();
foreach ($result->Errors() as $error) {
$errorMessage->AppendLine($error);
}
if (!$isValid) {
$errorMessage->PrependLine($resources->GetString('CustomAttributeErrors'));
}
return new ReservationRuleResult($isValid, $errorMessage->ToString());
}
/**
* @param ReservationSeries $series
* @return bool
*/
private function EvaluateCustomRule($series)
{
Log::Debug('Evaluating custom pre reservation rule');
// make your custom checks here
$configFile = Configuration::Instance()->File('PreReservationExample');
$maxValue = $configFile->GetKey('custom.attribute.max.value');
$customAttributeId = $configFile->GetKey('custom.attribute.id');
$attributeValue = $series->GetAttributeValue($customAttributeId);
$isValid = $attributeValue <= $maxValue;
if ($isValid) {
return new ReservationValidationResult();
}
return new ReservationValidationResult(false, "Value of custom attribute cannot be greater than {$maxValue}");
}
/**
* @param ReservationSeries $reservationSeries
* @return ReservationRuleResult
*/
function Validate($reservationSeries)
{
$status = ReservationStatus::Created;
/** @var BookableResource $resource */
foreach ($reservationSeries->AllResources() as $resource) {
if ($resource->GetRequiresApproval()) {
if (!$this->authorizationService->CanApproveForResource($reservationSeries->BookedBy(), $resource)) {
$status = ReservationStatus::Pending;
break;
}
}
}
$reservationSeries->SetStatusId($status);
return new ReservationRuleResult();
}
public function ScheduleId()
{
if (!empty($this->_scheduleId)) {
return $this->_scheduleId;
}
return parent::ScheduleId();
}
private function PopulateTemplate()
{
$this->Set('UserName', $this->reservationOwner->FullName());
$currentInstance = $this->reservationSeries->CurrentInstance();
$this->Set('StartDate', $currentInstance->StartDate()->ToTimezone($this->timezone));
$this->Set('EndDate', $currentInstance->EndDate()->ToTimezone($this->timezone));
$this->Set('ResourceName', $this->resource->GetName());
$this->Set('Title', $this->reservationSeries->Title());
$this->Set('Description', $this->reservationSeries->Description());
$repeatDates = array();
foreach ($this->reservationSeries->Instances() as $repeated) {
$repeatDates[] = $repeated->StartDate()->ToTimezone($this->timezone);
}
$this->Set('RequiresApproval', $this->reservationSeries->RequiresApproval());
$this->Set('RepeatDates', $repeatDates);
$this->Set('ReservationUrl', Pages::RESERVATION . "?" . QueryStringKeys::REFERENCE_NUMBER . '=' . $currentInstance->ReferenceNumber());
$resourceNames = array();
foreach ($this->reservationSeries->AllResources() as $resource) {
$resourceNames[] = $resource->GetName();
}
$this->Set('ResourceNames', $resourceNames);
$this->Set('Accessories', $this->reservationSeries->Accessories());
$attributes = $this->attributeRepository->GetByCategory(CustomAttributeCategory::RESERVATION);
$attributeValues = array();
foreach ($attributes as $attribute) {
$attributeValues[] = new Attribute($attribute, $this->reservationSeries->GetAttributeValue($attribute->Id()));
}
$this->Set('Attributes', $attributeValues);
}
/**
* @param ReservationSeries $reservationSeries
* @return ReservationRuleResult
*/
public function Validate($reservationSeries)
{
$conflicts = array();
$reservationAccessories = $reservationSeries->Accessories();
if (count($reservationAccessories) == 0) {
// no accessories to be reserved, no need to proceed
return new ReservationRuleResult();
}
/** @var AccessoryToCheck[] $accessories */
$accessories = array();
foreach ($reservationAccessories as $accessory) {
$a = $this->accessoryRepository->LoadById($accessory->AccessoryId);
if (!$a->HasUnlimitedQuantity()) {
$accessories[$a->GetId()] = new AccessoryToCheck($a, $accessory);
}
}
if (count($accessories) == 0) {
// no accessories with limited quantity to be reserved, no need to proceed
return new ReservationRuleResult();
}
$reservations = $reservationSeries->Instances();
/** @var Reservation $reservation */
foreach ($reservations as $reservation) {
Log::Debug("Checking for accessory conflicts, reference number %s", $reservation->ReferenceNumber());
$accessoryReservations = $this->reservationRepository->GetAccessoriesWithin($reservation->Duration());
$aggregation = new AccessoryAggregation($accessories, $reservation->Duration());
foreach ($accessoryReservations as $accessoryReservation) {
if ($reservation->ReferenceNumber() != $accessoryReservation->GetReferenceNumber()) {
$aggregation->Add($accessoryReservation);
}
}
foreach ($accessories as $accessory) {
$alreadyReserved = $aggregation->GetQuantity($accessory->GetId());
$requested = $accessory->QuantityReserved();
if ($requested + $alreadyReserved > $accessory->QuantityAvailable()) {
Log::Debug("Accessory over limit. Reference Number %s, Date %s, Quantity already reserved %s, Quantity requested: %s", $reservation->ReferenceNumber(), $reservation->Duration(), $alreadyReserved, $requested);
array_push($conflicts, array('name' => $accessory->GetName(), 'date' => $reservation->StartDate()));
}
}
}
$thereAreConflicts = count($conflicts) > 0;
if ($thereAreConflicts) {
return new ReservationRuleResult(false, $this->GetErrorString($conflicts));
}
return new ReservationRuleResult();
}
/**
* @see IReservationValidationRule::Validate()
*
* @param ReservationSeries $reservationSeries
* @return ReservationRuleResult
*/
public function Validate($reservationSeries)
{
$r = Resources::GetInstance();
$resources = $reservationSeries->AllResources();
foreach ($resources as $resource) {
if ($resource->HasMinLength()) {
$minDuration = $resource->GetMinLength()->Interval();
$start = $reservationSeries->CurrentInstance()->StartDate();
$end = $reservationSeries->CurrentInstance()->EndDate();
$minEnd = $start->ApplyDifference($minDuration);
if ($end->LessThan($minEnd)) {
return new ReservationRuleResult(false, $r->GetString("MinDurationError", $minDuration));
}
}
}
return new ReservationRuleResult();
}
/**
* @param ReservationSeries $reservationSeries
* @return ReservationRuleResult
*/
public function Validate($reservationSeries)
{
$layout = $this->repository->GetLayout($reservationSeries->Resource()->GetScheduleId(), new ScheduleLayoutFactory($this->session->Timezone));
$startDate = $reservationSeries->CurrentInstance()->StartDate();
$startPeriod = $layout->GetPeriod($startDate);
$endDate = $reservationSeries->CurrentInstance()->EndDate();
$endPeriod = $layout->GetPeriod($endDate);
$errors = new StringBuilder();
if ($startPeriod == null || !$startPeriod->IsReservable() || !$startPeriod->BeginDate()->Equals($startDate)) {
$errors->AppendLine(Resources::GetInstance()->GetString('InvalidStartSlot'));
}
if ($endPeriod == null || !$endPeriod->BeginDate()->Equals($endDate)) {
$errors->AppendLine(Resources::GetInstance()->GetString('InvalidEndSlot'));
}
$errorMessage = $errors->ToString();
return new ReservationRuleResult(strlen($errorMessage) == 0, $errorMessage);
}
/**
* @see IReservationValidationRule::Validate()
*
* @param ReservationSeries $reservationSeries
* @return ReservationRuleResult
*/
public function Validate($reservationSeries)
{
$r = Resources::GetInstance();
$resources = $reservationSeries->AllResources();
foreach ($resources as $resource) {
if ($resource->HasMinNotice()) {
$minStartDate = Date::Now()->ApplyDifference($resource->GetMinNotice()->Interval());
/* @var $instance Reservation */
foreach ($reservationSeries->Instances() as $instance) {
if ($instance->StartDate()->LessThan($minStartDate)) {
return new ReservationRuleResult(false, $r->GetString("MinNoticeError", $minStartDate->Format($r->GeneralDateTimeFormat())));
}
}
}
}
return new ReservationRuleResult();
}
/**
* @param ReservationSeries $reservationSeries
* @return ReservationRuleResult
*/
public function Validate($reservationSeries)
{
$attachments = $reservationSeries->AddedAttachments();
$allowedExtensionsConfig = Configuration::Instance()->GetSectionKey(ConfigSection::UPLOADS, ConfigKeys::UPLOAD_RESERVATION_EXTENSIONS);
if (empty($allowedExtensionsConfig) || empty($attachments)) {
return new ReservationRuleResult();
}
$allowedExtensions = str_replace('.', '', $allowedExtensionsConfig);
$allowedExtensions = str_replace(' ', '', $allowedExtensions);
$allowedExtensionList = explode(',', $allowedExtensions);
foreach ($attachments as $attachment) {
$isValid = in_array($attachment->FileExtension(), $allowedExtensionList);
if (!$isValid) {
return new ReservationRuleResult($isValid, Resources::GetInstance()->GetString('InvalidAttachmentExtension', $allowedExtensionsConfig));
}
}
return new ReservationRuleResult();
}
/**
* @param ReservationSeries $reservationSeries
* @return ReservationRuleResult
*/
public function Validate($reservationSeries)
{
$errorMessage = new StringBuilder();
if ($reservationSeries->GetStartReminder()->Enabled()) {
if (!$this->minutesValid($reservationSeries->GetStartReminder())) {
$errorMessage->AppendLine(Resources::GetInstance()->GetString('InvalidStartReminderTime'));
}
}
if ($reservationSeries->GetEndReminder()->Enabled()) {
if (!$this->minutesValid($reservationSeries->GetEndReminder())) {
$errorMessage->AppendLine(Resources::GetInstance()->GetString('InvalidEndReminderTime'));
}
}
$message = $errorMessage->ToString();
if (strlen($message) > 0) {
return new ReservationRuleResult(false, $message);
}
return new ReservationRuleResult();
}
public function testCanGetSpecificInstanceByDate()
{
$startDate = Date::Parse('2010-02-02 12:15', 'UTC');
$endDate = $startDate->AddDays(1);
$dateRange = new DateRange($startDate, $endDate);
$repeatOptions = $this->getMock('IRepeatOptions');
$series = ReservationSeries::Create(1, new FakeBookableResource(1), null, null, $dateRange, $repeatOptions, new FakeUserSession());
$instance = $series->CurrentInstance();
$this->assertEquals($startDate, $instance->StartDate());
$this->assertEquals($endDate, $instance->EndDate());
}
protected function PopulateTemplate()
{
$currentInstance = $this->reservationSeries->CurrentInstance();
$this->Set('UserName', $this->reservationOwner->FullName());
$this->Set('StartDate', $currentInstance->StartDate()->ToTimezone($this->timezone));
$this->Set('EndDate', $currentInstance->EndDate()->ToTimezone($this->timezone));
$this->Set('ResourceName', $this->reservationSeries->Resource()->GetName());
$img = $this->reservationSeries->Resource()->GetImage();
if (!empty($img)) {
$this->Set('ResourceImage', $this->GetFullImagePath($img));
}
$this->Set('Title', $this->reservationSeries->Title());
$this->Set('Description', $this->reservationSeries->Description());
$repeatDates = array();
if ($this->reservationSeries->IsRecurring()) {
foreach ($this->reservationSeries->Instances() as $repeated) {
$repeatDates[] = $repeated->StartDate()->ToTimezone($this->timezone);
}
}
$this->Set('RepeatDates', $repeatDates);
$this->Set('RequiresApproval', $this->reservationSeries->RequiresApproval());
$this->Set('ReservationUrl', sprintf("%s?%s=%s", Pages::RESERVATION, QueryStringKeys::REFERENCE_NUMBER, $currentInstance->ReferenceNumber()));
$icalUrl = sprintf("export/%s?%s=%s", Pages::CALENDAR_EXPORT, QueryStringKeys::REFERENCE_NUMBER, $currentInstance->ReferenceNumber());
$this->Set('ICalUrl', $icalUrl);
$resourceNames = array();
foreach ($this->reservationSeries->AllResources() as $resource) {
$resourceNames[] = $resource->GetName();
}
$this->Set('ResourceNames', $resourceNames);
$this->Set('Accessories', $this->reservationSeries->Accessories());
$attributes = $this->attributeRepository->GetByCategory(CustomAttributeCategory::RESERVATION);
$attributeValues = array();
foreach ($attributes as $attribute) {
$attributeValues[] = new Attribute($attribute, $this->reservationSeries->GetAttributeValue($attribute->Id()));
}
$this->Set('Attributes', $attributeValues);
$bookedBy = $this->reservationSeries->BookedBy();
if ($bookedBy != null && $bookedBy->UserId != $this->reservationOwner->Id()) {
$this->Set('CreatedBy', new FullName($bookedBy->FirstName, $bookedBy->LastName));
}
}
/**
* @param ReservationSeries $reservationSeries
* @return ReservationRuleResult
*/
public function Validate($reservationSeries)
{
$constraint = Configuration::Instance()->GetSectionKey(ConfigSection::RESERVATION, ConfigKeys::RESERVATION_START_TIME_CONSTRAINT);
if (empty($constraint)) {
$constraint = ReservationStartTimeConstraint::_DEFAULT;
}
if ($constraint == ReservationStartTimeConstraint::NONE) {
return new ReservationRuleResult();
}
$currentInstance = $reservationSeries->CurrentInstance();
$dateThatShouldBeLessThanNow = $currentInstance->StartDate();
if ($constraint == ReservationStartTimeConstraint::CURRENT) {
$timezone = $dateThatShouldBeLessThanNow->Timezone();
/** @var $currentPeriod SchedulePeriod */
$currentPeriod = $this->scheduleRepository->GetLayout($reservationSeries->ScheduleId(), new ScheduleLayoutFactory($timezone))->GetPeriod($currentInstance->EndDate());
$dateThatShouldBeLessThanNow = $currentPeriod->BeginDate();
}
Log::Debug("Start Time Rule: Comparing %s to %s", $dateThatShouldBeLessThanNow, Date::Now());
$startIsInFuture = $dateThatShouldBeLessThanNow->Compare(Date::Now()) >= 0;
return new ReservationRuleResult($startIsInFuture, Resources::GetInstance()->GetString('StartIsInPast'));
}
/**
* @param ReservationSeries $reservationSeries
* @return void
*/
public function Notify($reservationSeries)
{
$resourceAdmins = array();
$applicationAdmins = array();
$groupAdmins = array();
if ($this->SendForResourceAdmins()) {
$resourceAdmins = $this->userViewRepo->GetResourceAdmins($reservationSeries->ResourceId());
}
if ($this->SendForApplicationAdmins()) {
$applicationAdmins = $this->userViewRepo->GetApplicationAdmins();
}
if ($this->SendForGroupAdmins()) {
$groupAdmins = $this->userViewRepo->GetGroupAdmins($reservationSeries->UserId());
}
$admins = array_merge($resourceAdmins, $applicationAdmins, $groupAdmins);
if (count($admins) == 0) {
// skip if there is nobody to send to
return;
}
$owner = $this->userRepo->LoadById($reservationSeries->UserId());
$resource = $reservationSeries->Resource();
$adminIds = array();
/** @var $admin UserDto */
foreach ($admins as $admin) {
$id = $admin->Id();
if (array_key_exists($id, $adminIds) || $id == $owner->Id()) {
// only send to each person once
continue;
}
$adminIds[$id] = true;
$message = $this->GetMessage($admin, $owner, $reservationSeries, $resource);
ServiceLocator::GetEmailService()->Send($message);
}
}
/**
* @param ReservationSeries $reservationSeries
* @return ReservationRuleResult
*/
public function Validate($reservationSeries)
{
$errorMessage = new StringBuilder();
foreach ($reservationSeries->AllResources() as $resource) {
if (!$resource->HasMaxParticipants()) {
continue;
}
foreach ($reservationSeries->Instances() as $instance) {
$numberOfParticipants = count($instance->Participants());
Log::Debug('ResourceParticipationRule Resource=%s,InstanceId=%s,MaxParticipants=%s,CurrentParticipants=%s', $resource->GetName(), $instance->ReservationId(), $resource->GetMaxParticipants(), $numberOfParticipants);
if ($numberOfParticipants > $resource->GetMaxParticipants()) {
$errorMessage->AppendLine(Resources::GetInstance()->GetString('MaxParticipantsError', array($resource->GetName(), $resource->GetMaxParticipants())));
continue;
}
}
}
$message = $errorMessage->ToString();
if (strlen($message) > 0) {
return new ReservationRuleResult(false, $message);
}
return new ReservationRuleResult();
}
public function BuildReservation()
{
$userId = $this->_page->GetUserId();
$primaryResourceId = $this->_page->GetResourceId();
$resource = $this->_resourceRepository->LoadById($primaryResourceId);
$title = $this->_page->GetTitle();
$description = $this->_page->GetDescription();
$roFactory = new RepeatOptionsFactory();
$repeatOptions = $roFactory->CreateFromComposite($this->_page, $this->userSession->Timezone);
$duration = $this->GetReservationDuration();
/*EXPERIMENT*/
$experiment = $this->_page->getExperiment();
$reservationSeries = ReservationSeries::Create($userId, $resource, $title, $description, $duration, $repeatOptions, $this->userSession, $experiment);
$resourceIds = $this->_page->GetResources();
foreach ($resourceIds as $resourceId) {
if ($primaryResourceId != $resourceId) {
$reservationSeries->AddResource($this->_resourceRepository->LoadById($resourceId));
}
}
$accessories = $this->_page->GetAccessories();
foreach ($accessories as $accessory) {
$reservationSeries->AddAccessory(new ReservationAccessory($accessory->Id, $accessory->Quantity, $accessory->Name));
}
$attributes = $this->_page->GetAttributes();
foreach ($attributes as $attribute) {
$reservationSeries->AddAttributeValue(new AttributeValue($attribute->Id, $attribute->Value));
}
$participantIds = $this->_page->GetParticipants();
$reservationSeries->ChangeParticipants($participantIds);
$inviteeIds = $this->_page->GetInvitees();
$reservationSeries->ChangeInvitees($inviteeIds);
$reservationSeries->AllowParticipation($this->_page->GetAllowParticipation());
$attachments = $this->_page->GetAttachments();
foreach ($attachments as $attachment) {
if ($attachment != null) {
if ($attachment->IsError()) {
Log::Error('Error attaching file %s. %s', $attachment->OriginalName(), $attachment->Error());
} else {
$att = ReservationAttachment::Create($attachment->OriginalName(), $attachment->MimeType(), $attachment->Size(), $attachment->Contents(), $attachment->Extension(), 0);
$reservationSeries->AddAttachment($att);
}
}
}
if ($this->_page->HasStartReminder()) {
$reservationSeries->AddStartReminder(new ReservationReminder($this->_page->GetStartReminderValue(), $this->_page->GetStartReminderInterval()));
}
if ($this->_page->HasEndReminder()) {
$reservationSeries->AddEndReminder(new ReservationReminder($this->_page->GetEndReminderValue(), $this->_page->GetEndReminderInterval()));
}
return $reservationSeries;
}
public function testSucceedsWhenStartAndEndTimeMatchPeriods()
{
$date = Date::Now();
$dates = new DateRange($date, $date);
$scheduleId = 1232;
$resource = new FakeBookableResource(1);
$resource->SetScheduleId($scheduleId);
$series = ReservationSeries::Create(1, $resource, null, null, $dates, new RepeatNone(), $this->fakeUser);
$this->scheduleRepository->expects($this->once())->method('GetLayout')->with($this->equalTo($scheduleId), $this->equalTo(new ScheduleLayoutFactory($this->fakeUser->Timezone)))->will($this->returnValue($this->layout));
$period = new SchedulePeriod($date, $date);
$this->layout->expects($this->at(0))->method('GetPeriod')->with($this->equalTo($series->CurrentInstance()->StartDate()))->will($this->returnValue($period));
$this->layout->expects($this->at(1))->method('GetPeriod')->with($this->equalTo($series->CurrentInstance()->EndDate()))->will($this->returnValue($period));
$result = $this->rule->Validate($series);
$this->assertTrue($result->IsValid());
}
/**
* @param ReservationSeries $reservationSeries
* @return ReservationRuleResult
*/
public function Validate($reservationSeries)
{
$conflicts = array();
$reservations = $reservationSeries->Instances();
$bufferTime = $reservationSeries->MaxBufferTime();
$keyedResources = array();
foreach ($reservationSeries->AllResources() as $resource) {
$keyedResources[$resource->GetId()] = $resource;
}
/** @var Reservation $reservation */
foreach ($reservations as $reservation) {
Log::Debug("Checking for reservation conflicts, reference number %s", $reservation->ReferenceNumber());
$startDate = $reservation->StartDate();
$endDate = $reservation->EndDate();
if ($bufferTime != null && !$reservationSeries->BookedBy()->IsAdmin) {
$startDate = $startDate->SubtractInterval($bufferTime);
$endDate = $endDate->AddInterval($bufferTime);
}
$existingItems = $this->strategy->GetItemsBetween($startDate, $endDate);
/** @var IReservedItemView $existingItem */
foreach ($existingItems as $existingItem) {
if (($bufferTime == null || $reservationSeries->BookedBy()->IsAdmin) && ($existingItem->GetStartDate()->Equals($reservation->EndDate()) || $existingItem->GetEndDate()->Equals($reservation->StartDate()))) {
continue;
}
if ($this->IsInConflict($reservation, $reservationSeries, $existingItem, $keyedResources)) {
Log::Debug("Reference number %s conflicts with existing %s with id %s", $reservation->ReferenceNumber(), get_class($existingItem), $existingItem->GetId());
array_push($conflicts, $existingItem);
}
}
}
$thereAreConflicts = count($conflicts) > 0;
if ($thereAreConflicts) {
return new ReservationRuleResult(false, $this->GetErrorString($conflicts));
}
return new ReservationRuleResult();
}
private function GetHourLongReservation($startDate, $endDate, $resourceId1 = null, $resourceId2 = null, $scheduleId = null)
{
$userId = 12;
$resource1 = empty($resourceId1) ? 13 : $resourceId1;
$resource2 = empty($resourceId2) ? 14 : $resourceId2;
$schedule = empty($scheduleId) ? 1 : $scheduleId;
$hourLongReservation = new DateRange($startDate, $endDate, $this->tz);
$resource = new FakeBookableResource($resource1);
$resource->SetScheduleId($schedule);
$series = ReservationSeries::Create($userId, $resource, null, null, $hourLongReservation, new RepeatNone(), new FakeUserSession());
$series->AddResource(new FakeBookableResource($resource2));
return $series;
}
/**
* @param ReservationSeries $reservationSeries
* @return int newly created series_id
*/
private function InsertSeries(ReservationSeries $reservationSeries)
{
$database = ServiceLocator::GetDatabase();
$insertReservationSeries = new AddReservationSeriesCommand(Date::Now(), $reservationSeries->Title(), $reservationSeries->Description(), $reservationSeries->RepeatOptions()->RepeatType(), $reservationSeries->RepeatOptions()->ConfigurationString(), ReservationTypes::Reservation, $reservationSeries->StatusId(), $reservationSeries->UserId(), $reservationSeries->GetAllowParticipation());
$reservationSeriesId = $database->ExecuteInsert($insertReservationSeries);
$reservationSeries->WithSeriesId($reservationSeriesId);
$insertReservationResource = new AddReservationResourceCommand($reservationSeriesId, $reservationSeries->ResourceId(), ResourceLevel::Primary);
$database->Execute($insertReservationResource);
foreach ($reservationSeries->AdditionalResources() as $resource) {
$insertReservationResource = new AddReservationResourceCommand($reservationSeriesId, $resource->GetResourceId(), ResourceLevel::Additional);
$database->Execute($insertReservationResource);
}
foreach ($reservationSeries->Accessories() as $accessory) {
$insertAccessory = new AddReservationAccessoryCommand($accessory->AccessoryId, $accessory->QuantityReserved, $reservationSeriesId);
$database->Execute($insertAccessory);
}
foreach ($reservationSeries->AttributeValues() as $attribute) {
$insertAttributeValue = new AddAttributeValueCommand($attribute->AttributeId, $attribute->Value, $reservationSeriesId, CustomAttributeCategory::RESERVATION);
$database->Execute($insertAttributeValue);
}
foreach ($reservationSeries->AddedAttachments() as $attachment) {
$this->AddReservationAttachment($attachment);
}
if ($reservationSeries->GetStartReminder()->Enabled()) {
$reminder = $reservationSeries->GetStartReminder();
$insertAccessory = new AddReservationReminderCommand($reservationSeriesId, $reminder->MinutesPrior(), ReservationReminderType::Start);
$database->Execute($insertAccessory);
}
if ($reservationSeries->GetEndReminder()->Enabled()) {
$reminder = $reservationSeries->GetEndReminder();
$insertAccessory = new AddReservationReminderCommand($reservationSeriesId, $reminder->MinutesPrior(), ReservationReminderType::End);
$database->Execute($insertAccessory);
}
return $reservationSeriesId;
}
/**
* @param ReservationSeries $series
* @param IRepeatOptions $targetRepeatOptions
* @return bool
*/
public function CanChangeRepeatTo($series, $targetRepeatOptions)
{
$this->hasSameConfiguration = $targetRepeatOptions->HasSameConfigurationAs($series->RepeatOptions());
return parent::CanChangeRepeatTo($series, $targetRepeatOptions);
}
/**
* @param ReservationSeries $reservationSeries
* @return ReservationRuleResult
*/
public function Validate($reservationSeries)
{
$currentInstance = $reservationSeries->CurrentInstance();
$startIsBeforeEnd = $currentInstance->StartDate()->LessThan($currentInstance->EndDate());
return new ReservationRuleResult($startIsBeforeEnd, Resources::GetInstance()->GetString('StartDateBeforeEndDateRule'));
}
