public function __construct(ExistingReservationSeries $series)
{
foreach ($series->Accessories() as $accessory) {
$this->Accessories[] = new ReservationAccessoryView($accessory->AccessoryId, $accessory->QuantityReserved, $accessory->Name, null);
}
foreach ($series->AdditionalResources() as $resource) {
$this->AdditionalResourceIds[] = $resource->GetId();
}
foreach ($series->AddedAttachments() as $attachment) {
$this->Attachments[] = new ReservationAttachmentView($attachment->FileId(), $series->SeriesId(), $attachment->FileName());
}
foreach ($series->AttributeValues() as $av) {
$this->Attributes[] = $av;
}
$this->Description = $series->Description();
$this->EndDate = $series->CurrentInstance()->EndDate();
$this->OwnerId = $series->UserId();
$this->ReferenceNumber = $series->CurrentInstance()->ReferenceNumber();
$this->ReservationId = $series->CurrentInstance()->ReservationId();
$this->ResourceId = $series->ResourceId();
foreach ($series->AllResources() as $resource) {
$this->Resources[] = new ReservationResourceView($resource->GetId(), $resource->GetName(), $resource->GetAdminGroupId(), $resource->GetScheduleId(), $resource->GetScheduleAdminGroupId(), $resource->GetStatusId());
}
$this->ScheduleId = $series->ScheduleId();
$this->SeriesId = $series->SeriesId();
$this->StartDate = $series->CurrentInstance()->StartDate();
$this->StatusId = $series->StatusId();
}
public function testUpdatesReservationAttributeIfTheUserCanEdit()
{
$referenceNumber = 'rn';
$id = 111;
$value = 'new attribute value';
$user = $this->fakeUser;
$resultCollector = new ManageReservationsUpdateAttributeResultCollector();
$reservation = new ExistingReservationSeries();
$reservation->UpdateBookedBy($user);
$reservation->AddAttributeValue(new AttributeValue($id, $value));
$this->persistenceService->expects($this->once())->method('LoadByReferenceNumber')->with($this->equalTo($referenceNumber))->will($this->returnValue($reservation));
$this->reservationHandler->expects($this->once())->method('Handle')->with($this->equalTo($reservation), $this->equalTo($resultCollector));
$result = $this->service->UpdateAttribute($referenceNumber, $id, $value, $user);
}
public function testSendsReservationDeletedEmailIfUserWantsIt()
{
$event = new ReservationDeletedEvent();
$ownerId = 100;
$resourceId = 200;
$resource = new FakeBookableResource($resourceId, 'name');
$reservation = new ExistingReservationSeries();
$reservation->WithOwner($ownerId);
$reservation->WithPrimaryResource($resource);
$userRepo = $this->getMock('IUserRepository');
$attributeRepo = $this->getMock('IAttributeRepository');
$user = $this->LoadsUser($userRepo, $ownerId);
$this->AsksUser($user, $event);
$notification = new OwnerEmailDeletedNotification($userRepo, $attributeRepo);
$notification->Notify($reservation);
$expectedMessage = new ReservationDeletedEmail($user, $reservation, null, $attributeRepo);
$lastMessage = $this->fakeEmailService->_LastMessage;
$this->assertInstanceOf('ReservationDeletedEmail', $lastMessage);
}
public function testLoadsExistingReservationAndUpdatesData()
{
$seriesId = 109809;
$expectedSeries = new ExistingReservationSeries();
$currentDuration = new DateRange(Date::Now()->AddDays(1), Date::Now()->AddDays(2), 'UTC');
$removedResourceId = 190;
$resource = new FakeBookableResource(1);
$additionalId1 = $this->page->resourceIds[0];
$additionalId2 = $this->page->resourceIds[1];
$additional1 = new FakeBookableResource($additionalId1);
$additional2 = new FakeBookableResource($additionalId2);
$reservation = new Reservation($expectedSeries, $currentDuration);
$expectedSeries->WithId($seriesId);
$expectedSeries->WithCurrentInstance($reservation);
$expectedSeries->WithPrimaryResource($resource);
$expectedSeries->WithResource(new FakeBookableResource($removedResourceId));
$expectedSeries->WithAttribute(new AttributeValue(100, 'to be removed'));
$referenceNumber = $this->page->existingReferenceNumber;
$timezone = $this->user->Timezone;
$this->persistenceService->expects($this->once())->method('LoadByReferenceNumber')->with($this->equalTo($referenceNumber))->will($this->returnValue($expectedSeries));
$this->resourceRepository->expects($this->at(0))->method('LoadById')->with($this->equalTo($this->page->resourceId))->will($this->returnValue($resource));
$this->resourceRepository->expects($this->at(1))->method('LoadById')->with($this->equalTo($additionalId1))->will($this->returnValue($additional1));
$this->resourceRepository->expects($this->at(2))->method('LoadById')->with($this->equalTo($additionalId2))->will($this->returnValue($additional2));
$this->page->repeatType = RepeatType::Daily;
$roFactory = new RepeatOptionsFactory();
$repeatOptions = $roFactory->CreateFromComposite($this->page, $this->user->Timezone);
$expectedDuration = DateRange::Create($this->page->GetStartDate() . " " . $this->page->GetStartTime(), $this->page->GetEndDate() . " " . $this->page->GetEndTime(), $timezone);
$attachment = new FakeUploadedFile();
$this->page->attachment = $attachment;
$this->page->hasEndReminder = false;
$existingSeries = $this->presenter->BuildReservation();
$expectedAccessories = array(new ReservationAccessory(1, 2, 'accessoryname'));
$expectedAttributes = array(1 => new AttributeValue(1, 'something'));
$this->assertEquals($seriesId, $existingSeries->SeriesId());
$this->assertEquals($this->page->seriesUpdateScope, $existingSeries->SeriesUpdateScope());
$this->assertEquals($this->page->title, $existingSeries->Title());
$this->assertEquals($this->page->description, $existingSeries->Description());
$this->assertEquals($this->page->userId, $existingSeries->UserId());
$this->assertEquals($resource, $existingSeries->Resource());
$this->assertEquals($repeatOptions, $existingSeries->RepeatOptions());
$this->assertEquals(array($additional1, $additional2), $existingSeries->AdditionalResources());
$this->assertEquals($this->page->participants, $existingSeries->CurrentInstance()->AddedParticipants());
$this->assertEquals($this->page->invitees, $existingSeries->CurrentInstance()->AddedInvitees());
$this->assertTrue($expectedDuration->Equals($existingSeries->CurrentInstance()->Duration()), "Expected: {$expectedDuration} Actual: {$existingSeries->CurrentInstance()->Duration()}");
$this->assertEquals($this->user, $expectedSeries->BookedBy());
$this->assertEquals($expectedAccessories, $existingSeries->Accessories());
$this->assertEquals($expectedAttributes, $existingSeries->AttributeValues());
$expectedAttachment = ReservationAttachment::Create($attachment->OriginalName(), $attachment->MimeType(), $attachment->Size(), $attachment->Contents(), $attachment->Extension(), $seriesId);
$this->assertEquals(array($expectedAttachment), $expectedSeries->AddedAttachments());
$this->assertEquals($this->page->removedFileIds, $existingSeries->RemovedAttachmentIds());
$this->assertEquals(new ReservationReminder($this->page->GetStartReminderValue(), $this->page->GetStartReminderInterval()), $existingSeries->GetStartReminder());
$this->assertEquals(ReservationReminder::None(), $existingSeries->GetEndReminder());
}
/**
* @param ExistingReservationSeries $series
* @return mixed|null|string
*/
private function CheckCapacityAndReturnAnyError($series)
{
foreach ($series->AllResources() as $resource) {
if (!$resource->HasMaxParticipants()) {
continue;
}
/** @var $instance Reservation */
foreach ($series->Instances() as $instance) {
$numberOfParticipants = count($instance->Participants());
if ($numberOfParticipants > $resource->GetMaxParticipants()) {
return Resources::GetInstance()->GetString('MaxParticipantsError', array($resource->GetName(), $resource->GetMaxParticipants()));
}
}
}
return null;
}
public function Execute(Database $database)
{
if (!$this->series->RequiresNewSeries()) {
$database->Execute($this->command);
}
}
/**
* @param ExistingReservationSeries $series
* @return mixed
*/
public function EarliestDateToKeep($series)
{
$startTimeConstraint = Configuration::Instance()->GetSectionKey(ConfigSection::RESERVATION, ConfigKeys::RESERVATION_START_TIME_CONSTRAINT);
if (ReservationStartTimeConstraint::IsCurrent($startTimeConstraint)) {
return $series->CurrentInstance()->StartDate();
}
if (ReservationStartTimeConstraint::IsNone($startTimeConstraint)) {
return Date::Min();
}
return Date::Now();
}
/**
* @param ExistingReservationSeries $reservationSeries
*/
public function HandleReservation($reservationSeries)
{
Log::Debug("Deleting reservation %s", $reservationSeries->CurrentInstance()->ReferenceNumber());
$this->handler->Handle($reservationSeries, $this->page);
}
public function testNoConflictsIfReservationExistsAtSameTimeForDifferentResource()
{
$resourceId1 = 1;
$resourceId2 = 2;
$resourceId3 = 3;
$currentId = 19;
$currentDate = new DateRange(Date::Now()->AddDays(10), Date::Now()->AddDays(15));
$current = new TestReservation('ref', $currentDate);
$current->SetReservationId($currentId);
$series = new ExistingReservationSeries();
$series->WithPrimaryResource(new FakeBookableResource($resourceId1));
$series->WithResource(new FakeBookableResource($resourceId2));
$series->WithCurrentInstance($current);
$reservations = array(new TestReservationItemView($currentId + 1, Date::Now(), Date::Now(), $resourceId3));
$this->strategy->expects($this->once())->method('GetItemsBetween')->with($this->anything(), $this->anything())->will($this->returnValue($reservations));
$rule = new ExistingResourceAvailabilityRule($this->strategy, $this->timezone);
$ruleResult = $rule->Validate($series);
$this->assertTrue($ruleResult->IsValid());
}
public function testSendsReservationDeletedEmailIfAdminWantsIt()
{
$ownerId = 100;
$resourceId = 200;
$resource = new FakeBookableResource($resourceId, 'name');
$reservation = new ExistingReservationSeries();
$reservation->WithOwner($ownerId);
$reservation->WithPrimaryResource($resource);
$owner = new FakeUser($ownerId);
$admin1 = new UserDto(1, 'f', 'l', 'e');
$admin2 = new UserDto(2, 'f', 'l', 'e');
$admin3 = new UserDto(3, 'f', 'l', 'e');
$admin4 = new UserDto(4, 'f', 'l', 'e');
$admin5 = new UserDto(5, 'f', 'l', 'e');
$admin6 = new UserDto(6, 'f', 'l', 'e');
$resourceAdmins = array($admin1, $admin2, $admin3);
$appAdmins = array($admin3, $admin4, $admin1);
$groupAdmins = array($admin5, $admin6, $admin2);
$attributeRepo = $this->getMock('IAttributeRepository');
$userRepo = $this->getMock('IUserRepository');
$userRepo->expects($this->once())->method('LoadById')->with($this->equalTo($ownerId))->will($this->returnValue($owner));
$userRepo->expects($this->once())->method('GetResourceAdmins')->with($this->equalTo($resourceId))->will($this->returnValue($resourceAdmins));
$userRepo->expects($this->once())->method('GetApplicationAdmins')->will($this->returnValue($appAdmins));
$userRepo->expects($this->once())->method('GetGroupAdmins')->with($this->equalTo($ownerId))->will($this->returnValue($groupAdmins));
$this->EnableNotifyFor(ConfigKeys::NOTIFY_DELETE_RESOURCE_ADMINS);
$this->EnableNotifyFor(ConfigKeys::NOTIFY_DELETE_APPLICATION_ADMINS);
$this->EnableNotifyFor(ConfigKeys::NOTIFY_DELETE_GROUP_ADMINS);
$notification = new AdminEmailDeletedNotification($userRepo, $userRepo, $attributeRepo);
$notification->Notify($reservation);
$expectedMessage1 = new ReservationDeletedEmailAdmin($admin1, $owner, $reservation, $resource, $attributeRepo);
$this->assertEquals(6, count($this->fakeEmailService->_Messages), "send one per person, no duplicates");
$this->isInstanceOf('ReservationDeletedEmailAdmin', $this->fakeEmailService->_Messages[0]);
$this->isInstanceOf('ReservationDeletedEmailAdmin', $this->fakeEmailService->_Messages[1]);
}
public function testDeleteSeries()
{
$seriesId = 981;
$eventSeries = new ExistingReservationSeries();
$eventSeries->WithId($seriesId);
$builder = new ExistingReservationSeriesBuilder();
$builder->WithEvent(new SeriesDeletedEvent($eventSeries));
$series = $builder->BuildTestVersion();
$series->WithId($seriesId);
$this->repository->Delete($series);
$deleteSeriesCommand = new DeleteSeriesCommand($eventSeries->SeriesId(), Date::Now());
$this->assertEquals(1, count($this->db->_Commands));
$this->assertTrue(in_array($deleteSeriesCommand, $this->db->_Commands));
}
public function AddEvent(SeriesEvent $event)
{
parent::AddEvent($event);
}
public function testChangeAccessories()
{
$accessory1 = new ReservationAccessory(1, 100);
$accessory2 = new ReservationAccessory(2, 22);
$accessory3 = new ReservationAccessory(3, 3);
$accessory4 = new ReservationAccessory(4, 444);
$accessory1WithDifferentQuantity = new ReservationAccessory(1, 99);
$series = new ExistingReservationSeries();
$series->WithAccessory($accessory1);
$series->WithAccessory($accessory2);
$series->WithAccessory($accessory3);
$accessories = array($accessory1WithDifferentQuantity, $accessory2, $accessory4);
$series->ChangeAccessories($accessories);
$this->assertEquals($accessories, $series->Accessories());
$events = $series->GetEvents();
$remove1 = new AccessoryRemovedEvent($accessory1, $series);
$remove3 = new AccessoryRemovedEvent($accessory3, $series);
$add1 = new AccessoryAddedEvent($accessory1WithDifferentQuantity, $series);
$add4 = new AccessoryAddedEvent($accessory4, $series);
$this->assertTrue(in_array($remove1, $events));
$this->assertTrue(in_array($add1, $events));
$this->assertTrue(in_array($add4, $events));
$this->assertTrue(in_array($remove3, $events));
$removeIndex = array_search($remove1, $events);
$addIndex = array_search($add1, $events);
$this->assertTrue($removeIndex < $addIndex, "need to remove before adding to avoid key conflicts");
}
