public function testBuildView()
{
$firstUser = new User();
$firstUser->setUsername('1');
$secondUser = new User();
$secondUser->setUsername('2');
$firstCalendar = new Calendar();
$firstCalendar->setOwner($firstUser);
$secondCalendar = new Calendar();
$secondCalendar->setOwner($secondUser);
$firstEvent = new CalendarEvent();
$firstEvent->setCalendar($firstCalendar);
$secondEvent = new CalendarEvent();
$secondEvent->setCalendar($secondCalendar);
$formData = [$firstEvent, $secondEvent];
$transformedData = [$firstUser, $secondUser];
$form = $this->getMock('Symfony\\Component\\Form\\FormInterface');
$form->expects($this->once())->method('getData')->will($this->returnValue($formData));
$this->transformer->expects($this->once())->method('transform')->with($formData)->will($this->returnValue($transformedData));
$converter = $this->getMock('Oro\\Bundle\\FormBundle\\Autocomplete\\ConverterInterface');
$converter->expects($this->any())->method('convertItem')->will($this->returnCallback([$this, 'convertEvent']));
$formView = new FormView();
$expectedSelectedData = json_encode([$this->convertEvent($firstUser), $this->convertEvent($secondUser)]);
$this->type->buildView($formView, $form, ['converter' => $converter]);
$this->assertArrayHasKey('attr', $formView->vars);
$this->assertEquals(['data-selected-data' => $expectedSelectedData], $formView->vars['attr']);
}
/**
* {@inheritdoc}
*/
public function reverseTransform($value)
{
if (!$value) {
return [];
}
/** @var CalendarRepository $calendarRepository */
$calendarRepository = $this->registry->getRepository('OroCalendarBundle:Calendar');
$organizationId = $this->securityFacade->getOrganizationId();
if (!$organizationId) {
throw new TransformationFailedException('Can\'t get current organization');
}
$events = new ArrayCollection();
/** @var User $user */
$userIds = [];
foreach ($value as $user) {
$userIds[] = $user->getId();
}
$calendars = $calendarRepository->findDefaultCalendars($userIds, $organizationId);
foreach ($calendars as $calendar) {
$event = new CalendarEvent();
$event->setCalendar($calendar);
$events->add($event);
}
return $events;
}
/**
* @dataProvider supportedMethods
*/
public function testProcessValidDataWithTargetEntityActivity($method)
{
$targetEntity = new User();
ReflectionUtil::setId($targetEntity, 123);
$organization = new Organization();
ReflectionUtil::setId($organization, 1);
$targetEntity->setOrganization($organization);
$defaultCalendar = $this->getMockBuilder('Oro\\Bundle\\CalendarBundle\\Entity\\Calendar')->disableOriginalConstructor()->getMock();
$this->entity->setCalendar($defaultCalendar);
$this->entityRoutingHelper->expects($this->once())->method('getEntityClassName')->will($this->returnValue(get_class($targetEntity)));
$this->entityRoutingHelper->expects($this->once())->method('getEntityId')->will($this->returnValue($targetEntity->getId()));
$this->entityRoutingHelper->expects($this->once())->method('getAction')->will($this->returnValue('activity'));
$this->request->setMethod($method);
$this->form->expects($this->once())->method('setData')->with($this->identicalTo($this->entity));
$this->form->expects($this->once())->method('submit')->with($this->identicalTo($this->request));
$this->form->expects($this->once())->method('isValid')->will($this->returnValue(true));
$this->entityRoutingHelper->expects($this->once())->method('getEntityReference')->with(get_class($targetEntity), $targetEntity->getId())->will($this->returnValue($targetEntity));
$this->activityManager->expects($this->once())->method('addActivityTarget')->with($this->identicalTo($this->entity), $this->identicalTo($targetEntity));
$this->form->expects($this->once())->method('get')->will($this->returnValue($this->form));
$this->form->expects($this->once())->method('getData');
$this->om->expects($this->once())->method('persist')->with($this->identicalTo($this->entity));
$this->om->expects($this->once())->method('flush');
$this->assertTrue($this->handler->process($this->entity));
$this->assertSame($defaultCalendar, $this->entity->getCalendar());
}
/**
* Process form
*
* @param CalendarEvent $entity
* @throws \LogicException
*
* @return bool True on successful processing, false otherwise
*/
public function process(CalendarEvent $entity)
{
if (!$entity->getCalendar()) {
if ($this->securityFacade->getLoggedUser() && $this->securityFacade->getOrganization()) {
/** @var Calendar $defaultCalendar */
$defaultCalendar = $this->manager->getRepository('OroCalendarBundle:Calendar')->findDefaultCalendar($this->securityFacade->getLoggedUser()->getId(), $this->securityFacade->getOrganization()->getId());
$entity->setCalendar($defaultCalendar);
} else {
throw new \LogicException('Current user did not define');
}
}
$this->form->setData($entity);
if (in_array($this->request->getMethod(), array('POST', 'PUT'))) {
$this->form->submit($this->request);
if ($this->form->isValid()) {
$targetEntityClass = $this->entityRoutingHelper->getEntityClassName($this->request);
if ($targetEntityClass) {
$targetEntityId = $this->entityRoutingHelper->getEntityId($this->request);
$targetEntity = $this->entityRoutingHelper->getEntityReference($targetEntityClass, $targetEntityId);
$action = $this->entityRoutingHelper->getAction($this->request);
if ($action === 'activity') {
$this->activityManager->addActivityTarget($entity, $targetEntity);
}
if ($action === 'assign' && $targetEntity instanceof User && $targetEntityId !== $this->securityFacade->getLoggedUserId()) {
/** @var Calendar $defaultCalendar */
$defaultCalendar = $this->manager->getRepository('OroCalendarBundle:Calendar')->findDefaultCalendar($targetEntity->getId(), $targetEntity->getOrganization()->getId());
$entity->setCalendar($defaultCalendar);
}
}
$this->onSuccess($entity);
return true;
}
}
return false;
}
/**
* {@inheritdoc}
*/
public function load(ObjectManager $manager)
{
$user = $manager->getRepository('OroUserBundle:User')->findOneByUsername('admin');
$organization = $manager->getRepository('OroOrganizationBundle:Organization')->getFirst();
$calendar = $manager->getRepository('OroCalendarBundle:Calendar')->findDefaultCalendar($user->getId(), $organization->getId());
$calendarEvent = new CalendarEvent();
$calendarEvent->setCalendar($calendar);
$calendarEvent->setTitle(self::CALENDAR_EVENT_TITLE);
$calendarEvent->setStart(new \DateTime('tomorrow'));
$calendarEvent->setEnd(new \DateTime('tomorrow + 1hour'));
$calendarEvent->setAllDay(false);
$manager->persist($calendarEvent);
$manager->flush();
}
public function testTransform()
{
$this->assertNull($this->transformer->transform(null));
$firstUser = new User();
$firstUser->setUsername('1');
$secondUser = new User();
$secondUser->setUsername('2');
$firstCalendar = new Calendar();
$firstCalendar->setOwner($firstUser);
$secondCalendar = new Calendar();
$secondCalendar->setOwner($secondUser);
$firstEvent = new CalendarEvent();
$firstEvent->setCalendar($firstCalendar);
$secondEvent = new CalendarEvent();
$secondEvent->setCalendar($secondCalendar);
$this->assertEquals([$firstUser, $secondUser], $this->transformer->transform([$firstEvent, $secondEvent])->toArray());
}
/**
* Links an event with a calendar by its alias and id
*
* @param CalendarEvent $event
* @param string $calendarAlias
* @param int $calendarId
*
* @throws \LogicException
* @throws ForbiddenException
*/
public function setCalendar(CalendarEvent $event, $calendarAlias, $calendarId)
{
if ($calendarAlias === Calendar::CALENDAR_ALIAS) {
$calendar = $event->getCalendar();
if (!$calendar || $calendar->getId() !== $calendarId) {
$event->setCalendar($this->findCalendar($calendarId));
}
} elseif (in_array($calendarAlias, [SystemCalendar::CALENDAR_ALIAS, SystemCalendar::PUBLIC_CALENDAR_ALIAS])) {
$systemCalendar = $this->findSystemCalendar($calendarId);
//@TODO: Added permission verification
if ($systemCalendar->isPublic() && !$this->calendarConfig->isPublicCalendarEnabled()) {
throw new ForbiddenException('Public calendars are disabled.');
}
if (!$systemCalendar->isPublic() && !$this->calendarConfig->isSystemCalendarEnabled()) {
throw new ForbiddenException('System calendars are disabled.');
}
$event->setSystemCalendar($systemCalendar);
} else {
throw new \LogicException(sprintf('Unexpected calendar alias: "%s". CalendarId: %d.', $calendarAlias, $calendarId));
}
}
/**
* Adds an event to this calendar.
*
* @param CalendarEvent $event
*
* @return self
*/
public function addEvent(CalendarEvent $event)
{
$this->events[] = $event;
$event->setCalendar($this);
return $this;
}
public function testSetCalendar()
{
$calendar = new Calendar();
$systemCalendar = new SystemCalendar();
$obj = new CalendarEvent();
$this->assertNull($obj->getCalendar());
$this->assertNull($obj->getSystemCalendar());
$obj->setCalendar($calendar);
$this->assertSame($calendar, $obj->getCalendar());
$this->assertNull($obj->getSystemCalendar());
$obj->setSystemCalendar($systemCalendar);
$this->assertNull($obj->getCalendar());
$this->assertSame($systemCalendar, $obj->getSystemCalendar());
$obj->setCalendar($calendar);
$this->assertSame($calendar, $obj->getCalendar());
$this->assertNull($obj->getSystemCalendar());
$obj->setCalendar(null);
$this->assertNull($obj->getCalendar());
$obj->setSystemCalendar($systemCalendar);
$this->assertNull($obj->getCalendar());
$this->assertSame($systemCalendar, $obj->getSystemCalendar());
$obj->setSystemCalendar(null);
$this->assertNull($obj->getCalendar());
$this->assertNull($obj->getSystemCalendar());
}
/**
* @param CalendarEvent $entity
*
* @throws \LogicException
*/
protected function ensureCalendarSet(CalendarEvent $entity)
{
if ($entity->getCalendar() || $entity->getSystemCalendar()) {
return;
}
if (!$this->securityFacade->getLoggedUser() || !$this->securityFacade->getOrganization()) {
throw new \LogicException('Both logged in user and organization must be defined.');
}
/** @var Calendar $defaultCalendar */
$defaultCalendar = $this->manager->getRepository('OroCalendarBundle:Calendar')->findDefaultCalendar($this->securityFacade->getLoggedUser()->getId(), $this->securityFacade->getOrganization()->getId());
$entity->setCalendar($defaultCalendar);
}
protected function setUpEvent(CalendarEvent $event, $id, $email)
{
$user = new User();
$user->setEmail($email);
$calendar = new Calendar();
$calendar->setOwner($user);
$event->setCalendar($calendar);
ReflectionUtil::setPrivateProperty($event, 'id', $id);
$event->setReminded(false);
}
public function testSetSameUserCalendar()
{
$calendarId = 123;
$calendar = new Calendar();
ReflectionUtil::setId($calendar, $calendarId);
$event = new CalendarEvent();
$event->setCalendar($calendar);
$this->doctrineHelper->expects($this->never())->method('getEntityRepository');
$this->manager->setCalendar($event, Calendar::CALENDAR_ALIAS, $calendarId);
$this->assertSame($calendar, $event->getCalendar());
}
