/**
* @param ReservationSeries $reservationSeries
* @return void
*/
public function Notify($reservationSeries)
{
$resourceAdmins = array();
$applicationAdmins = array();
$groupAdmins = array();
if ($this->SendForResourceAdmins($reservationSeries)) {
$resourceAdmins = $this->userViewRepo->GetResourceAdmins($reservationSeries->ResourceId());
}
if ($this->SendForApplicationAdmins($reservationSeries)) {
$applicationAdmins = $this->userViewRepo->GetApplicationAdmins();
}
if ($this->SendForGroupAdmins($reservationSeries)) {
$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);
}
}
public function Validate($reservationSeries)
{
if ($this->userSession->IsAdmin) {
Log::Debug('User is application admin. Skipping check. UserId=%s', $this->userSession->UserId);
return new ReservationRuleResult(true);
}
if ($this->userSession->IsGroupAdmin || $this->userSession->IsResourceAdmin || $this->userSession->IsScheduleAdmin) {
if ($this->userSession->IsGroupAdmin) {
$user = $this->userRepository->LoadById($this->userSession->UserId);
$reservationUser = $this->userRepository->LoadById($reservationSeries->UserId());
if ($user->IsAdminFor($reservationUser)) {
Log::Debug('User is admin for reservation user. Skipping check. UserId=%s', $this->userSession->UserId);
return new ReservationRuleResult(true);
}
}
if ($this->userSession->IsResourceAdmin || $this->userSession->IsScheduleAdmin) {
$user = $this->userRepository->LoadById($this->userSession->UserId);
$isResourceAdmin = true;
foreach ($reservationSeries->AllResources() as $resource) {
if (!$user->IsResourceAdminFor($resource)) {
$isResourceAdmin = false;
break;
}
}
if ($isResourceAdmin) {
Log::Debug('User is admin for all resources. Skipping check. UserId=%s', $this->userSession->UserId);
return new ReservationRuleResult(true);
}
}
}
return $this->rule->Validate($reservationSeries);
}
/**
* @param IResource $resource
* @return bool
*/
public function ShouldInclude($resource)
{
if ($resource->GetStatusId() != ResourceStatus::AVAILABLE) {
$user = $this->userRepository->LoadById($this->user->UserId);
return $user->IsResourceAdminFor($resource);
}
return true;
}
public function LoadById($groupId)
{
$user = $this->userRepository->LoadById($this->userSession->UserId);
if ($user->IsGroupAdminFor($groupId)) {
return parent::LoadById($groupId);
}
return Group::Null();
}
public function testGetsUserByPublicId()
{
$expected = new FakeUser();
$publicId = uniqid();
$this->userRepo->expects($this->once())->method('LoadByPublicId')->with($this->equalTo($publicId))->will($this->returnValue($expected));
$actual = $this->service->GetUser($publicId);
$this->assertEquals($expected, $actual);
}
/**
* @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 $pageNumber int
* @param $pageSize int
* @param $filter ReservationFilter
* @param $user UserSession
* @return PageableData|ReservationItemView[]
*/
public function LoadFiltered($pageNumber, $pageSize, $filter, $user)
{
$groupIds = array();
$groups = $this->userRepository->LoadGroups($user->UserId, RoleLevel::RESOURCE_ADMIN);
foreach ($groups as $group) {
$groupIds[] = $group->GroupId;
}
$filter->_And(new SqlFilterIn(new SqlFilterColumn(TableNames::RESOURCES, ColumnNames::RESOURCE_ADMIN_GROUP_ID), $groupIds));
return $this->reservationViewRepository->GetList($pageNumber, $pageSize, null, null, $filter->GetFilter());
}
public function Activate($activationCode)
{
$userId = $this->activationRepository->FindUserIdByCode($activationCode);
$this->activationRepository->DeleteActivation($activationCode);
if ($userId != null) {
$user = $this->userRepository->LoadById($userId);
$user->Activate();
$this->userRepository->Update($user);
return new ActivationResult(true, $user);
}
return new ActivationResult(false);
}
public function Bind(IReservationComponentInitializer $initializer)
{
$userId = $initializer->GetOwnerId();
$currentUser = $initializer->CurrentUser();
$canChangeUser = $this->reservationAuthorization->CanChangeUsers($currentUser);
$initializer->SetCanChangeUser($canChangeUser);
$reservationUser = $this->userRepository->GetById($userId);
$initializer->SetReservationUser($reservationUser);
$hideUser = Configuration::Instance()->GetSectionKey(ConfigSection::PRIVACY, ConfigKeys::PRIVACY_HIDE_USER_DETAILS, new BooleanConverter());
$initializer->ShowUserDetails(!$hideUser || $currentUser->IsAdmin);
$initializer->SetShowParticipation(!$hideUser || $currentUser->IsAdmin || $currentUser->IsGroupAdmin);
}
/**
* @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);
}
}
public function Add(Schedule $schedule, $copyLayoutFromScheduleId)
{
$user = $this->repo->LoadById($this->user->UserId);
if (!$user->IsInRole(RoleLevel::SCHEDULE_ADMIN)) {
throw new Exception(sprintf('Schedule Add Failed. User %s does not have admin access.', $this->user->UserId));
}
foreach ($user->Groups() as $group) {
if ($group->IsScheduleAdmin) {
$schedule->SetAdminGroupId($group->GroupId);
break;
}
}
parent::Add($schedule, $copyLayoutFromScheduleId);
}
public function testBindsUserData()
{
$userDto = new UserDto($this->userId, 'f', 'l', 'email');
$this->initializer->expects($this->any())->method('CurrentUser')->will($this->returnValue($this->fakeUser));
$this->initializer->expects($this->once())->method('GetOwnerId')->will($this->returnValue($this->userId));
$this->initializer->expects($this->once())->method('CurrentUser')->will($this->returnValue($this->fakeUser));
$this->userRepository->expects($this->once())->method('GetById')->with($this->equalTo($this->userId))->will($this->returnValue($userDto));
$this->reservationAuthorization->expects($this->once())->method('CanChangeUsers')->with($this->fakeUser)->will($this->returnValue(true));
$this->fakeConfig->SetSectionKey(ConfigSection::PRIVACY, ConfigKeys::PRIVACY_HIDE_USER_DETAILS, 'true');
$this->initializer->expects($this->once())->method('SetShowParticipation')->with($this->equalTo(false));
$this->initializer->expects($this->once())->method('SetCanChangeUser')->with($this->equalTo(true));
$this->initializer->expects($this->once())->method('SetReservationUser')->with($this->equalTo($userDto));
$binder = new ReservationUserBinder($this->userRepository, $this->reservationAuthorization);
$binder->Bind($this->initializer);
}
public function testGetsScheduleResourcesUserHasAdminRightsTo()
{
$scheduleId = 100;
$user = $this->getMock('User');
$this->userRepository->expects($this->once())->method('LoadById')->with($this->equalTo($this->fakeUser->UserId))->will($this->returnValue($user));
$ra = new FakeResourceAccess();
$this->db->SetRows($ra->GetRows());
$user->expects($this->at(0))->method('IsResourceAdminFor')->with($this->equalTo($ra->_Resources[0]))->will($this->returnValue(false));
$user->expects($this->at(1))->method('IsResourceAdminFor')->with($this->equalTo($ra->_Resources[1]))->will($this->returnValue(true));
$repo = new ResourceAdminResourceRepository($this->userRepository, $this->fakeUser);
$resources = $repo->GetScheduleResources($scheduleId);
$this->assertTrue($this->db->ContainsCommand(new GetScheduleResourcesCommand($scheduleId)));
$this->assertEquals(1, count($resources));
$this->assertEquals(2, $resources[0]->GetId());
}
/**
* @param $pageNumber int
* @param $pageSize int
* @param $filter ReservationFilter
* @param $userSession UserSession
* @return PageableData|ReservationItemView[]
*/
public function LoadFiltered($pageNumber, $pageSize, $filter, $userSession)
{
$user = $this->userRepository->LoadById($userSession->UserId);
$adminGroups = $user->GetAdminGroups();
$groupIds = array();
foreach ($adminGroups as $group) {
$groupIds[] = $group->GroupId;
}
$command = new GetFullGroupReservationListCommand($groupIds);
if ($filter != null) {
$command = new FilterCommand($command, $filter->GetFilter());
}
$builder = array('ReservationItemView', 'Populate');
return PageableDataStore::GetList($command, $builder, $pageNumber, $pageSize);
}
public function testLoadsFilteredResultsAndChecksAuthorizationAgainstPendingReservations()
{
$pageNumber = 1;
$pageSize = 40;
$groups = array(new UserGroup(1, '1'), new UserGroup(5, '5'), new UserGroup(9, '9'), new UserGroup(22, '22'));
$myGroups = array(1, 5, 9, 22);
$this->userRepository->expects($this->once())->method('LoadGroups')->with($this->equalTo($this->fakeUser->UserId), $this->equalTo(RoleLevel::RESOURCE_ADMIN))->will($this->returnValue($groups));
$filter = new ReservationFilter();
$expectedFilter = $filter->GetFilter();
$expectedFilter->_And(new SqlFilterIn(new SqlFilterColumn(TableNames::RESOURCES, ColumnNames::RESOURCE_ADMIN_GROUP_ID), $myGroups));
$data = new PageableData();
$this->reservationViewRepository->expects($this->once())->method('GetList')->with($pageNumber, $pageSize, null, null, $expectedFilter)->will($this->returnValue($data));
$actualData = $this->service->LoadFiltered($pageNumber, $pageSize, $filter, $this->fakeUser);
$this->assertEquals($data, $actualData);
}
public function testDoesNotUpdateScheduleIfUserDoesNotHaveAccess()
{
$user = $this->getMock('User');
$this->userRepository->expects($this->once())->method('LoadById')->with($this->equalTo($this->fakeUser->UserId))->will($this->returnValue($user));
$schedule = new FakeSchedule(1);
$schedule->SetAdminGroupId(2);
$user->expects($this->at(0))->method('IsScheduleAdminFor')->with($this->equalTo($schedule))->will($this->returnValue(false));
$actualEx = null;
try {
$this->repo->Update($schedule);
} catch (Exception $ex) {
$actualEx = $ex;
}
$this->assertNotEmpty($actualEx, "should have thrown an exception");
}
public function testConflictHandlerReportsConflictingReservationAndDoesNotUpdateBlackout()
{
$userId = $this->fakeUser->UserId;
$start = Date::Parse('2011-01-01 01:01:01');
$end = Date::Parse('2011-02-02 02:02:02');
$date = new DateRange($start, $end);
$resourceId = 2;
$resourceIds = array($resourceId);
$title = 'title';
$seriesId = 111;
$blackoutInstanceId = 10;
$series = BlackoutSeries::Create(1, 'old title', new TestDateRange());
$series->WithId($seriesId);
$user = $this->getMock('User');
$user->expects($this->any())->method('IsResourceAdminFor')->with($this->anything())->will($this->returnValue(true));
$this->userRepository->expects($this->once())->method('LoadById')->with($this->equalTo($userId))->will($this->returnValue($user));
$this->reservationViewRepository->expects($this->once())->method('GetBlackoutsWithin')->with($this->equalTo($date))->will($this->returnValue(array()));
$reservation1 = new TestReservationItemView(1, $start, $end, 2);
$reservation2 = new TestReservationItemView(2, $start, $end, 2);
$this->reservationViewRepository->expects($this->once())->method('GetReservationList')->with($this->equalTo($start), $this->equalTo($end))->will($this->returnValue(array($reservation1, $reservation2)));
$this->conflictHandler->expects($this->at(0))->method('Handle')->with($this->equalTo($reservation1))->will($this->returnValue(false));
$this->conflictHandler->expects($this->at(1))->method('Handle')->with($this->equalTo($reservation2))->will($this->returnValue(false));
$this->blackoutRepository->expects($this->never())->method('Update');
$this->blackoutRepository->expects($this->once())->method('LoadByBlackoutId')->with($this->equalTo($blackoutInstanceId))->will($this->returnValue($series));
$result = $this->service->Update($blackoutInstanceId, $date, $resourceIds, $title, $this->conflictHandler, new RepeatNone(), SeriesUpdateScope::FullSeries);
$this->assertFalse($result->WasSuccessful());
}
public function testFirstQuotaExceeded()
{
$scheduleId = 971243;
$timezone = 'America/New_York';
$userId = 10;
$groupId1 = 8287;
$groupId2 = 102;
$user = new FakeUser();
$user->SetGroups(array($groupId1, $groupId2));
$schedule = new Schedule(1, null, null, null, null, $timezone);
$resource = new FakeBookableResource(20);
$resource->SetScheduleId($scheduleId);
$series = ReservationSeries::Create($userId, $resource, null, null, new TestDateRange(), new RepeatNone(), new FakeUserSession());
$series->AddResource(new FakeBookableResource(22));
$quota1 = $this->mockQuota('IQuota');
$quota2 = $this->mockQuota('IQuota');
$quotas = array($quota1, $quota2);
$this->quotaRepository->expects($this->once())->method('LoadAll')->will($this->returnValue($quotas));
$this->userRepository->expects($this->once())->method('LoadById')->with($this->equalTo($userId))->will($this->returnValue($user));
$this->scheduleRepository->expects($this->once())->method('LoadById')->with($this->equalTo($scheduleId))->will($this->returnValue($schedule));
$this->ChecksAgainstQuota($quota1, $series, $this->reservationViewRepository, $schedule, $user, true);
$quota2->expects($this->never())->method('ExceedsQuota');
$rule = new QuotaRule($this->quotaRepository, $this->reservationViewRepository, $this->userRepository, $this->scheduleRepository);
$result = $rule->Validate($series);
$this->assertFalse($result->IsValid(), 'first quotas was exceeded');
}
function testLoginGetsUserDataFromDatabase()
{
$language = 'en_gb';
$this->userRepository->expects($this->once())->method('LoadByUsername')->with($this->equalTo($this->username))->will($this->returnValue($this->user));
LoginTime::$Now = time();
$this->user->Login(LoginTime::Now(), $language);
$this->userRepository->expects($this->once())->method('Update')->with($this->equalTo($this->user));
$this->authorization->expects($this->once())->method('IsApplicationAdministrator')->with($this->equalTo($this->user))->will($this->returnValue(true));
$this->authorization->expects($this->once())->method('IsGroupAdministrator')->with($this->equalTo($this->user))->will($this->returnValue(true));
$this->authorization->expects($this->once())->method('IsResourceAdministrator')->with($this->equalTo($this->user))->will($this->returnValue(true));
$this->authorization->expects($this->once())->method('IsScheduleAdministrator')->with($this->equalTo($this->user))->will($this->returnValue(true));
$context = new WebLoginContext(new LoginData(false, $language));
$actualSession = $this->auth->Login($this->username, $context);
$user = new UserSession($this->id);
$user->FirstName = $this->fname;
$user->LastName = $this->lname;
$user->Email = $this->email;
$user->Timezone = $this->timezone;
$user->HomepageId = $this->homepageId;
$user->IsAdmin = true;
$user->IsGroupAdmin = true;
$user->IsResourceAdmin = true;
$user->IsScheduleAdmin = true;
$user->LanguageCode = $language;
$user->LoginTime = LoginTime::Now();
$user->PublicId = $this->publicId;
$user->ScheduleId = $this->scheduleId;
foreach ($this->groups as $group) {
$user->Groups[] = $group->GroupId;
}
$this->assertEquals($user, $actualSession);
}
public function GetList($pageNumber, $pageSize, $sortField = null, $sortDirection = null, $filter = null)
{
$user = $this->repo->LoadById($this->user->UserId);
if (!$user->IsInRole(RoleLevel::SCHEDULE_ADMIN)) {
return new PageableData();
}
$ids = array();
$filter = new SqlFilterNull();
foreach ($user->Groups() as $group) {
if ($group->IsScheduleAdmin) {
$ids[] = $group->GroupId;
}
}
$filter->_And(new SqlFilterIn(new SqlFilterColumn(TableNames::SCHEDULES_ALIAS, ColumnNames::RESOURCE_ADMIN_GROUP_ID), $ids));
return parent::GetList($pageNumber, $pageSize, $sortField, $sortDirection, $filter);
}
public function testUpdatesUser()
{
$user = new User();
$userId = 1029380;
$fname = 'f';
$lname = 'l';
$username = '******';
$email = '*****@*****.**';
$timezone = 'America/Chicago';
$phone = '123-123-1234';
$organization = 'ou';
$position = 'position';
$extraAttributes = array(UserAttribute::Organization => $organization, UserAttribute::Phone => $phone, UserAttribute::Position => $position);
$this->userRepo->expects($this->once())->method('LoadById')->with($this->equalTo($userId))->will($this->returnValue($user));
$this->userRepo->expects($this->once())->method('Update')->with($this->equalTo($user));
$updatedUser = $this->service->UpdateUser($userId, $username, $email, $fname, $lname, $timezone, $extraAttributes);
$this->assertEquals($user, $updatedUser);
$this->assertEquals($fname, $user->FirstName());
$this->assertEquals($lname, $user->LastName());
$this->assertEquals($timezone, $user->Timezone());
$this->assertEquals($username, $user->Username());
$this->assertEquals($email, $user->EmailAddress());
$this->assertEquals($phone, $user->GetAttribute(UserAttribute::Phone));
$this->assertEquals($organization, $user->GetAttribute(UserAttribute::Organization));
$this->assertEquals($position, $user->GetAttribute(UserAttribute::Position));
}
public function DisableSubscription()
{
$userId = ServiceLocator::GetServer()->GetUserSession()->UserId;
Log::Debug('Disabling calendar subscription for userId: %s', $userId);
$user = $this->userRepository->LoadById($userId);
$user->DisableSubscription();
$this->userRepository->Update($user);
}
public function testWhenActivationCodeIsValid()
{
$userId = 11;
$homepage = Pages::CALENDAR;
$user = new FakeUser($userId);
$user->ChangeDefaultHomePage($homepage);
$user->SetStatus(AccountStatus::AWAITING_ACTIVATION);
$activationCode = uniqid();
$this->activationRepo->expects($this->once())->method('FindUserIdByCode')->with($this->equalTo($activationCode))->will($this->returnValue($userId));
$this->activationRepo->expects($this->once())->method('DeleteActivation')->with($this->equalTo($activationCode));
$this->userRepo->expects($this->once())->method('LoadById')->with($this->equalTo($userId))->will($this->returnValue($user));
$this->userRepo->expects($this->once())->method('Update')->with($this->equalTo($user));
$result = $this->activation->Activate($activationCode);
$this->assertTrue($result->Activated());
$this->assertEquals($user, $result->User());
$this->assertEquals(AccountStatus::ACTIVE, $user->StatusId());
}
public function Login($username, $loginContext)
{
Log::Debug('Logging in with user: %s', $username);
$user = $this->userRepository->LoadByUsername($username);
if ($user->StatusId() == AccountStatus::ACTIVE) {
$loginData = $loginContext->GetData();
$loginTime = LoginTime::Now();
$language = $user->Language();
if (!empty($loginData->Language)) {
$language = $loginData->Language;
}
$user->Login($loginTime, $language);
$this->userRepository->Update($user);
return $this->GetUserSession($user, $loginTime);
}
return new NullUserSession();
}
/**
* @param UserSession $userSession
* @param IResource $resource
* @return bool
*/
public function CanApproveForResource(UserSession $userSession, IResource $resource)
{
if ($userSession->IsAdmin) {
return true;
}
if (!$userSession->IsResourceAdmin) {
return false;
}
$user = $this->userRepository->LoadById($userSession->UserId);
return $user->IsResourceAdminFor($resource);
}
public function Synchronize(AuthenticatedUser $user, $insertOnly = false)
{
if ($this->UserExists($user->UserName(), $user->Email())) {
if ($insertOnly) {
return;
}
$encryptedPassword = $this->_passwordEncryption->EncryptPassword($user->Password());
$command = new UpdateUserFromLdapCommand($user->UserName(), $user->Email(), $user->FirstName(), $user->LastName(), $encryptedPassword->EncryptedPassword(), $encryptedPassword->Salt(), $user->Phone(), $user->Organization(), $user->Title());
ServiceLocator::GetDatabase()->Execute($command);
if ($user->GetGroups() != null) {
$updatedUser = $this->_userRepository->LoadByUsername($user->Username());
$updatedUser->ChangeGroups($user->GetGroups());
$this->_userRepository->Update($updatedUser);
}
} else {
$defaultHomePageId = Configuration::Instance()->GetKey(ConfigKeys::DEFAULT_HOMEPAGE, new IntConverter());
$additionalFields = array('phone' => $user->Phone(), 'organization' => $user->Organization(), 'position' => $user->Title());
$this->Register($user->UserName(), $user->Email(), $user->FirstName(), $user->LastName(), $user->Password(), $user->TimezoneName(), $user->LanguageCode(), empty($defaultHomePageId) ? Pages::DEFAULT_HOMEPAGE_ID : $defaultHomePageId, $additionalFields, array(), $user->GetGroups());
}
}
public function UpdateUser($userId, $username, $email, $firstName, $lastName, $timezone, $extraAttributes)
{
$attributes = new UserAttribute($extraAttributes);
$user = $this->userRepository->LoadById($userId);
$user->ChangeName($firstName, $lastName);
$user->ChangeEmailAddress($email);
$user->ChangeUsername($username);
$user->ChangeTimezone($timezone);
$user->ChangeAttributes($attributes->Get(UserAttribute::Phone), $attributes->Get(UserAttribute::Organization), $attributes->Get(UserAttribute::Position));
$this->userRepository->Update($user);
}
public function LoadBlackout($blackoutId, $userId)
{
$series = $this->blackoutRepository->LoadByBlackoutId($blackoutId);
$user = $this->userRepository->LoadById($userId);
foreach ($series->Resources() as $resource) {
if (!$user->IsResourceAdminFor($resource)) {
return null;
}
}
return $series;
}
