Merge branch 'calendar/finalization' into calendar_changes

src/Bundle/ChillCalendarBundle/ChillCalendarBundle.php

@@ -11,8 +11,16 @@ declare(strict_types=1);
 
 namespace Chill\CalendarBundle;
 
+use Chill\CalendarBundle\RemoteCalendar\DependencyInjection\RemoteCalendarCompilerPass;
+use Symfony\Component\DependencyInjection\ContainerBuilder;
 use Symfony\Component\HttpKernel\Bundle\Bundle;
 
 class ChillCalendarBundle extends Bundle
 {
+    public function build(ContainerBuilder $container)
+    {
+        parent::build($container);
+
+        $container->addCompilerPass(new RemoteCalendarCompilerPass());
+    }
 }

src/Bundle/ChillCalendarBundle/Command/AzureGrantAdminConsentAndAcquireToken.php

@@ -0,0 +1,77 @@
+<?php
+
+/**
+ * Chill is a software for social workers
+ *
+ * For the full copyright and license information, please view
+ * the LICENSE file that was distributed with this source code.
+ */
+
+declare(strict_types=1);
+
+namespace Chill\CalendarBundle\Command;
+
+use Chill\CalendarBundle\RemoteCalendar\Connector\MSGraph\MachineTokenStorage;
+use KnpU\OAuth2ClientBundle\Client\ClientRegistry;
+use Symfony\Component\Console\Command\Command;
+use Symfony\Component\Console\Helper\FormatterHelper;
+use Symfony\Component\Console\Input\InputInterface;
+use Symfony\Component\Console\Output\OutputInterface;
+use Symfony\Component\Console\Question\ConfirmationQuestion;
+use TheNetworg\OAuth2\Client\Provider\Azure;
+
+class AzureGrantAdminConsentAndAcquireToken extends Command
+{
+    private Azure $azure;
+
+    private ClientRegistry $clientRegistry;
+
+    private MachineTokenStorage $machineTokenStorage;
+
+    public function __construct(Azure $azure, ClientRegistry $clientRegistry, MachineTokenStorage $machineTokenStorage)
+    {
+        parent::__construct('chill:calendar:msgraph-grant-admin-consent');
+
+        $this->azure = $azure;
+        $this->clientRegistry = $clientRegistry;
+        $this->machineTokenStorage = $machineTokenStorage;
+    }
+
+    protected function execute(InputInterface $input, OutputInterface $output)
+    {
+        /** @var FormatterHelper $formatter */
+        $formatter = $this->getHelper('formatter');
+        $this->azure->scope = ['https://graph.microsoft.com/.default'];
+        $authorizationUrl = explode('?', $this->azure->getAuthorizationUrl(['prompt' => 'admin_consent']));
+
+        // replace the first part by the admin consent authorization url
+        $authorizationUrl[0] = strtr('https://login.microsoftonline.com/{tenant}/adminconsent', ['{tenant}' => $this->azure->tenant]);
+
+        $output->writeln('Go to the url');
+        $output->writeln(implode('?', $authorizationUrl));
+        $output->writeln('Authenticate as admin, and grant admin consent');
+
+        // not necessary ?
+        $helper = $this->getHelper('question');
+        $question = new ConfirmationQuestion('Access granted ?');
+
+        if (!$helper->ask($input, $output, $question)) {
+            $messages = ['No problem, we will wait for you', 'Grant access and come back here'];
+            $output->writeln($formatter->formatBlock($messages, 'warning'));
+
+            return 0;
+        }
+
+        $token = $this->machineTokenStorage->getToken();
+
+        $messages = ['Token acquired!', 'We could acquire a machine token successfully'];
+        $output->writeln($formatter->formatBlock($messages, 'success'));
+
+        $output->writeln('Token information:');
+        $output->writeln($token->getToken());
+        $output->writeln('Expires at: ' . $token->getExpires());
+        $output->writeln('To inspect the token content, go to https://jwt.ms/#access_token=' . urlencode($token->getToken()));
+
+        return 0;
+    }
+}

src/Bundle/ChillCalendarBundle/Command/MapAndSubscribeUserCalendarCommand.php

@@ -0,0 +1,164 @@
+<?php
+
+/**
+ * Chill is a software for social workers
+ *
+ * For the full copyright and license information, please view
+ * the LICENSE file that was distributed with this source code.
+ */
+
+declare(strict_types=1);
+
+namespace Chill\CalendarBundle\Command;
+
+use Chill\CalendarBundle\RemoteCalendar\Connector\MSGraph\EventsOnUserSubscriptionCreator;
+use Chill\CalendarBundle\RemoteCalendar\Connector\MSGraph\MapCalendarToUser;
+use Chill\CalendarBundle\RemoteCalendar\Connector\MSGraph\MSGraphUserRepository;
+use DateInterval;
+use DateTimeImmutable;
+use Doctrine\ORM\EntityManagerInterface;
+use Psr\Log\LoggerInterface;
+use Symfony\Component\Console\Command\Command;
+use Symfony\Component\Console\Input\InputInterface;
+use Symfony\Component\Console\Input\InputOption;
+use Symfony\Component\Console\Output\OutputInterface;
+
+class MapAndSubscribeUserCalendarCommand extends Command
+{
+    private EntityManagerInterface $em;
+
+    private EventsOnUserSubscriptionCreator $eventsOnUserSubscriptionCreator;
+
+    private LoggerInterface $logger;
+
+    private MapCalendarToUser $mapCalendarToUser;
+
+    private MSGraphUserRepository $userRepository;
+
+    public function __construct(
+        EntityManagerInterface $em,
+        EventsOnUserSubscriptionCreator $eventsOnUserSubscriptionCreator,
+        LoggerInterface $logger,
+        MapCalendarToUser $mapCalendarToUser,
+        MSGraphUserRepository $userRepository
+    ) {
+        parent::__construct('chill:calendar:msgraph-user-map-subscribe');
+
+        $this->em = $em;
+        $this->eventsOnUserSubscriptionCreator = $eventsOnUserSubscriptionCreator;
+        $this->logger = $logger;
+        $this->mapCalendarToUser = $mapCalendarToUser;
+        $this->userRepository = $userRepository;
+    }
+
+    public function execute(InputInterface $input, OutputInterface $output): int
+    {
+        $this->logger->info(__CLASS__ . ' execute command');
+
+        $limit = 50;
+        $offset = 0;
+        /** @var DateInterval $interval the interval before the end of the expiration */
+        $interval = new DateInterval('P1D');
+        $expiration = (new DateTimeImmutable('now'))->add(new DateInterval('PT15M'));
+        $total = $this->userRepository->countByMostOldSubscriptionOrWithoutSubscriptionOrData($interval);
+        $created = 0;
+        $renewed = 0;
+
+        $this->logger->info(__CLASS__ . ' the number of user to get - renew', [
+            'total' => $total,
+            'expiration' => $expiration->format(DateTimeImmutable::ATOM),
+        ]);
+
+        while ($offset < ($total - 1)) {
+            $users = $this->userRepository->findByMostOldSubscriptionOrWithoutSubscriptionOrData(
+                $interval,
+                $limit,
+                $offset
+            );
+
+            foreach ($users as $user) {
+                if (!$this->mapCalendarToUser->hasUserId($user)) {
+                    $this->mapCalendarToUser->writeMetadata($user);
+                }
+
+                if ($this->mapCalendarToUser->hasUserId($user)) {
+                    // we first try to renew an existing subscription, if any.
+                    // if not, or if it fails, we try to create a new one
+                    if ($this->mapCalendarToUser->hasActiveSubscription($user)) {
+                        $this->logger->debug(__CLASS__ . ' renew a subscription for', [
+                            'userId' => $user->getId(),
+                            'username' => $user->getUsernameCanonical(),
+                        ]);
+
+                        ['secret' => $secret, 'id' => $id, 'expiration' => $expirationTs]
+                            = $this->eventsOnUserSubscriptionCreator->renewSubscriptionForUser($user, $expiration);
+                        $this->mapCalendarToUser->writeSubscriptionMetadata($user, $expirationTs, $id, $secret);
+
+                        if (0 !== $expirationTs) {
+                            ++$renewed;
+                        } else {
+                            $this->logger->warning(__CLASS__ . ' could not renew subscription for a user', [
+                                'userId' => $user->getId(),
+                                'username' => $user->getUsernameCanonical(),
+                            ]);
+                        }
+                    }
+
+                    if (!$this->mapCalendarToUser->hasActiveSubscription($user)) {
+                        $this->logger->debug(__CLASS__ . ' create a subscription for', [
+                            'userId' => $user->getId(),
+                            'username' => $user->getUsernameCanonical(),
+                        ]);
+
+                        ['secret' => $secret, 'id' => $id, 'expiration' => $expirationTs]
+                            = $this->eventsOnUserSubscriptionCreator->createSubscriptionForUser($user, $expiration);
+                        $this->mapCalendarToUser->writeSubscriptionMetadata($user, $expirationTs, $id, $secret);
+
+                        if (0 !== $expirationTs) {
+                            ++$created;
+                        } else {
+                            $this->logger->warning(__CLASS__ . ' could not create subscription for a user', [
+                                'userId' => $user->getId(),
+                                'username' => $user->getUsernameCanonical(),
+                            ]);
+                        }
+                    }
+                }
+
+                ++$offset;
+            }
+
+            $this->em->flush();
+            $this->em->clear();
+        }
+
+        $this->logger->warning(__CLASS__ . ' process executed', [
+            'created' => $created,
+            'renewed' => $renewed,
+        ]);
+
+        return 0;
+    }
+
+    protected function configure()
+    {
+        parent::configure();
+
+        $this
+            ->setDescription('MSGraph: collect user metadata and create subscription on events for users')
+            ->addOption(
+                'renew-before-end-interval',
+                'r',
+                InputOption::VALUE_OPTIONAL,
+                'delay before renewing subscription',
+                'P1D'
+            )
+            ->addOption(
+                'subscription-duration',
+                's',
+                InputOption::VALUE_OPTIONAL,
+                'duration for the subscription',
+                'PT4230M'
+            );
+    }
+}

src/Bundle/ChillCalendarBundle/Command/SendShortMessageOnEligibleCalendar.php

@@ -0,0 +1,41 @@
+<?php
+
+/**
+ * Chill is a software for social workers
+ *
+ * For the full copyright and license information, please view
+ * the LICENSE file that was distributed with this source code.
+ */
+
+declare(strict_types=1);
+
+namespace Chill\CalendarBundle\Command;
+
+use Chill\CalendarBundle\Service\ShortMessageNotification\BulkCalendarShortMessageSender;
+use Symfony\Component\Console\Command\Command;
+use Symfony\Component\Console\Input\InputInterface;
+use Symfony\Component\Console\Output\OutputInterface;
+
+class SendShortMessageOnEligibleCalendar extends Command
+{
+    private BulkCalendarShortMessageSender $messageSender;
+
+    public function __construct(BulkCalendarShortMessageSender $messageSender)
+    {
+        parent::__construct();
+
+        $this->messageSender = $messageSender;
+    }
+
+    public function getName()
+    {
+        return 'chill:calendar:send-short-messages';
+    }
+
+    protected function execute(InputInterface $input, OutputInterface $output)
+    {
+        $this->messageSender->sendBulkMessageToEligibleCalendars();
+
+        return 0;
+    }
+}

src/Bundle/ChillCalendarBundle/Command/SendTestShortMessageOnCalendarCommand.php

@@ -0,0 +1,200 @@
+<?php
+
+/**
+ * Chill is a software for social workers
+ *
+ * For the full copyright and license information, please view
+ * the LICENSE file that was distributed with this source code.
+ */
+
+declare(strict_types=1);
+
+namespace Chill\CalendarBundle\Command;
+
+use Chill\CalendarBundle\Entity\Calendar;
+use Chill\CalendarBundle\Service\ShortMessageNotification\ShortMessageForCalendarBuilderInterface;
+use Chill\MainBundle\Entity\User;
+use Chill\MainBundle\Phonenumber\PhoneNumberHelperInterface;
+use Chill\MainBundle\Repository\UserRepositoryInterface;
+use Chill\MainBundle\Service\ShortMessage\ShortMessageTransporterInterface;
+use Chill\PersonBundle\Entity\Person;
+use Chill\PersonBundle\Repository\PersonRepository;
+use DateInterval;
+use DateTimeImmutable;
+use libphonenumber\PhoneNumber;
+use libphonenumber\PhoneNumberFormat;
+use libphonenumber\PhoneNumberType;
+use libphonenumber\PhoneNumberUtil;
+use Symfony\Component\Console\Command\Command;
+use Symfony\Component\Console\Helper\QuestionHelper;
+use Symfony\Component\Console\Input\InputInterface;
+use Symfony\Component\Console\Output\OutputInterface;
+use Symfony\Component\Console\Question\ConfirmationQuestion;
+use Symfony\Component\Console\Question\Question;
+use UnexpectedValueException;
+use function count;
+
+class SendTestShortMessageOnCalendarCommand extends Command
+{
+    private ShortMessageForCalendarBuilderInterface $messageForCalendarBuilder;
+
+    private PersonRepository $personRepository;
+
+    private PhoneNumberHelperInterface $phoneNumberHelper;
+
+    private PhoneNumberUtil $phoneNumberUtil;
+
+    private ShortMessageTransporterInterface $transporter;
+
+    private UserRepositoryInterface $userRepository;
+
+    public function __construct(
+        PersonRepository $personRepository,
+        PhoneNumberUtil $phoneNumberUtil,
+        PhoneNumberHelperInterface $phoneNumberHelper,
+        ShortMessageForCalendarBuilderInterface $messageForCalendarBuilder,
+        ShortMessageTransporterInterface $transporter,
+        UserRepositoryInterface $userRepository
+    ) {
+        parent::__construct();
+
+        $this->personRepository = $personRepository;
+        $this->phoneNumberUtil = $phoneNumberUtil;
+        $this->phoneNumberHelper = $phoneNumberHelper;
+        $this->messageForCalendarBuilder = $messageForCalendarBuilder;
+        $this->transporter = $transporter;
+        $this->userRepository = $userRepository;
+    }
+
+    public function getName()
+    {
+        return 'chill:calendar:test-send-short-message';
+    }
+
+    protected function configure()
+    {
+        $this->setDescription('Test sending a SMS for a dummy calendar appointment');
+    }
+
+    protected function execute(InputInterface $input, OutputInterface $output): int
+    {
+        $calendar = new Calendar();
+        $calendar->setSendSMS(true);
+
+        /** @var QuestionHelper $helper */
+        $helper = $this->getHelper('question');
+
+        // start date
+        $question = new Question('When will start the appointment ? (default: "1 hour") ', '1 hour');
+        $startDate = new DateTimeImmutable($helper->ask($input, $output, $question));
+
+        if (false === $startDate) {
+            throw new UnexpectedValueException('could not create a date with this date and time');
+        }
+
+        $calendar->setStartDate($startDate);
+
+        // end date
+        $question = new Question('How long will last the appointment ? (default: "PT30M") ', 'PT30M');
+        $interval = new DateInterval($helper->ask($input, $output, $question));
+
+        if (false === $interval) {
+            throw new UnexpectedValueException('could not create the interval');
+        }
+
+        $calendar->setEndDate($calendar->getStartDate()->add($interval));
+
+        // a person
+        $question = new Question('Who will participate ? Give an id for a person. ');
+        $question
+            ->setValidator(function ($answer): Person {
+                if (!is_numeric($answer)) {
+                    throw new UnexpectedValueException('the answer must be numeric');
+                }
+
+                if (0 >= (int) $answer) {
+                    throw new UnexpectedValueException('the answer must be greater than zero');
+                }
+
+                $person = $this->personRepository->find((int) $answer);
+
+                if (null === $person) {
+                    throw new UnexpectedValueException('The person is not found');
+                }
+
+                return $person;
+            });
+
+        $person = $helper->ask($input, $output, $question);
+        $calendar->addPerson($person);
+
+        // a main user
+        $question = new Question('Who will be the main user ? Give an id for a user. ');
+        $question
+            ->setValidator(function ($answer): User {
+                if (!is_numeric($answer)) {
+                    throw new UnexpectedValueException('the answer must be numeric');
+                }
+
+                if (0 >= (int) $answer) {
+                    throw new UnexpectedValueException('the answer must be greater than zero');
+                }
+
+                $user = $this->userRepository->find((int) $answer);
+
+                if (null === $user) {
+                    throw new UnexpectedValueException('The user is not found');
+                }
+
+                return $user;
+            });
+
+        $user = $helper->ask($input, $output, $question);
+        $calendar->setMainUser($user);
+
+        // phonenumber
+        $phonenumberFormatted = null !== $person->getMobilenumber() ?
+            $this->phoneNumberUtil->format($person->getMobilenumber(), PhoneNumberFormat::E164) : '';
+        $question = new Question(
+            sprintf('To which number are we going to send this fake message ? (default to: %s)', $phonenumberFormatted),
+            $phonenumberFormatted
+        );
+
+        $question->setNormalizer(function ($answer): PhoneNumber {
+            if (null === $answer) {
+                throw new UnexpectedValueException('The person is not found');
+            }
+
+            $phone = $this->phoneNumberUtil->parse($answer, 'BE');
+
+            if (!$this->phoneNumberUtil->isPossibleNumberForType($phone, PhoneNumberType::MOBILE)) {
+                throw new UnexpectedValueException('Phone number si not a mobile');
+            }
+
+            return $phone;
+        });
+
+        $phone = $helper->ask($input, $output, $question);
+
+        $question = new ConfirmationQuestion('really send the message to the phone ?');
+        $reallySend = (bool) $helper->ask($input, $output, $question);
+
+        $messages = $this->messageForCalendarBuilder->buildMessageForCalendar($calendar);
+
+        if (0 === count($messages)) {
+            $output->writeln('no message to send to this user');
+        }
+
+        foreach ($messages as $key => $message) {
+            $output->writeln("The short message for SMS {$key} will be: ");
+            $output->writeln($message->getContent());
+            $message->setPhoneNumber($phone);
+
+            if ($reallySend) {
+                $this->transporter->send($message);
+            }
+        }
+
+        return 0;
+    }
+}

src/Bundle/ChillCalendarBundle/Controller/AdminController.php

@@ -0,0 +1,28 @@
+<?php
+
+/**
+ * Chill is a software for social workers
+ *
+ * For the full copyright and license information, please view
+ * the LICENSE file that was distributed with this source code.
+ */
+
+declare(strict_types=1);
+
+namespace Chill\CalendarBundle\Controller;
+
+use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
+use Symfony\Component\Routing\Annotation\Route;
+
+class AdminController extends AbstractController
+{
+    /**
+     * Calendar admin.
+     *
+     * @Route("/{_locale}/admin/calendar", name="chill_calendar_admin_index")
+     */
+    public function indexAdminAction()
+    {
+        return $this->render('ChillCalendarBundle:Admin:index.html.twig');
+    }
+}

src/Bundle/ChillCalendarBundle/Controller/CalendarController.php

@@ -13,17 +13,21 @@ namespace Chill\CalendarBundle\Controller;
 
 use Chill\CalendarBundle\Entity\Calendar;
 use Chill\CalendarBundle\Form\CalendarType;
+use Chill\CalendarBundle\RemoteCalendar\Connector\RemoteCalendarConnectorInterface;
+use Chill\CalendarBundle\Repository\CalendarACLAwareRepositoryInterface;
 use Chill\CalendarBundle\Repository\CalendarRepository;
 use Chill\MainBundle\Entity\User;
 use Chill\MainBundle\Pagination\PaginatorFactory;
-use Chill\MainBundle\Security\Authorization\AuthorizationHelper;
+use Chill\MainBundle\Repository\UserRepository;
+use Chill\MainBundle\Templating\Listing\FilterOrderHelper;
+use Chill\MainBundle\Templating\Listing\FilterOrderHelperFactoryInterface;
 use Chill\PersonBundle\Entity\AccompanyingPeriod;
 use Chill\PersonBundle\Entity\Person;
 use Chill\ThirdPartyBundle\Entity\ThirdParty;
+use DateTimeImmutable;
 use Exception;
 use Psr\Log\LoggerInterface;
 use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
-use Symfony\Component\EventDispatcher\EventDispatcherInterface;
 use Symfony\Component\Form\Extension\Core\Type\SubmitType;
 use Symfony\Component\Form\Form;
 use Symfony\Component\Form\FormInterface;
@@ -35,32 +39,40 @@ use Symfony\Component\Serializer\SerializerInterface;
 
 class CalendarController extends AbstractController
 {
-    protected AuthorizationHelper $authorizationHelper;
-
-    protected EventDispatcherInterface $eventDispatcher;
-
-    protected LoggerInterface $logger;
-
-    protected PaginatorFactory $paginator;
-
-    protected SerializerInterface $serializer;
+    private CalendarACLAwareRepositoryInterface $calendarACLAwareRepository;
 
     private CalendarRepository $calendarRepository;
 
+    private FilterOrderHelperFactoryInterface $filterOrderHelperFactory;
+
+    private LoggerInterface $logger;
+
+    private PaginatorFactory $paginator;
+
+    private RemoteCalendarConnectorInterface $remoteCalendarConnector;
+
+    private SerializerInterface $serializer;
+
+    private UserRepository $userRepository;
+
     public function __construct(
-        EventDispatcherInterface $eventDispatcher,
-        AuthorizationHelper $authorizationHelper,
+        CalendarRepository $calendarRepository,
+        CalendarACLAwareRepositoryInterface $calendarACLAwareRepository,
+        FilterOrderHelperFactoryInterface $filterOrderHelperFactory,
         LoggerInterface $logger,
-        SerializerInterface $serializer,
         PaginatorFactory $paginator,
-        CalendarRepository $calendarRepository
+        RemoteCalendarConnectorInterface $remoteCalendarConnector,
+        SerializerInterface $serializer,
+        UserRepository $userRepository
     ) {
-        $this->eventDispatcher = $eventDispatcher;
-        $this->authorizationHelper = $authorizationHelper;
-        $this->logger = $logger;
-        $this->serializer = $serializer;
-        $this->paginator = $paginator;
         $this->calendarRepository = $calendarRepository;
+        $this->calendarACLAwareRepository = $calendarACLAwareRepository;
+        $this->filterOrderHelperFactory = $filterOrderHelperFactory;
+        $this->logger = $logger;
+        $this->paginator = $paginator;
+        $this->remoteCalendarConnector = $remoteCalendarConnector;
+        $this->serializer = $serializer;
+        $this->userRepository = $userRepository;
     }
 
     /**
@@ -127,8 +139,12 @@ class CalendarController extends AbstractController
      *
      * @Route("/{_locale}/calendar/calendar/{id}/edit", name="chill_calendar_calendar_edit")
      */
-    public function editAction(int $id, Request $request): Response
+    public function editAction(Calendar $entity, Request $request): Response
     {
+        if (!$this->remoteCalendarConnector->isReady()) {
+            return $this->remoteCalendarConnector->getMakeReadyResponse($request->getUri());
+        }
+
         $view = null;
         $em = $this->getDoctrine()->getManager();
 
@@ -137,35 +153,28 @@ class CalendarController extends AbstractController
         if ($accompanyingPeriod instanceof AccompanyingPeriod) {
             $view = '@ChillCalendar/Calendar/editByAccompanyingCourse.html.twig';
         } elseif ($user instanceof User) {
+            throw new Exception('to analyze');
             $view = '@ChillCalendar/Calendar/editByUser.html.twig';
         }
 
-        $entity = $em->getRepository(\Chill\CalendarBundle\Entity\Calendar::class)->find($id);
-
-        if (!$entity) {
-            throw $this->createNotFoundException('Unable to find Calendar entity.');
-        }
-
-        $form = $this->createForm(CalendarType::class, $entity, [
-            'accompanyingPeriod' => $accompanyingPeriod,
-        ])->handleRequest($request);
+        $form = $this->createForm(CalendarType::class, $entity);
+        $form->handleRequest($request);
 
         if ($form->isSubmitted() && $form->isValid()) {
-            $em->persist($entity);
             $em->flush();
 
             $this->addFlash('success', $this->get('translator')->trans('Success : calendar item updated!'));
 
             $params = $this->buildParamsToUrl($user, $accompanyingPeriod);
 
-            return $this->redirectToRoute('chill_calendar_calendar_list', $params);
+            return $this->redirectToRoute('chill_calendar_calendar_list_by_period', $params);
         }
 
         if ($form->isSubmitted() && !$form->isValid()) {
             $this->addFlash('error', $this->get('translator')->trans('This form contains errors'));
         }
 
-        $deleteForm = $this->createDeleteForm($id, $user, $accompanyingPeriod);
+        $deleteForm = $this->createDeleteForm($entity->getId(), $user, $accompanyingPeriod);
 
         if (null === $view) {
             throw $this->createNotFoundException('Template not found');
@@ -178,7 +187,7 @@ class CalendarController extends AbstractController
             'form' => $form->createView(),
             'delete_form' => $deleteForm->createView(),
             'accompanyingCourse' => $accompanyingPeriod,
-            'user' => $user,
+            //            'user' => $user,
             'entity_json' => $entity_array,
         ]);
     }
@@ -207,48 +216,31 @@ class CalendarController extends AbstractController
     /**
      * Lists all Calendar entities.
      *
-     * @Route("/{_locale}/calendar/calendar/", name="chill_calendar_calendar_list")
+     * @Route("/{_locale}/calendar/calendar/by-period/{id}", name="chill_calendar_calendar_list_by_period")
      */
-    public function listAction(Request $request): Response
+    public function listActionByCourse(AccompanyingPeriod $accompanyingPeriod): Response
     {
-        $view = null;
+        $filterOrder = $this->buildListFilterOrder();
+        ['from' => $from, 'to' => $to] = $filterOrder->getDateRangeData('startDate');
 
-        [$user, $accompanyingPeriod] = $this->getEntity($request);
+        $total = $this->calendarACLAwareRepository
+            ->countByAccompanyingPeriod($accompanyingPeriod, $from, $to);
+        $paginator = $this->paginator->create($total);
+        $calendarItems = $this->calendarACLAwareRepository->findByAccompanyingPeriod(
+            $accompanyingPeriod,
+            $from,
+            $to,
+            ['startDate' => 'DESC'],
+            $paginator->getCurrentPageFirstItemNumber(),
+            $paginator->getItemsPerPage()
+        );
 
-        /*
-         dead code ?
-        if ($user instanceof User) {
-            $calendarItems = $this->calendarRepository->findByUser($user);
-
-            $view = '@ChillCalendar/Calendar/listByUser.html.twig';
-
-            return $this->render($view, [
-                'calendarItems' => $calendarItems,
-                'user' => $user,
-            ]);
-        }
-         */
-
-        if ($accompanyingPeriod instanceof AccompanyingPeriod) {
-            $total = $this->calendarRepository->countByAccompanyingPeriod($accompanyingPeriod);
-            $paginator = $this->paginator->create($total);
-            $calendarItems = $this->calendarRepository->findBy(
-                ['accompanyingPeriod' => $accompanyingPeriod],
-                ['startDate' => 'DESC'],
-                $paginator->getItemsPerPage(),
-                $paginator->getCurrentPageFirstItemNumber()
-            );
-
-            $view = '@ChillCalendar/Calendar/listByAccompanyingCourse.html.twig';
-
-            return $this->render($view, [
-                'calendarItems' => $calendarItems,
-                'accompanyingCourse' => $accompanyingPeriod,
-                'paginator' => $paginator,
-            ]);
-        }
-
-        throw new Exception('Unable to list actions.');
+        return $this->render('@ChillCalendar/Calendar/listByAccompanyingCourse.html.twig', [
+            'calendarItems' => $calendarItems,
+            'accompanyingCourse' => $accompanyingPeriod,
+            'paginator' => $paginator,
+            'filterOrder' => $filterOrder,
+        ]);
     }
 
     /**
@@ -258,6 +250,10 @@ class CalendarController extends AbstractController
      */
     public function newAction(Request $request): Response
     {
+        if (!$this->remoteCalendarConnector->isReady()) {
+            return $this->remoteCalendarConnector->getMakeReadyResponse($request->getUri());
+        }
+
         $view = null;
         $em = $this->getDoctrine()->getManager();
 
@@ -271,8 +267,10 @@ class CalendarController extends AbstractController
         // }
 
         $entity = new Calendar();
-        $entity->setUser($this->getUser());
-        $entity->setStatus($entity::STATUS_VALID);
+
+        if ($request->query->has('mainUser')) {
+            $entity->setMainUser($this->userRepository->find($request->query->getInt('mainUser')));
+        }
 
         // if ($user instanceof User) {
         //     $entity->setPerson($user);
@@ -282,9 +280,8 @@ class CalendarController extends AbstractController
             $entity->setAccompanyingPeriod($accompanyingPeriod);
         }
 
-        $form = $this->createForm(CalendarType::class, $entity, [
-            'accompanyingPeriod' => $accompanyingPeriod,
-        ])->handleRequest($request);
+        $form = $this->createForm(CalendarType::class, $entity);
+        $form->handleRequest($request);
 
         if ($form->isSubmitted() && $form->isValid()) {
             $em->persist($entity);
@@ -294,7 +291,7 @@ class CalendarController extends AbstractController
 
             $params = $this->buildParamsToUrl($user, $accompanyingPeriod);
 
-            return $this->redirectToRoute('chill_calendar_calendar_list', $params);
+            return $this->redirectToRoute('chill_calendar_calendar_list_by_period', $params);
         }
 
         if ($form->isSubmitted() && !$form->isValid()) {
@@ -387,6 +384,14 @@ class CalendarController extends AbstractController
         ]);
     }
 
+    private function buildListFilterOrder(): FilterOrderHelper
+    {
+        $filterOrder = $this->filterOrderHelperFactory->create(self::class);
+        $filterOrder->addDateRange('startDate', 'chill_calendar.start date filter', new DateTimeImmutable('3 days ago'), null);
+
+        return $filterOrder->build();
+    }
+
     private function buildParamsToUrl(?User $user, ?AccompanyingPeriod $accompanyingPeriod): array
     {
         $params = [];
@@ -396,7 +401,7 @@ class CalendarController extends AbstractController
         }
 
         if (null !== $accompanyingPeriod) {
-            $params['accompanying_period_id'] = $accompanyingPeriod->getId();
+            $params['id'] = $accompanyingPeriod->getId();
         }
 
         return $params;

src/Bundle/ChillCalendarBundle/Controller/CalendarRangeAPIController.php

@@ -11,58 +11,72 @@ declare(strict_types=1);
 
 namespace Chill\CalendarBundle\Controller;
 
+use Chill\CalendarBundle\Repository\CalendarRangeRepository;
 use Chill\MainBundle\CRUD\Controller\ApiController;
-use DateTime;
+use Chill\MainBundle\Entity\User;
+use Chill\MainBundle\Serializer\Model\Collection;
+use DateTimeImmutable;
 use Symfony\Component\HttpFoundation\JsonResponse;
 use Symfony\Component\HttpFoundation\Request;
 use Symfony\Component\HttpFoundation\Response;
-use Symfony\Component\Routing\Annotation\Route;
+use Symfony\Component\HttpKernel\Exception\BadRequestHttpException;
 
-use function count;
+use Symfony\Component\Routing\Annotation\Route;
 
 class CalendarRangeAPIController extends ApiController
 {
-    /**
-     * @Route("/api/1.0/calendar/calendar-range-available.{_format}", name="chill_api_single_calendar_range_available")
-     */
-    public function availableRanges(Request $request, string $_format): JsonResponse
+    private CalendarRangeRepository $calendarRangeRepository;
+
+    public function __construct(CalendarRangeRepository $calendarRangeRepository)
     {
-        $em = $this->getDoctrine()->getManager();
+        $this->calendarRangeRepository = $calendarRangeRepository;
+    }
 
-        $sql = 'SELECT c FROM ChillCalendarBundle:CalendarRange c
-        WHERE NOT EXISTS (SELECT cal.id FROM ChillCalendarBundle:Calendar cal WHERE cal.calendarRange = c.id)';
+    /**
+     * @Route("/api/1.0/calendar/calendar-range-available/{id}.{_format}",
+     *     name="chill_api_single_calendar_range_available",
+     *     requirements={"_format": "json"}
+     * )
+     */
+    public function availableRanges(User $user, Request $request, string $_format): JsonResponse
+    {
+        //return new JsonResponse(['ok' => true], 200, [], false);
+        $this->denyAccessUnlessGranted('ROLE_USER');
 
-        if ($request->query->has('user')) {
-            $user = $request->query->get('user');
-            $sql = $sql . ' AND c.user = :user';
-            $query = $em->createQuery($sql)
-                ->setParameter('user', $user);
-
-            if ($request->query->has('start') && $request->query->has('end')) {
-                $startDate = $request->query->get('start');
-                $endDate = $request->query->get('end');
-
-                $sql = $sql . ' AND c.startDate > :startDate AND c.endDate < :endDate';
-                $query = $em ->createQuery($sql)
-                    ->setParameter('startDate', $startDate)
-                    ->setParameter('endDate', $endDate)
-                    ->setParameter('user', $user);
-            }
-
-            if($request->query->has('start') && !$request->query->has('end')) {
-                $copyDate = $request->query->get('start');
-
-                $sql = $sql . ' AND DATE_DIFF(c.startDate, :copyDate) = 0';
-                $query = $em ->createQuery($sql)
-                    ->setParameter('copyDate', $copyDate)
-                    ->setParameter('user', $user);
-            }
-        } else {
-            $query = $em->createQuery($sql);
+        if (!$request->query->has('dateFrom')) {
+            throw new BadRequestHttpException('You must provide a dateFrom parameter');
         }
-        $results = $query->getResult();
 
-        return $this->json(['count' => count($results), 'results' => $results], Response::HTTP_OK, [], ['groups' => ['read']]);
-        //TODO use also the paginator, eg return $this->serializeCollection('get', $request, $_format, $paginator, $results);
+        if (false === $dateFrom = DateTimeImmutable::createFromFormat(
+            DateTimeImmutable::ATOM,
+            $request->query->get('dateFrom')
+        )) {
+            throw new BadRequestHttpException('dateFrom not parsable');
+        }
+
+        if (!$request->query->has('dateTo')) {
+            throw new BadRequestHttpException('You must provide a dateTo parameter');
+        }
+
+        if (false === $dateTo = DateTimeImmutable::createFromFormat(
+            DateTimeImmutable::ATOM,
+            $request->query->get('dateTo')
+        )) {
+            throw new BadRequestHttpException('dateTo not parsable');
+        }
+
+        $total = $this->calendarRangeRepository->countByAvailableRangesForUser($user, $dateFrom, $dateTo);
+        $paginator = $this->getPaginatorFactory()->create($total);
+        $ranges = $this->calendarRangeRepository->findByAvailableRangesForUser(
+            $user,
+            $dateFrom,
+            $dateTo,
+            $paginator->getItemsPerPage(),
+            $paginator->getCurrentPageFirstItemNumber()
+        );
+
+        $collection = new Collection($ranges, $paginator);
+
+        return $this->json($collection, Response::HTTP_OK, [], ['groups' => ['read']]);
     }
 }

src/Bundle/ChillCalendarBundle/Controller/CancelReasonController.php

@@ -0,0 +1,26 @@
+<?php
+
+/**
+ * Chill is a software for social workers
+ *
+ * For the full copyright and license information, please view
+ * the LICENSE file that was distributed with this source code.
+ */
+
+declare(strict_types=1);
+
+namespace Chill\CalendarBundle\Controller;
+
+use Chill\MainBundle\CRUD\Controller\CRUDController;
+use Chill\MainBundle\Pagination\PaginatorInterface;
+use Symfony\Component\HttpFoundation\Request;
+
+class CancelReasonController extends CRUDController
+{
+    protected function orderQuery(string $action, $query, Request $request, PaginatorInterface $paginator)
+    {
+        $query->addOrderBy('e.id', 'ASC');
+
+        return parent::orderQuery($action, $query, $request, $paginator);
+    }
+}

src/Bundle/ChillCalendarBundle/Controller/InviteApiController.php

@@ -0,0 +1,76 @@
+<?php
+
+/**
+ * Chill is a software for social workers
+ *
+ * For the full copyright and license information, please view
+ * the LICENSE file that was distributed with this source code.
+ */
+
+declare(strict_types=1);
+
+namespace Chill\CalendarBundle\Controller;
+
+use Chill\CalendarBundle\Entity\Calendar;
+use Chill\CalendarBundle\Entity\Invite;
+use Chill\CalendarBundle\Messenger\Message\InviteUpdateMessage;
+use Chill\CalendarBundle\Security\Voter\InviteVoter;
+use Chill\MainBundle\Entity\User;
+use Doctrine\ORM\EntityManagerInterface;
+use Symfony\Component\HttpFoundation\JsonResponse;
+use Symfony\Component\HttpFoundation\Response;
+use Symfony\Component\HttpKernel\Exception\AccessDeniedHttpException;
+use Symfony\Component\HttpKernel\Exception\BadRequestHttpException;
+use Symfony\Component\Messenger\MessageBusInterface;
+use Symfony\Component\Routing\Annotation\Route;
+use Symfony\Component\Security\Core\Security;
+use function in_array;
+
+class InviteApiController
+{
+    private EntityManagerInterface $entityManager;
+
+    private MessageBusInterface $messageBus;
+
+    private Security $security;
+
+    public function __construct(EntityManagerInterface $entityManager, MessageBusInterface $messageBus, Security $security)
+    {
+        $this->entityManager = $entityManager;
+        $this->messageBus = $messageBus;
+        $this->security = $security;
+    }
+
+    /**
+     * Give an answer to a calendar invite.
+     *
+     * @Route("/api/1.0/calendar/calendar/{id}/answer/{answer}.json", methods={"post"})
+     */
+    public function answer(Calendar $calendar, string $answer): Response
+    {
+        $user = $this->security->getUser();
+
+        if (!$user instanceof User) {
+            throw new AccessDeniedHttpException('not a regular user');
+        }
+
+        if (null === $invite = $calendar->getInviteForUser($user)) {
+            throw new AccessDeniedHttpException('not invited to this calendar');
+        }
+
+        if (!$this->security->isGranted(InviteVoter::ANSWER, $invite)) {
+            throw new AccessDeniedHttpException('not allowed to answer on this invitation');
+        }
+
+        if (!in_array($answer, Invite::STATUSES, true)) {
+            throw new BadRequestHttpException('answer not valid');
+        }
+
+        $invite->setStatus($answer);
+        $this->entityManager->flush();
+
+        $this->messageBus->dispatch(new InviteUpdateMessage($invite, $this->security->getUser()));
+
+        return new JsonResponse(null, Response::HTTP_ACCEPTED, [], false);
+    }
+}

src/Bundle/ChillCalendarBundle/Controller/RemoteCalendarConnectAzureController.php

@@ -0,0 +1,69 @@
+<?php
+
+/**
+ * Chill is a software for social workers
+ *
+ * For the full copyright and license information, please view
+ * the LICENSE file that was distributed with this source code.
+ */
+
+declare(strict_types=1);
+
+namespace Chill\CalendarBundle\Controller;
+
+use Chill\CalendarBundle\RemoteCalendar\Connector\MSGraph\OnBehalfOfUserTokenStorage;
+use KnpU\OAuth2ClientBundle\Client\ClientRegistry;
+use League\OAuth2\Client\Provider\Exception\IdentityProviderException;
+use Symfony\Component\HttpFoundation\RedirectResponse;
+use Symfony\Component\HttpFoundation\Request;
+use Symfony\Component\HttpFoundation\Response;
+use Symfony\Component\Routing\Annotation\Route;
+use TheNetworg\OAuth2\Client\Provider\Azure;
+use TheNetworg\OAuth2\Client\Token\AccessToken;
+
+class RemoteCalendarConnectAzureController
+{
+    private ClientRegistry $clientRegistry;
+
+    private OnBehalfOfUserTokenStorage $MSGraphTokenStorage;
+
+    public function __construct(
+        ClientRegistry $clientRegistry,
+        OnBehalfOfUserTokenStorage $MSGraphTokenStorage
+    ) {
+        $this->clientRegistry = $clientRegistry;
+        $this->MSGraphTokenStorage = $MSGraphTokenStorage;
+    }
+
+    /**
+     * @Route("/{_locale}/connect/azure", name="chill_calendar_remote_connect_azure")
+     */
+    public function connectAzure(Request $request): Response
+    {
+        $request->getSession()->set('azure_return_path', $request->query->get('returnPath', '/'));
+
+        return $this->clientRegistry
+            ->getClient('azure') // key used in config/packages/knpu_oauth2_client.yaml
+            ->redirect(['https://graph.microsoft.com/.default', 'offline_access'], []);
+    }
+
+    /**
+     * @Route("/connect/azure/check", name="chill_calendar_remote_connect_azure_check")
+     */
+    public function connectAzureCheck(Request $request): Response
+    {
+        /** @var Azure $client */
+        $client = $this->clientRegistry->getClient('azure');
+
+        try {
+            /** @var AccessToken $token */
+            $token = $client->getAccessToken([]);
+
+            $this->MSGraphTokenStorage->setToken($token);
+        } catch (IdentityProviderException $e) {
+            throw $e;
+        }
+
+        return new RedirectResponse($request->getSession()->remove('azure_return_path', '/'));
+    }
+}

src/Bundle/ChillCalendarBundle/Controller/RemoteCalendarMSGraphSyncController.php

@@ -0,0 +1,54 @@
+<?php
+
+/**
+ * Chill is a software for social workers
+ *
+ * For the full copyright and license information, please view
+ * the LICENSE file that was distributed with this source code.
+ */
+
+declare(strict_types=1);
+
+namespace Chill\CalendarBundle\Controller;
+
+use Chill\CalendarBundle\Messenger\Message\MSGraphChangeNotificationMessage;
+use JsonException;
+use Symfony\Component\HttpFoundation\Request;
+use Symfony\Component\HttpFoundation\Response;
+use Symfony\Component\HttpKernel\Exception\BadRequestHttpException;
+use Symfony\Component\Messenger\MessageBusInterface;
+use Symfony\Component\Routing\Annotation\Route;
+use const JSON_THROW_ON_ERROR;
+
+class RemoteCalendarMSGraphSyncController
+{
+    private MessageBusInterface $messageBus;
+
+    public function __construct(MessageBusInterface $messageBus)
+    {
+        $this->messageBus = $messageBus;
+    }
+
+    /**
+     * @Route("/public/incoming-hook/calendar/msgraph/events/{userId}", name="chill_calendar_remote_msgraph_incoming_webhook_events",
+     * methods={"POST"})
+     */
+    public function webhookCalendarReceiver(int $userId, Request $request): Response
+    {
+        if ($request->query->has('validationToken')) {
+            return new Response($request->query->get('validationToken'), Response::HTTP_OK, [
+                'content-type' => 'text/plain',
+            ]);
+        }
+
+        try {
+            $body = json_decode($request->getContent(), true, 512, JSON_THROW_ON_ERROR);
+        } catch (JsonException $e) {
+            throw new BadRequestHttpException('could not decode json', $e);
+        }
+
+        $this->messageBus->dispatch(new MSGraphChangeNotificationMessage($body, $userId));
+
+        return new Response('', Response::HTTP_ACCEPTED);
+    }
+}

src/Bundle/ChillCalendarBundle/Controller/RemoteCalendarProxyController.php

@@ -0,0 +1,88 @@
+<?php
+
+/**
+ * Chill is a software for social workers
+ *
+ * For the full copyright and license information, please view
+ * the LICENSE file that was distributed with this source code.
+ */
+
+declare(strict_types=1);
+
+namespace Chill\CalendarBundle\Controller;
+
+use Chill\CalendarBundle\RemoteCalendar\Connector\RemoteCalendarConnectorInterface;
+use Chill\MainBundle\Entity\User;
+use Chill\MainBundle\Pagination\PaginatorFactory;
+use Chill\MainBundle\Serializer\Model\Collection;
+use DateTimeImmutable;
+use Symfony\Component\HttpFoundation\JsonResponse;
+use Symfony\Component\HttpFoundation\Request;
+use Symfony\Component\HttpFoundation\Response;
+use Symfony\Component\HttpKernel\Exception\BadRequestHttpException;
+use Symfony\Component\Routing\Annotation\Route;
+use Symfony\Component\Serializer\SerializerInterface;
+use function count;
+
+/**
+ * Contains method to get events (Calendar) from remote calendar.
+ */
+class RemoteCalendarProxyController
+{
+    private PaginatorFactory $paginatorFactory;
+
+    private RemoteCalendarConnectorInterface $remoteCalendarConnector;
+
+    private SerializerInterface $serializer;
+
+    public function __construct(PaginatorFactory $paginatorFactory, RemoteCalendarConnectorInterface $remoteCalendarConnector, SerializerInterface $serializer)
+    {
+        $this->paginatorFactory = $paginatorFactory;
+        $this->remoteCalendarConnector = $remoteCalendarConnector;
+        $this->serializer = $serializer;
+    }
+
+    /**
+     * @Route("api/1.0/calendar/proxy/calendar/by-user/{id}/events")
+     */
+    public function listEventForCalendar(User $user, Request $request): Response
+    {
+        if (!$request->query->has('dateFrom')) {
+            throw new BadRequestHttpException('You must provide a dateFrom parameter');
+        }
+
+        if (false === $dateFrom = DateTimeImmutable::createFromFormat(
+            DateTimeImmutable::ATOM,
+            $request->query->get('dateFrom')
+        )) {
+            throw new BadRequestHttpException('dateFrom not parsable');
+        }
+
+        if (!$request->query->has('dateTo')) {
+            throw new BadRequestHttpException('You must provide a dateTo parameter');
+        }
+
+        if (false === $dateTo = DateTimeImmutable::createFromFormat(
+            DateTimeImmutable::ATOM,
+            $request->query->get('dateTo')
+        )) {
+            throw new BadRequestHttpException('dateTo not parsable');
+        }
+
+        $events = $this->remoteCalendarConnector->listEventsForUser($user, $dateFrom, $dateTo);
+        $paginator = $this->paginatorFactory->create(count($events));
+
+        if (count($events) > 0) {
+            $paginator->setItemsPerPage($paginator->getTotalItems());
+        }
+
+        $collection = new Collection($events, $paginator);
+
+        return new JsonResponse(
+            $this->serializer->serialize($collection, 'json', ['groups' => ['read']]),
+            JsonResponse::HTTP_OK,
+            [],
+            true
+        );
+    }
+}

src/Bundle/ChillCalendarBundle/DependencyInjection/ChillCalendarExtension.php

@@ -36,6 +36,15 @@ class ChillCalendarExtension extends Extension implements PrependExtensionInterf
         $loader->load('services/fixtures.yml');
         $loader->load('services/form.yml');
         $loader->load('services/event.yml');
+        $loader->load('services/remote_calendar.yaml');
+
+        $container->setParameter('chill_calendar', $config);
+
+        if ($config['short_messages']['enabled']) {
+            $container->setParameter('chill_calendar.short_messages', $config['short_messages']);
+        } else {
+            $container->setParameter('chill_calendar.short_messages', null);
+        }
     }
 
     public function prepend(ContainerBuilder $container)
@@ -47,6 +56,29 @@ class ChillCalendarExtension extends Extension implements PrependExtensionInterf
     protected function prependCruds(ContainerBuilder $container)
     {
         $container->prependExtensionConfig('chill_main', [
+            'cruds' => [
+                [
+                    'class' => \Chill\CalendarBundle\Entity\CancelReason::class,
+                    'name' => 'calendar_cancel-reason',
+                    'base_path' => '/admin/calendar/cancel-reason',
+                    'form_class' => \Chill\CalendarBundle\Form\CancelReasonType::class,
+                    'controller' => \Chill\CalendarBundle\Controller\CancelReasonController::class,
+                    'actions' => [
+                        'index' => [
+                            'role' => 'ROLE_ADMIN',
+                            'template' => '@ChillCalendar/CancelReason/index.html.twig',
+                        ],
+                        'new' => [
+                            'role' => 'ROLE_ADMIN',
+                            'template' => '@ChillCalendar/CancelReason/new.html.twig',
+                        ],
+                        'edit' => [
+                            'role' => 'ROLE_ADMIN',
+                            'template' => '@ChillCalendar/CancelReason/edit.html.twig',
+                        ],
+                    ],
+                ],
+            ],
             'apis' => [
                 [
                     'controller' => \Chill\CalendarBundle\Controller\CalendarRangeAPIController::class,

src/Bundle/ChillCalendarBundle/DependencyInjection/Configuration.php

@@ -26,9 +26,22 @@ class Configuration implements ConfigurationInterface
         $treeBuilder = new TreeBuilder('chill_calendar');
         $rootNode = $treeBuilder->getRootNode('chill_calendar');
 
-        // Here you should define the parameters that are allowed to
-        // configure your bundle. See the documentation linked above for
-        // more information on that topic.
+        $rootNode
+            ->children()
+            ->arrayNode('short_messages')
+            ->canBeDisabled()
+            ->children()->end()
+            ->end() // end for short_messages
+            ->arrayNode('remote_calendars_sync')->canBeEnabled()
+            ->children()
+            ->arrayNode('microsoft_graph')->canBeEnabled()
+            ->children()
+            ->end() // end of machine_access_token
+            ->end() // end of microsoft_graph children
+            ->end() // end of array microsoft_graph
+            ->end() // end of children's remote_calendars_sync
+            ->end() // end of array remote_calendars_sync
+            ->end();
 
         return $treeBuilder;
     }

src/Bundle/ChillCalendarBundle/Entity/Calendar.php

@@ -12,40 +12,79 @@ declare(strict_types=1);
 namespace Chill\CalendarBundle\Entity;
 
 use Chill\ActivityBundle\Entity\Activity;
-use Chill\CalendarBundle\Repository\CalendarRepository;
+use Chill\MainBundle\Doctrine\Model\TrackCreationInterface;
+use Chill\MainBundle\Doctrine\Model\TrackCreationTrait;
+use Chill\MainBundle\Doctrine\Model\TrackUpdateInterface;
+use Chill\MainBundle\Doctrine\Model\TrackUpdateTrait;
 use Chill\MainBundle\Entity\Embeddable\CommentEmbeddable;
+use Chill\MainBundle\Entity\Embeddable\PrivateCommentEmbeddable;
 use Chill\MainBundle\Entity\Location;
 use Chill\MainBundle\Entity\User;
 use Chill\PersonBundle\Entity\AccompanyingPeriod;
 use Chill\PersonBundle\Entity\Person;
 use Chill\ThirdPartyBundle\Entity\ThirdParty;
+use DateInterval;
 use DateTimeImmutable;
 use Doctrine\Common\Collections\ArrayCollection;
 use Doctrine\Common\Collections\Collection;
+use Doctrine\Common\Collections\Criteria;
 use Doctrine\ORM\Mapping as ORM;
+use LogicException;
 use Symfony\Component\Serializer\Annotation as Serializer;
-use Symfony\Component\Serializer\Annotation\Groups;
 use Symfony\Component\Validator\Constraints\NotBlank;
+
 use Symfony\Component\Validator\Constraints\Range;
 use Symfony\Component\Validator\Mapping\ClassMetadata;
-
 use function in_array;
 
 /**
- * @ORM\Table(name="chill_calendar.calendar")
- * @ORM\Entity(repositoryClass=CalendarRepository::class)
+ * @ORM\Table(
+ *     name="chill_calendar.calendar",
+ *     uniqueConstraints={@ORM\UniqueConstraint(name="idx_calendar_remote", columns={"remoteId"}, options={"where": "remoteId <> ''"})}
+ * )
+ * @ORM\Entity
  */
-class Calendar
+class Calendar implements TrackCreationInterface, TrackUpdateInterface
 {
+    use RemoteCalendarTrait;
+
+    use TrackCreationTrait;
+
+    use TrackUpdateTrait;
+
+    public const SMS_CANCEL_PENDING = 'sms_cancel_pending';
+
+    public const SMS_PENDING = 'sms_pending';
+
+    public const SMS_SENT = 'sms_sent';
+
     public const STATUS_CANCELED = 'canceled';
 
     public const STATUS_MOVED = 'moved';
 
     public const STATUS_VALID = 'valid';
 
+    /**
+     * a list of invite which have been added during this session.
+     *
+     * @var array|Invite[]
+     */
+    public array $newInvites = [];
+
+    /**
+     * a list of invite which have been removed during this session.
+     *
+     * @var array|Invite[]
+     */
+    public array $oldInvites = [];
+
+    public ?CalendarRange $previousCalendarRange = null;
+
+    public ?User $previousMainUser = null;
+
     /**
      * @ORM\ManyToOne(targetEntity="Chill\PersonBundle\Entity\AccompanyingPeriod")
-     * @Groups({"read"})
+     * @Serializer\Groups({"read"})
      */
     private AccompanyingPeriod $accompanyingPeriod;
 
@@ -55,7 +94,8 @@ class Calendar
     private ?Activity $activity = null;
 
     /**
-     * @ORM\ManyToOne(targetEntity="CalendarRange", inversedBy="calendars")
+     * @ORM\OneToOne(targetEntity="CalendarRange", inversedBy="calendar")
+     * @Serializer\Groups({"calendar:read", "read"})
      */
     private ?CalendarRange $calendarRange = null;
 
@@ -66,13 +106,13 @@ class Calendar
 
     /**
      * @ORM\Embedded(class=CommentEmbeddable::class, columnPrefix="comment_")
-     * @Serializer\Groups({"calendar:read"})
+     * @Serializer\Groups({"calendar:read", "read"})
      */
     private CommentEmbeddable $comment;
 
     /**
-     * @ORM\Column(type="datetimetz_immutable")
-     * @Serializer\Groups({"calendar:read"})
+     * @ORM\Column(type="datetime_immutable", nullable=false)
+     * @Serializer\Groups({"calendar:read", "read"})
      */
     private ?DateTimeImmutable $endDate = null;
 
@@ -80,104 +120,123 @@ class Calendar
      * @ORM\Id
      * @ORM\GeneratedValue
      * @ORM\Column(type="integer")
-     * @Serializer\Groups({"calendar:read"})
+     * @Serializer\Groups({"calendar:read", "read"})
      */
-    private ?int $id;
+    private ?int $id = null;
 
     /**
-     * @ORM\ManyToMany(
-     *     targetEntity="Invite",
-     * cascade={"persist", "remove", "merge", "detach"})
+     * @ORM\OneToMany(
+     *     targetEntity=Invite::class,
+     *     mappedBy="calendar",
+     *     orphanRemoval=true,
+     *     cascade={"persist", "remove", "merge", "detach"}
+     * )
      * @ORM\JoinTable(name="chill_calendar.calendar_to_invites")
-     * @Groups({"read"})
+     * @Serializer\Groups({"read"})
      */
     private Collection $invites;
 
     /**
      * @ORM\ManyToOne(targetEntity="Chill\MainBundle\Entity\Location")
-     * @groups({"read"})
+     * @Serializer\Groups({"read"})
      */
     private ?Location $location = null;
 
     /**
      * @ORM\ManyToOne(targetEntity="Chill\MainBundle\Entity\User")
-     * @Serializer\Groups({"calendar:read"})
+     * @Serializer\Groups({"calendar:read", "read"})
      */
-    private ?User $mainUser;
+    private ?User $mainUser = null;
 
     /**
      * @ORM\ManyToMany(
      *     targetEntity="Chill\PersonBundle\Entity\Person",
      * cascade={"persist", "remove", "merge", "detach"})
      * @ORM\JoinTable(name="chill_calendar.calendar_to_persons")
-     * @Groups({"read"})
-     * @Serializer\Groups({"calendar:read"})
+     * @Serializer\Groups({"calendar:read", "read"})
      */
     private Collection $persons;
 
+    /**
+     * @ORM\Embedded(class=PrivateCommentEmbeddable::class, columnPrefix="privateComment_")
+     * @Serializer\Groups({"calendar:read"})
+     */
+    private PrivateCommentEmbeddable $privateComment;
+
     /**
      * @ORM\ManyToMany(
      *     targetEntity="Chill\ThirdPartyBundle\Entity\ThirdParty",
      * cascade={"persist", "remove", "merge", "detach"})
      * @ORM\JoinTable(name="chill_calendar.calendar_to_thirdparties")
-     * @Groups({"read"})
-     * @Serializer\Groups({"calendar:read"})
+     * @Serializer\Groups({"calendar:read", "read"})
      */
     private Collection $professionals;
 
     /**
      * @ORM\Column(type="boolean", nullable=true)
      */
-    private ?bool $sendSMS;
+    private ?bool $sendSMS = null;
 
     /**
-     * @ORM\Column(type="datetimetz_immutable")
-     * @Serializer\Groups({"calendar:read"})
+     * @ORM\Column(type="text", nullable=false, options={"default": Calendar::SMS_PENDING})
+     */
+    private string $smsStatus = self::SMS_PENDING;
+
+    /**
+     * @ORM\Column(type="datetime_immutable", nullable=false)
+     * @Serializer\Groups({"calendar:read", "read"})
      */
     private ?DateTimeImmutable $startDate = null;
 
     /**
-     * @ORM\Column(type="string", length=255)
+     * @ORM\Column(type="string", length=255, nullable=false, options={"default": "valid"})
      */
-    private ?string $status = null;
-
-    /**
-     * @ORM\ManyToOne(targetEntity="Chill\MainBundle\Entity\User")
-     * @Groups({"read"})
-     * @Serializer\Groups({"calendar:read"})
-     */
-    private ?User $user = null;
+    private string $status = self::STATUS_VALID;
 
     public function __construct()
     {
         $this->comment = new CommentEmbeddable();
+        $this->privateComment = new PrivateCommentEmbeddable();
         $this->persons = new ArrayCollection();
         $this->professionals = new ArrayCollection();
         $this->invites = new ArrayCollection();
     }
 
-    public function addInvite(?Invite $invite): self
+    /**
+     * @internal Use {@link (Calendar::addUser)} instead
+     */
+    public function addInvite(Invite $invite): self
     {
-        if (null !== $invite) {
-            $this->invites[] = $invite;
+        if ($invite->getCalendar() instanceof Calendar && $invite->getCalendar() !== $this) {
+            throw new LogicException('Not allowed to move an invitation to another Calendar');
         }
 
+        $this->invites[] = $invite;
+        $this->newInvites[] = $invite;
+
+        $invite->setCalendar($this);
+
         return $this;
     }
 
-    public function addPerson(?Person $person): self
+    public function addPerson(Person $person): self
     {
-        if (null !== $person) {
-            $this->persons[] = $person;
-        }
+        $this->persons[] = $person;
 
         return $this;
     }
 
-    public function addProfessional(?ThirdParty $professional): self
+    public function addProfessional(ThirdParty $professional): self
     {
-        if (null !== $professional) {
-            $this->professionals[] = $professional;
+        $this->professionals[] = $professional;
+
+        return $this;
+    }
+
+    public function addUser(User $user): self
+    {
+        if (!$this->getUsers()->contains($user) && $this->getMainUser() !== $user) {
+            $this->addInvite((new Invite())->setUser($user));
         }
 
         return $this;
@@ -208,6 +267,15 @@ class Calendar
         return $this->comment;
     }
 
+    public function getDuration(): ?DateInterval
+    {
+        if ($this->getStartDate() === null || $this->getEndDate() === null) {
+            return null;
+        }
+
+        return $this->getStartDate()->diff($this->getEndDate());
+    }
+
     public function getEndDate(): ?DateTimeImmutable
     {
         return $this->endDate;
@@ -218,6 +286,21 @@ class Calendar
         return $this->id;
     }
 
+    public function getInviteForUser(User $user): ?Invite
+    {
+        $criteria = Criteria::create();
+        $criteria->where(Criteria::expr()->eq('user', $user));
+
+        $matchings = $this->invites
+            ->matching($criteria);
+
+        if (1 === $matchings->count()) {
+            return $matchings->first();
+        }
+
+        return null;
+    }
+
     /**
      * @return Collection|Invite[]
      */
@@ -278,6 +361,11 @@ class Calendar
         return [];
     }
 
+    public function getPrivateComment(): PrivateCommentEmbeddable
+    {
+        return $this->privateComment;
+    }
+
     /**
      * @return Collection|ThirdParty[]
      */
@@ -291,6 +379,11 @@ class Calendar
         return $this->sendSMS;
     }
 
+    public function getSmsStatus(): string
+    {
+        return $this->smsStatus;
+    }
+
     public function getStartDate(): ?DateTimeImmutable
     {
         return $this->startDate;
@@ -306,14 +399,30 @@ class Calendar
         return $this->getProfessionals();
     }
 
-    public function getUser(): ?User
+    /**
+     * @return Collection|User[]
+     * @Serializer\Groups({"calendar:read", "read"})
+     */
+    public function getUsers(): Collection
     {
-        return $this->user;
+        return $this->getInvites()->map(static function (Invite $i) { return $i->getUser(); });
     }
 
-    public function getusers(): Collection
+    public function hasCalendarRange(): bool
     {
-        return $this->getInvites(); //TODO get users of the invite
+        return null !== $this->calendarRange;
+    }
+
+    /**
+     * return true if the user is invited.
+     */
+    public function isInvited(User $user): bool
+    {
+        if ($this->getMainUser() === $user) {
+            return false;
+        }
+
+        return $this->getUsers()->contains($user);
     }
 
     public static function loadValidatorMetadata(ClassMetadata $metadata): void
@@ -330,9 +439,15 @@ class Calendar
         ]));
     }
 
+    /**
+     * @internal Use {@link (Calendar::removeUser)} instead
+     */
     public function removeInvite(Invite $invite): self
     {
-        $this->invites->removeElement($invite);
+        if ($this->invites->removeElement($invite)) {
+            $invite->setCalendar(null);
+            $this->oldInvites[] = $invite;
+        }
 
         return $this;
     }
@@ -351,6 +466,20 @@ class Calendar
         return $this;
     }
 
+    public function removeUser(User $user): self
+    {
+        if (!$this->getUsers()->contains($user)) {
+            return $this;
+        }
+
+        $invite = $this->invites
+            ->filter(static function (Invite $invite) use ($user) { return $invite->getUser() === $user; })
+            ->first();
+        $this->removeInvite($invite);
+
+        return $this;
+    }
+
     public function setAccompanyingPeriod(?AccompanyingPeriod $accompanyingPeriod): self
     {
         $this->accompanyingPeriod = $accompanyingPeriod;
@@ -367,8 +496,20 @@ class Calendar
 
     public function setCalendarRange(?CalendarRange $calendarRange): self
     {
+        if ($this->calendarRange !== $calendarRange) {
+            $this->previousCalendarRange = $this->calendarRange;
+
+            if (null !== $this->previousCalendarRange) {
+                $this->previousCalendarRange->setCalendar(null);
+            }
+        }
+
         $this->calendarRange = $calendarRange;
 
+        if ($this->calendarRange instanceof CalendarRange) {
+            $this->calendarRange->setCalendar($this);
+        }
+
         return $this;
     }
 
@@ -402,7 +543,19 @@ class Calendar
 
     public function setMainUser(?User $mainUser): self
     {
+        if ($this->mainUser !== $mainUser) {
+            $this->previousMainUser = $this->mainUser;
+        }
+
         $this->mainUser = $mainUser;
+        $this->removeUser($mainUser);
+
+        return $this;
+    }
+
+    public function setPrivateComment(PrivateCommentEmbeddable $privateComment): self
+    {
+        $this->privateComment = $privateComment;
 
         return $this;
     }
@@ -414,6 +567,13 @@ class Calendar
         return $this;
     }
 
+    public function setSmsStatus(string $smsStatus): self
+    {
+        $this->smsStatus = $smsStatus;
+
+        return $this;
+    }
+
     public function setStartDate(DateTimeImmutable $startDate): self
     {
         $this->startDate = $startDate;
@@ -425,12 +585,9 @@ class Calendar
     {
         $this->status = $status;
 
-        return $this;
-    }
-
-    public function setUser(?User $user): self
-    {
-        $this->user = $user;
+        if (self::STATUS_CANCELED === $status && $this->getSmsStatus() === self::SMS_SENT) {
+            $this->setSmsStatus(self::SMS_CANCEL_PENDING);
+        }
 
         return $this;
     }

src/Bundle/ChillCalendarBundle/Entity/CalendarRange.php

@@ -11,29 +11,38 @@ declare(strict_types=1);
 
 namespace Chill\CalendarBundle\Entity;
 
-use Chill\CalendarBundle\Repository\CalendarRangeRepository;
+use Chill\MainBundle\Doctrine\Model\TrackCreationInterface;
+use Chill\MainBundle\Doctrine\Model\TrackCreationTrait;
+use Chill\MainBundle\Doctrine\Model\TrackUpdateInterface;
+use Chill\MainBundle\Doctrine\Model\TrackUpdateTrait;
 use Chill\MainBundle\Entity\User;
 use DateTimeImmutable;
-use Doctrine\Common\Collections\ArrayCollection;
-use Doctrine\Common\Collections\Collection;
 use Doctrine\ORM\Mapping as ORM;
 use Symfony\Component\Serializer\Annotation\Groups;
 
 /**
- * @ORM\Table(name="chill_calendar.calendar_range")
- * @ORM\Entity(repositoryClass=CalendarRangeRepository::class)
+ * @ORM\Table(
+ *     name="chill_calendar.calendar_range",
+ *     uniqueConstraints={@ORM\UniqueConstraint(name="idx_calendar_range_remote", columns={"remoteId"}, options={"where": "remoteId <> ''"})}
+ * )
+ * @ORM\Entity
  */
-class CalendarRange
+class CalendarRange implements TrackCreationInterface, TrackUpdateInterface
 {
-    /**
-     * @ORM\OneToMany(targetEntity=Calendar::class,
-     * mappedBy="calendarRange")
-     */
-    private Collection $calendars;
+    use RemoteCalendarTrait;
+
+    use TrackCreationTrait;
+
+    use TrackUpdateTrait;
 
     /**
-     * @ORM\Column(type="datetimetz_immutable")
-     * @groups({"read", "write"})
+     * @ORM\OneToOne(targetEntity=Calendar::class, mappedBy="calendarRange")
+     */
+    private ?Calendar $calendar = null;
+
+    /**
+     * @ORM\Column(type="datetime_immutable", nullable=false)
+     * @groups({"read", "write", "calendar:read"})
      */
     private ?DateTimeImmutable $endDate = null;
 
@@ -46,24 +55,24 @@ class CalendarRange
     private $id;
 
     /**
-     * @ORM\Column(type="datetimetz_immutable")
-     * @groups({"read", "write"})
+     * @ORM\Column(type="datetime_immutable", nullable=false)
+     * @groups({"read", "write", "calendar:read"})
      */
     private ?DateTimeImmutable $startDate = null;
 
     /**
      * @ORM\ManyToOne(targetEntity="Chill\MainBundle\Entity\User")
-     * @groups({"read", "write"})
+     * @groups({"read", "write", "calendar:read"})
      */
     private ?User $user = null;
 
-    //TODO Lieu
-
-    public function __construct()
+    public function getCalendar(): ?Calendar
     {
-        $this->calendars = new ArrayCollection();
+        return $this->calendar;
     }
 
+    //TODO Lieu
+
     public function getEndDate(): ?DateTimeImmutable
     {
         return $this->endDate;
@@ -84,6 +93,14 @@ class CalendarRange
         return $this->user;
     }
 
+    /**
+     * @internal use {@link (Calendar::setCalendarRange)} instead
+     */
+    public function setCalendar(?Calendar $calendar): void
+    {
+        $this->calendar = $calendar;
+    }
+
     public function setEndDate(DateTimeImmutable $endDate): self
     {
         $this->endDate = $endDate;

src/Bundle/ChillCalendarBundle/Entity/Invite.php

@@ -11,39 +11,90 @@ declare(strict_types=1);
 
 namespace Chill\CalendarBundle\Entity;
 
-use Chill\CalendarBundle\Repository\InviteRepository;
+use Chill\MainBundle\Doctrine\Model\TrackCreationInterface;
+use Chill\MainBundle\Doctrine\Model\TrackCreationTrait;
+use Chill\MainBundle\Doctrine\Model\TrackUpdateInterface;
+use Chill\MainBundle\Doctrine\Model\TrackUpdateTrait;
 use Chill\MainBundle\Entity\User;
 use Doctrine\ORM\Mapping as ORM;
+use LogicException;
+use Symfony\Component\Serializer\Annotation as Serializer;
 
 /**
- * @ORM\Table(name="chill_calendar.invite")
- * @ORM\Entity(repositoryClass=InviteRepository::class)
+ * An invitation for another user to a Calendar.
+ *
+ * The event/calendar in the user may have a different id than the mainUser. We add then fields to store the
+ * remote id of this event in the remote calendar.
+ *
+ * @ORM\Table(
+ *     name="chill_calendar.invite",
+ *     uniqueConstraints={@ORM\UniqueConstraint(name="idx_calendar_invite_remote", columns={"remoteId"}, options={"where": "remoteId <> ''"})}
+ * )
+ * @ORM\Entity
  */
-class Invite
+class Invite implements TrackUpdateInterface, TrackCreationInterface
 {
+    use RemoteCalendarTrait;
+
+    use TrackCreationTrait;
+
+    use TrackUpdateTrait;
+
+    public const ACCEPTED = 'accepted';
+
+    public const DECLINED = 'declined';
+
+    public const PENDING = 'pending';
+
+    /**
+     * all statuses in one const.
+     */
+    public const STATUSES = [
+        self::ACCEPTED,
+        self::DECLINED,
+        self::PENDING,
+        self::TENTATIVELY_ACCEPTED,
+    ];
+
+    public const TENTATIVELY_ACCEPTED = 'tentative';
+
+    /**
+     * @ORM\ManyToOne(targetEntity=Calendar::class, inversedBy="invites")
+     */
+    private ?Calendar $calendar = null;
+
     /**
      * @ORM\Id
      * @ORM\GeneratedValue
      * @ORM\Column(type="integer")
+     * @Serializer\Groups(groups={"calendar:read", "read"})
      */
-    private $id;
+    private ?int $id = null;
 
     /**
-     * @ORM\Column(type="json")
+     * @ORM\Column(type="text", nullable=false, options={"default": "pending"})
+     * @Serializer\Groups(groups={"calendar:read", "read"})
      */
-    private array $status = [];
+    private string $status = self::PENDING;
 
     /**
      * @ORM\ManyToOne(targetEntity="Chill\MainBundle\Entity\User")
+     * @ORM\JoinColumn(nullable=false)
+     * @Serializer\Groups(groups={"calendar:read", "read"})
      */
-    private User $user;
+    private ?User $user = null;
+
+    public function getCalendar(): ?Calendar
+    {
+        return $this->calendar;
+    }
 
     public function getId(): ?int
     {
         return $this->id;
     }
 
-    public function getStatus(): ?array
+    public function getStatus(): string
     {
         return $this->status;
     }
@@ -53,7 +104,15 @@ class Invite
         return $this->user;
     }
 
-    public function setStatus(array $status): self
+    /**
+     * @internal use Calendar::addInvite instead
+     */
+    public function setCalendar(?Calendar $calendar): void
+    {
+        $this->calendar = $calendar;
+    }
+
+    public function setStatus(string $status): self
     {
         $this->status = $status;
 
@@ -62,6 +121,10 @@ class Invite
 
     public function setUser(?User $user): self
     {
+        if ($user instanceof User && $this->user instanceof User && $user !== $this->user) {
+            throw new LogicException('Not allowed to associate an invite to a different user');
+        }
+
         $this->user = $user;
 
         return $this;

src/Bundle/ChillCalendarBundle/Entity/RemoteCalendarTrait.php

@@ -0,0 +1,64 @@
+<?php
+
+/**
+ * Chill is a software for social workers
+ *
+ * For the full copyright and license information, please view
+ * the LICENSE file that was distributed with this source code.
+ */
+
+declare(strict_types=1);
+
+namespace Chill\CalendarBundle\Entity;
+
+use Doctrine\ORM\Mapping as ORM;
+
+trait RemoteCalendarTrait
+{
+    /**
+     * If true, the changes won't be enqueued to remote.
+     *
+     * This is required to prevent update loop: a persist trigger an event creation on remote,
+     * which in turn change remoteId and, in turn, trigger an update change, ...
+     */
+    public bool $preventEnqueueChanges = false;
+
+    /**
+     * @ORM\Column(type="json", options={"default": "[]"}, nullable=false)
+     */
+    private array $remoteAttributes = [];
+
+    /**
+     * @ORM\Column(type="text", options={"default": ""}, nullable=false)
+     */
+    private string $remoteId = '';
+
+    public function addRemoteAttributes(array $remoteAttributes): self
+    {
+        $this->remoteAttributes = array_merge($this->remoteAttributes, $remoteAttributes);
+
+        return $this;
+    }
+
+    public function getRemoteAttributes(): array
+    {
+        return $this->remoteAttributes;
+    }
+
+    public function getRemoteId(): string
+    {
+        return $this->remoteId;
+    }
+
+    public function hasRemoteId(): bool
+    {
+        return '' !== $this->remoteId;
+    }
+
+    public function setRemoteId(string $remoteId): self
+    {
+        $this->remoteId = $remoteId;
+
+        return $this;
+    }
+}

src/Bundle/ChillCalendarBundle/Form/CalendarType.php

@@ -12,17 +12,16 @@ declare(strict_types=1);
 namespace Chill\CalendarBundle\Form;
 
 use Chill\CalendarBundle\Entity\Calendar;
-use Chill\CalendarBundle\Entity\CalendarRange;
 use Chill\CalendarBundle\Entity\CancelReason;
-use Chill\CalendarBundle\Entity\Invite;
-use Chill\MainBundle\Entity\Location;
-use Chill\MainBundle\Entity\User;
+use Chill\CalendarBundle\Form\DataTransformer\IdToCalendarRangeDataTransformer;
+use Chill\MainBundle\Form\DataTransformer\IdToLocationDataTransformer;
+use Chill\MainBundle\Form\DataTransformer\IdToUserDataTransformer;
+use Chill\MainBundle\Form\DataTransformer\IdToUsersDataTransformer;
 use Chill\MainBundle\Form\Type\CommentType;
-use Chill\MainBundle\Templating\TranslatableStringHelper;
-use Chill\PersonBundle\Entity\Person;
-use Chill\ThirdPartyBundle\Entity\ThirdParty;
+use Chill\MainBundle\Form\Type\PrivateCommentType;
+use Chill\PersonBundle\Form\DataTransformer\PersonsToIdDataTransformer;
+use Chill\ThirdPartyBundle\Form\DataTransformer\ThirdPartiesToIdDataTransformer;
 use DateTimeImmutable;
-use Doctrine\Persistence\ObjectManager;
 use Symfony\Bridge\Doctrine\Form\Type\EntityType;
 use Symfony\Component\Form\AbstractType;
 use Symfony\Component\Form\CallbackTransformer;
@@ -33,16 +32,32 @@ use Symfony\Component\OptionsResolver\OptionsResolver;
 
 class CalendarType extends AbstractType
 {
-    protected ObjectManager $om;
+    private IdToCalendarRangeDataTransformer $calendarRangeDataTransformer;
 
-    protected TranslatableStringHelper $translatableStringHelper;
+    private IdToLocationDataTransformer $idToLocationDataTransformer;
+
+    private IdToUserDataTransformer $idToUserDataTransformer;
+
+    private IdToUsersDataTransformer $idToUsersDataTransformer;
+
+    private ThirdPartiesToIdDataTransformer $partiesToIdDataTransformer;
+
+    private PersonsToIdDataTransformer $personsToIdDataTransformer;
 
     public function __construct(
-        TranslatableStringHelper $translatableStringHelper,
-        ObjectManager $om
+        PersonsToIdDataTransformer $personsToIdDataTransformer,
+        IdToUserDataTransformer $idToUserDataTransformer,
+        IdToUsersDataTransformer $idToUsersDataTransformer,
+        IdToLocationDataTransformer $idToLocationDataTransformer,
+        ThirdPartiesToIdDataTransformer $partiesToIdDataTransformer,
+        IdToCalendarRangeDataTransformer $idToCalendarRangeDataTransformer
     ) {
-        $this->translatableStringHelper = $translatableStringHelper;
-        $this->om = $om;
+        $this->personsToIdDataTransformer = $personsToIdDataTransformer;
+        $this->idToUserDataTransformer = $idToUserDataTransformer;
+        $this->idToUsersDataTransformer = $idToUsersDataTransformer;
+        $this->idToLocationDataTransformer = $idToLocationDataTransformer;
+        $this->partiesToIdDataTransformer = $partiesToIdDataTransformer;
+        $this->calendarRangeDataTransformer = $idToCalendarRangeDataTransformer;
     }
 
     public function buildForm(FormBuilderInterface $builder, array $options)
@@ -51,6 +66,10 @@ class CalendarType extends AbstractType
             ->add('comment', CommentType::class, [
                 'required' => false,
             ])
+            ->add('privateComment', PrivateCommentType::class, [
+                'required' => false,
+                'label' => 'private comment',
+            ])
             // ->add('cancelReason', EntityType::class, [
             //     'required' => false,
             //     'class' => CancelReason::class,
@@ -68,36 +87,26 @@ class CalendarType extends AbstractType
             ]);
 
         $builder->add('mainUser', HiddenType::class);
-        $builder->get('mainUser')
-            ->addModelTransformer(new CallbackTransformer(
-                static function (?User $user): int {
-                    if (null !== $user) {
-                        $res = $user->getId();
-                    } else {
-                        $res = -1; //TODO cannot be null in any ways...
-                    }
-
-                    return $res;
-                },
-                function (?int $userId): User {
-                    return $this->om->getRepository(user::class)->findOneBy(['id' => (int) $userId]);
-                }
-            ));
+        $builder->get('mainUser')->addModelTransformer($this->idToUserDataTransformer);
 
         $builder->add('startDate', HiddenType::class);
         $builder->get('startDate')
             ->addModelTransformer(new CallbackTransformer(
                 static function (?DateTimeImmutable $dateTimeImmutable): string {
                     if (null !== $dateTimeImmutable) {
-                        $res = date_format($dateTimeImmutable, 'Y-m-d H:i:s');
+                        $res = date_format($dateTimeImmutable, DateTimeImmutable::ATOM);
                     } else {
                         $res = '';
                     }
 
                     return $res;
                 },
-                static function (?string $dateAsString): DateTimeImmutable {
-                    return new DateTimeImmutable($dateAsString);
+                static function (?string $dateAsString): ?DateTimeImmutable {
+                    if ('' === $dateAsString) {
+                        return null;
+                    }
+
+                    return DateTimeImmutable::createFromFormat(DateTimeImmutable::ATOM, $dateAsString);
                 }
             ));
 
@@ -106,121 +115,41 @@ class CalendarType extends AbstractType
             ->addModelTransformer(new CallbackTransformer(
                 static function (?DateTimeImmutable $dateTimeImmutable): string {
                     if (null !== $dateTimeImmutable) {
-                        $res = date_format($dateTimeImmutable, 'Y-m-d H:i:s');
+                        $res = date_format($dateTimeImmutable, DateTimeImmutable::ATOM);
                     } else {
                         $res = '';
                     }
 
                     return $res;
                 },
-                static function (?string $dateAsString): DateTimeImmutable {
-                    return new DateTimeImmutable($dateAsString);
+                static function (?string $dateAsString): ?DateTimeImmutable {
+                    if ('' === $dateAsString) {
+                        return null;
+                    }
+
+                    return DateTimeImmutable::createFromFormat(DateTimeImmutable::ATOM, $dateAsString);
                 }
             ));
 
         $builder->add('persons', HiddenType::class);
         $builder->get('persons')
-            ->addModelTransformer(new CallbackTransformer(
-                static function (iterable $personsAsIterable): string {
-                    $personIds = [];
-
-                    foreach ($personsAsIterable as $value) {
-                        $personIds[] = $value->getId();
-                    }
-
-                    return implode(',', $personIds);
-                },
-                function (?string $personsAsString): array {
-                    if (null === $personsAsString) {
-                        return [];
-                    }
-                    return array_map(
-                        fn (string $id): ?Person => $this->om->getRepository(Person::class)->findOneBy(['id' => (int) $id]),
-                        explode(',', $personsAsString)
-                    );
-                }
-            ));
+            ->addModelTransformer($this->personsToIdDataTransformer);
 
         $builder->add('professionals', HiddenType::class);
         $builder->get('professionals')
-            ->addModelTransformer(new CallbackTransformer(
-                static function (iterable $thirdpartyAsIterable): string {
-                    $thirdpartyIds = [];
+            ->addModelTransformer($this->partiesToIdDataTransformer);
 
-                    foreach ($thirdpartyAsIterable as $value) {
-                        $thirdpartyIds[] = $value->getId();
-                    }
-
-                    return implode(',', $thirdpartyIds);
-                },
-                function (?string $thirdpartyAsString): array {
-                    if (null === $thirdpartyAsString) {
-                        return [];
-                    }
-                    return array_map(
-                        fn (string $id): ?ThirdParty => $this->om->getRepository(ThirdParty::class)->findOneBy(['id' => (int) $id]),
-                        explode(',', $thirdpartyAsString)
-                    );
-                }
-            ));
+        $builder->add('users', HiddenType::class);
+        $builder->get('users')
+            ->addModelTransformer($this->idToUsersDataTransformer);
 
         $builder->add('calendarRange', HiddenType::class);
         $builder->get('calendarRange')
-            ->addModelTransformer(new CallbackTransformer(
-                static function (?CalendarRange $calendarRange): ?int {
-                    if (null !== $calendarRange) {
-                        $res = $calendarRange->getId();
-                    } else {
-                        $res = -1;
-                    }
-
-                    return $res;
-                },
-                function (?string $calendarRangeId): ?CalendarRange {
-                    if (null !== $calendarRangeId) {
-                        $res = $this->om->getRepository(CalendarRange::class)->findOneBy(['id' => (int) $calendarRangeId]);
-                    } else {
-                        $res = null;
-                    }
-
-                    return $res;
-                }
-            ));
+            ->addModelTransformer($this->calendarRangeDataTransformer);
 
         $builder->add('location', HiddenType::class)
             ->get('location')
-            ->addModelTransformer(new CallbackTransformer(
-                static function (?Location $location): string {
-                    if (null === $location) {
-                        return '';
-                    }
-
-                    return $location->getId();
-                },
-                function (?string $id): ?Location {
-                    return $this->om->getRepository(Location::class)->findOneBy(['id' => (int) $id]);
-                }
-            ));
-
-        $builder->add('invites', HiddenType::class);
-        $builder->get('invites')
-            ->addModelTransformer(new CallbackTransformer(
-                static function (iterable $usersAsIterable): string {
-                    $userIds = [];
-
-                    foreach ($usersAsIterable as $value) {
-                        $userIds[] = $value->getId();
-                    }
-
-                    return implode(',', $userIds);
-                },
-                function (?string $usersAsString): array {
-                    return array_map(
-                        fn (string $id): ?Invite => $this->om->getRepository(Invite::class)->findOneBy(['id' => (int) $id]),
-                        explode(',', $usersAsString)
-                    );
-                }
-            ));
+            ->addModelTransformer($this->idToLocationDataTransformer);
     }
 
     public function configureOptions(OptionsResolver $resolver)
@@ -228,10 +157,6 @@ class CalendarType extends AbstractType
         $resolver->setDefaults([
             'data_class' => Calendar::class,
         ]);
-
-        $resolver
-            ->setRequired(['accompanyingPeriod'])
-            ->setAllowedTypes('accompanyingPeriod', [\Chill\PersonBundle\Entity\AccompanyingPeriod::class, 'null']);
     }
 
     public function getBlockPrefix()

src/Bundle/ChillCalendarBundle/Form/CancelReasonType.php

@@ -0,0 +1,39 @@
+<?php
+
+/**
+ * Chill is a software for social workers
+ *
+ * For the full copyright and license information, please view
+ * the LICENSE file that was distributed with this source code.
+ */
+
+declare(strict_types=1);
+
+namespace Chill\CalendarBundle\Form;
+
+use Chill\CalendarBundle\Entity\CancelReason;
+use Chill\MainBundle\Form\Type\TranslatableStringFormType;
+use Symfony\Component\Form\AbstractType;
+use Symfony\Component\Form\Extension\Core\Type\CheckboxType;
+use Symfony\Component\Form\Extension\Core\Type\TextType;
+use Symfony\Component\Form\FormBuilderInterface;
+use Symfony\Component\OptionsResolver\OptionsResolver;
+
+class CancelReasonType extends AbstractType
+{
+    public function buildForm(FormBuilderInterface $builder, array $options)
+    {
+        $builder
+            ->add('name', TranslatableStringFormType::class)
+            ->add('active', CheckboxType::class, [
+                'required' => false,
+            ])
+            ->add('canceledBy', TextType::class);
+    }
+
+    public function configureOptions(OptionsResolver $resolver)
+    {
+        $resolver
+            ->setDefault('class', CancelReason::class);
+    }
+}

src/Bundle/ChillCalendarBundle/Form/DataTransformer/IdToCalendarRangeDataTransformer.php

@@ -0,0 +1,23 @@
+<?php
+
+/**
+ * Chill is a software for social workers
+ *
+ * For the full copyright and license information, please view
+ * the LICENSE file that was distributed with this source code.
+ */
+
+declare(strict_types=1);
+
+namespace Chill\CalendarBundle\Form\DataTransformer;
+
+use Chill\CalendarBundle\Repository\CalendarRangeRepository;
+use Chill\MainBundle\Form\DataTransformer\IdToEntityDataTransformer;
+
+class IdToCalendarRangeDataTransformer extends IdToEntityDataTransformer
+{
+    public function __construct(CalendarRangeRepository $repository)
+    {
+        parent::__construct($repository, false);
+    }
+}

src/Bundle/ChillCalendarBundle/Menu/AccompanyingCourseMenuBuilder.php

@@ -13,20 +13,16 @@ namespace Chill\CalendarBundle\Menu;
 
 use Chill\CalendarBundle\Security\Voter\CalendarVoter;
 use Chill\MainBundle\Routing\LocalMenuBuilderInterface;
-use Chill\MainBundle\Security\Authorization\AuthorizationHelper;
-use Chill\PersonBundle\Entity\AccompanyingPeriod;
 use Knp\Menu\MenuItem;
-use Symfony\Bundle\SecurityBundle\SecurityBundle;
-use Symfony\Component\Security\Core\Authentication\Token\Storage\TokenStorageInterface;
 use Symfony\Component\Security\Core\Security;
 use Symfony\Contracts\Translation\TranslatorInterface;
 
 class AccompanyingCourseMenuBuilder implements LocalMenuBuilderInterface
 {
-    private Security $security;
-
     protected TranslatorInterface $translator;
 
+    private Security $security;
+
     public function __construct(
         Security $security,
         TranslatorInterface $translator
@@ -41,9 +37,9 @@ class AccompanyingCourseMenuBuilder implements LocalMenuBuilderInterface
 
         if ($this->security->isGranted(CalendarVoter::SEE, $period)) {
             $menu->addChild($this->translator->trans('Calendar'), [
-                'route' => 'chill_calendar_calendar_list',
+                'route' => 'chill_calendar_calendar_list_by_period',
                 'routeParameters' => [
-                    'accompanying_period_id' => $period->getId(),
+                    'id' => $period->getId(),
                 ], ])
                 ->setExtras(['order' => 35]);
         }

src/Bundle/ChillCalendarBundle/Menu/AdminMenuBuilder.php

@@ -0,0 +1,54 @@
+<?php
+
+/**
+ * Chill is a software for social workers
+ *
+ * For the full copyright and license information, please view
+ * the LICENSE file that was distributed with this source code.
+ */
+
+declare(strict_types=1);
+
+namespace Chill\CalendarBundle\Menu;
+
+use Chill\MainBundle\Routing\LocalMenuBuilderInterface;
+use Knp\Menu\MenuItem;
+use Symfony\Component\Security\Core\Authorization\AuthorizationCheckerInterface;
+
+class AdminMenuBuilder implements LocalMenuBuilderInterface
+{
+    /**
+     * @var AuthorizationCheckerInterface
+     */
+    protected $authorizationChecker;
+
+    public function __construct(AuthorizationCheckerInterface $authorizationChecker)
+    {
+        $this->authorizationChecker = $authorizationChecker;
+    }
+
+    public function buildMenu($menuId, MenuItem $menu, array $parameters)
+    {
+        if (!$this->authorizationChecker->isGranted('ROLE_ADMIN')) {
+            return;
+        }
+
+        $menu->addChild('Calendar', [
+            'route' => 'chill_calendar_admin_index',
+        ])
+            ->setAttribute('class', 'list-group-item-header')
+            ->setExtras([
+                'order' => 6000,
+                'icons' => ['calendar'],
+            ]);
+
+        $menu->addChild('Cancel reason', [
+            'route' => 'chill_crud_calendar_cancel-reason_index',
+        ])->setExtras(['order' => 6010]);
+    }
+
+    public static function getMenuIds(): array
+    {
+        return ['admin_section', 'admin_calendar'];
+    }
+}

src/Bundle/ChillCalendarBundle/Messenger/Doctrine/CalendarEntityListener.php

@@ -0,0 +1,62 @@
+<?php
+
+/**
+ * Chill is a software for social workers
+ *
+ * For the full copyright and license information, please view
+ * the LICENSE file that was distributed with this source code.
+ */
+
+declare(strict_types=1);
+
+namespace Chill\CalendarBundle\Messenger\Doctrine;
+
+use Chill\CalendarBundle\Entity\Calendar;
+use Chill\CalendarBundle\Messenger\Message\CalendarMessage;
+use Doctrine\ORM\Event\LifecycleEventArgs;
+use Symfony\Component\Messenger\MessageBusInterface;
+use Symfony\Component\Security\Core\Security;
+
+class CalendarEntityListener
+{
+    private MessageBusInterface $messageBus;
+
+    private Security $security;
+
+    public function __construct(MessageBusInterface $messageBus, Security $security)
+    {
+        $this->messageBus = $messageBus;
+        $this->security = $security;
+    }
+
+    public function postPersist(Calendar $calendar, LifecycleEventArgs $args): void
+    {
+        if (!$calendar->preventEnqueueChanges) {
+            $this->messageBus->dispatch(
+                new CalendarMessage(
+                    $calendar,
+                    CalendarMessage::CALENDAR_PERSIST,
+                    $this->security->getUser()
+                )
+            );
+        }
+    }
+
+    public function postRemove(Calendar $calendar, LifecycleEventArgs $args): void
+    {
+        // TODO
+    }
+
+    public function postUpdate(Calendar $calendar, LifecycleEventArgs $args): void
+    {
+        if (!$calendar->preventEnqueueChanges) {
+            $this->messageBus->dispatch(
+                new CalendarMessage(
+                    $calendar,
+                    CalendarMessage::CALENDAR_UPDATE,
+                    $this->security->getUser()
+                )
+            );
+        }
+    }
+}

src/Bundle/ChillCalendarBundle/Messenger/Doctrine/CalendarRangeEntityListener.php

@@ -0,0 +1,70 @@
+<?php
+
+/**
+ * Chill is a software for social workers
+ *
+ * For the full copyright and license information, please view
+ * the LICENSE file that was distributed with this source code.
+ */
+
+declare(strict_types=1);
+
+namespace Chill\CalendarBundle\Messenger\Doctrine;
+
+use Chill\CalendarBundle\Entity\CalendarRange;
+use Chill\CalendarBundle\Messenger\Message\CalendarRangeMessage;
+use Chill\CalendarBundle\Messenger\Message\CalendarRangeRemovedMessage;
+use Doctrine\ORM\Event\LifecycleEventArgs;
+use Symfony\Component\Messenger\MessageBusInterface;
+use Symfony\Component\Security\Core\Security;
+
+class CalendarRangeEntityListener
+{
+    private MessageBusInterface $messageBus;
+
+    private Security $security;
+
+    public function __construct(MessageBusInterface $messageBus, Security $security)
+    {
+        $this->messageBus = $messageBus;
+        $this->security = $security;
+    }
+
+    public function postPersist(CalendarRange $calendarRange, LifecycleEventArgs $eventArgs): void
+    {
+        if (!$calendarRange->preventEnqueueChanges) {
+            $this->messageBus->dispatch(
+                new CalendarRangeMessage(
+                    $calendarRange,
+                    CalendarRangeMessage::CALENDAR_RANGE_PERSIST,
+                    $this->security->getUser()
+                )
+            );
+        }
+    }
+
+    public function postRemove(CalendarRange $calendarRange, LifecycleEventArgs $eventArgs): void
+    {
+        if (!$calendarRange->preventEnqueueChanges) {
+            $this->messageBus->dispatch(
+                new CalendarRangeRemovedMessage(
+                    $calendarRange,
+                    $this->security->getUser()
+                )
+            );
+        }
+    }
+
+    public function postUpdate(CalendarRange $calendarRange, LifecycleEventArgs $eventArgs): void
+    {
+        if (!$calendarRange->preventEnqueueChanges) {
+            $this->messageBus->dispatch(
+                new CalendarRangeMessage(
+                    $calendarRange,
+                    CalendarRangeMessage::CALENDAR_RANGE_UPDATE,
+                    $this->security->getUser()
+                )
+            );
+        }
+    }
+}

src/Bundle/ChillCalendarBundle/Messenger/Handler/CalendarRangeRemoveToRemoteHandler.php

@@ -0,0 +1,43 @@
+<?php
+
+/**
+ * Chill is a software for social workers
+ *
+ * For the full copyright and license information, please view
+ * the LICENSE file that was distributed with this source code.
+ */
+
+declare(strict_types=1);
+
+namespace Chill\CalendarBundle\Messenger\Handler;
+
+use Chill\CalendarBundle\Messenger\Message\CalendarRangeRemovedMessage;
+use Chill\CalendarBundle\RemoteCalendar\Connector\RemoteCalendarConnectorInterface;
+use Chill\MainBundle\Repository\UserRepository;
+use Symfony\Component\Messenger\Attribute\AsMessageHandler;
+use Symfony\Component\Messenger\Handler\MessageHandlerInterface;
+
+/**
+ * @AsMessageHandler
+ */
+class CalendarRangeRemoveToRemoteHandler implements MessageHandlerInterface
+{
+    private RemoteCalendarConnectorInterface $remoteCalendarConnector;
+
+    private UserRepository $userRepository;
+
+    public function __construct(RemoteCalendarConnectorInterface $remoteCalendarConnector, UserRepository $userRepository)
+    {
+        $this->remoteCalendarConnector = $remoteCalendarConnector;
+        $this->userRepository = $userRepository;
+    }
+
+    public function __invoke(CalendarRangeRemovedMessage $calendarRangeRemovedMessage)
+    {
+        $this->remoteCalendarConnector->removeCalendarRange(
+            $calendarRangeRemovedMessage->getRemoteId(),
+            $calendarRangeRemovedMessage->getRemoteAttributes(),
+            $this->userRepository->find($calendarRangeRemovedMessage->getCalendarRangeUserId())
+        );
+    }
+}

src/Bundle/ChillCalendarBundle/Messenger/Handler/CalendarRangeToRemoteHandler.php

@@ -0,0 +1,51 @@
+<?php
+
+/**
+ * Chill is a software for social workers
+ *
+ * For the full copyright and license information, please view
+ * the LICENSE file that was distributed with this source code.
+ */
+
+declare(strict_types=1);
+
+namespace Chill\CalendarBundle\Messenger\Handler;
+
+use Chill\CalendarBundle\Messenger\Message\CalendarRangeMessage;
+use Chill\CalendarBundle\RemoteCalendar\Connector\RemoteCalendarConnectorInterface;
+use Chill\CalendarBundle\Repository\CalendarRangeRepository;
+use Doctrine\ORM\EntityManagerInterface;
+use Symfony\Component\Messenger\Attribute\AsMessageHandler;
+use Symfony\Component\Messenger\Handler\MessageHandlerInterface;
+
+/**
+ * @AsMessageHandler
+ */
+class CalendarRangeToRemoteHandler implements MessageHandlerInterface
+{
+    private CalendarRangeRepository $calendarRangeRepository;
+
+    private EntityManagerInterface $entityManager;
+
+    private RemoteCalendarConnectorInterface $remoteCalendarConnector;
+
+    public function __construct(
+        CalendarRangeRepository $calendarRangeRepository,
+        RemoteCalendarConnectorInterface $remoteCalendarConnector,
+        EntityManagerInterface $entityManager
+    ) {
+        $this->calendarRangeRepository = $calendarRangeRepository;
+        $this->remoteCalendarConnector = $remoteCalendarConnector;
+        $this->entityManager = $entityManager;
+    }
+
+    public function __invoke(CalendarRangeMessage $calendarRangeMessage): void
+    {
+        $range = $this->calendarRangeRepository->find($calendarRangeMessage->getCalendarRangeId());
+
+        $this->remoteCalendarConnector->syncCalendarRange($range);
+        $range->preventEnqueueChanges = true;
+
+        $this->entityManager->flush();
+    }
+}

src/Bundle/ChillCalendarBundle/Messenger/Handler/CalendarToRemoteHandler.php

@@ -0,0 +1,106 @@
+<?php
+
+/**
+ * Chill is a software for social workers
+ *
+ * For the full copyright and license information, please view
+ * the LICENSE file that was distributed with this source code.
+ */
+
+declare(strict_types=1);
+
+namespace Chill\CalendarBundle\Messenger\Handler;
+
+use Chill\CalendarBundle\Entity\CalendarRange;
+use Chill\CalendarBundle\Entity\Invite;
+use Chill\CalendarBundle\Messenger\Message\CalendarMessage;
+use Chill\CalendarBundle\RemoteCalendar\Connector\RemoteCalendarConnectorInterface;
+use Chill\CalendarBundle\Repository\CalendarRangeRepository;
+use Chill\CalendarBundle\Repository\CalendarRepository;
+use Chill\CalendarBundle\Repository\InviteRepository;
+use Chill\MainBundle\Repository\UserRepository;
+use Doctrine\ORM\EntityManagerInterface;
+use Symfony\Component\Messenger\Attribute\AsMessageHandler;
+use Symfony\Component\Messenger\Handler\MessageHandlerInterface;
+
+/**
+ * @AsMessageHandler
+ */
+class CalendarToRemoteHandler implements MessageHandlerInterface
+{
+    private RemoteCalendarConnectorInterface $calendarConnector;
+
+    private CalendarRangeRepository $calendarRangeRepository;
+
+    private CalendarRepository $calendarRepository;
+
+    private EntityManagerInterface $entityManager;
+
+    private InviteRepository $inviteRepository;
+
+    private UserRepository $userRepository;
+
+    public function __construct(
+        CalendarRangeRepository $calendarRangeRepository,
+        CalendarRepository $calendarRepository,
+        EntityManagerInterface $entityManager,
+        InviteRepository $inviteRepository,
+        RemoteCalendarConnectorInterface $calendarConnector,
+        UserRepository $userRepository
+    ) {
+        $this->calendarConnector = $calendarConnector;
+        $this->calendarRepository = $calendarRepository;
+        $this->calendarRangeRepository = $calendarRangeRepository;
+        $this->entityManager = $entityManager;
+        $this->userRepository = $userRepository;
+        $this->inviteRepository = $inviteRepository;
+    }
+
+    public function __invoke(CalendarMessage $calendarMessage)
+    {
+        $calendar = $this->calendarRepository->find($calendarMessage->getCalendarId());
+
+        if (null !== $calendarMessage->getPreviousCalendarRangeId()) {
+            $previousCalendarRange = $this->calendarRangeRepository
+                ->find($calendarMessage->getPreviousCalendarRangeId());
+        } else {
+            $previousCalendarRange = null;
+        }
+
+        if (null !== $calendarMessage->getPreviousMainUserId()) {
+            $previousMainUser = $this->userRepository
+                ->find($calendarMessage->getPreviousMainUserId());
+        } else {
+            $previousMainUser = null;
+        }
+
+        $newInvites = array_filter(
+            array_map(
+                function ($id) { return $this->inviteRepository->find($id); },
+                $calendarMessage->getNewInvitesIds(),
+            ),
+            static function (?Invite $invite) { return null !== $invite; }
+        );
+
+        $this->calendarConnector->syncCalendar(
+            $calendar,
+            $calendarMessage->getAction(),
+            $previousCalendarRange,
+            $previousMainUser,
+            $calendarMessage->getOldInvites(),
+            $newInvites
+        );
+
+        $calendar->preventEnqueueChanges = true;
+
+        if ($calendar->hasCalendarRange()) {
+            $calendar->getCalendarRange()->preventEnqueueChanges = true;
+        }
+
+        if ($previousCalendarRange instanceof CalendarRange) {
+            $previousCalendarRange->preventEnqueueChanges = true;
+        }
+
+        $this->entityManager->flush();
+    }
+}

src/Bundle/ChillCalendarBundle/Messenger/Handler/InviteUpdateHandler.php

@@ -0,0 +1,48 @@
+<?php
+
+/**
+ * Chill is a software for social workers
+ *
+ * For the full copyright and license information, please view
+ * the LICENSE file that was distributed with this source code.
+ */
+
+declare(strict_types=1);
+
+namespace Chill\CalendarBundle\Messenger\Handler;
+
+use Chill\CalendarBundle\Messenger\Message\InviteUpdateMessage;
+use Chill\CalendarBundle\RemoteCalendar\Connector\RemoteCalendarConnectorInterface;
+use Chill\CalendarBundle\Repository\InviteRepository;
+use Doctrine\ORM\EntityManagerInterface;
+use Symfony\Component\Messenger\Handler\MessageHandlerInterface;
+
+/**
+ * @AsMessageHandler
+ */
+class InviteUpdateHandler implements MessageHandlerInterface
+{
+    private EntityManagerInterface $em;
+
+    private InviteRepository $inviteRepository;
+
+    private RemoteCalendarConnectorInterface $remoteCalendarConnector;
+
+    public function __construct(EntityManagerInterface $em, InviteRepository $inviteRepository, RemoteCalendarConnectorInterface $remoteCalendarConnector)
+    {
+        $this->em = $em;
+        $this->inviteRepository = $inviteRepository;
+        $this->remoteCalendarConnector = $remoteCalendarConnector;
+    }
+
+    public function __invoke(InviteUpdateMessage $inviteUpdateMessage): void
+    {
+        if (null === $invite = $this->inviteRepository->find($inviteUpdateMessage->getInviteId())) {
+            return;
+        }
+
+        $this->remoteCalendarConnector->syncInvite($invite);
+
+        $this->em->flush();
+    }
+}

src/Bundle/ChillCalendarBundle/Messenger/Handler/MSGraphChangeNotificationHandler.php

@@ -0,0 +1,103 @@
+<?php
+
+/**
+ * Chill is a software for social workers
+ *
+ * For the full copyright and license information, please view
+ * the LICENSE file that was distributed with this source code.
+ */
+
+declare(strict_types=1);
+
+namespace Chill\CalendarBundle\Messenger\Handler;
+
+use Chill\CalendarBundle\Messenger\Message\MSGraphChangeNotificationMessage;
+use Chill\CalendarBundle\RemoteCalendar\Connector\MSGraph\MapCalendarToUser;
+use Chill\CalendarBundle\RemoteCalendar\Connector\MSGraph\RemoteToLocalSync\CalendarRangeSyncer;
+use Chill\CalendarBundle\RemoteCalendar\Connector\MSGraph\RemoteToLocalSync\CalendarSyncer;
+use Chill\CalendarBundle\Repository\CalendarRangeRepository;
+use Chill\CalendarBundle\Repository\CalendarRepository;
+use Chill\MainBundle\Repository\UserRepository;
+use Doctrine\ORM\EntityManagerInterface;
+use Psr\Log\LoggerInterface;
+use Symfony\Component\Messenger\Handler\MessageHandlerInterface;
+
+/**
+ * Handle notification of chagnes from MSGraph.
+ *
+ * @AsMessageHandler
+ */
+class MSGraphChangeNotificationHandler implements MessageHandlerInterface
+{
+    private CalendarRangeRepository $calendarRangeRepository;
+
+    private CalendarRangeSyncer $calendarRangeSyncer;
+
+    private CalendarRepository $calendarRepository;
+
+    private CalendarSyncer $calendarSyncer;
+
+    private EntityManagerInterface $em;
+
+    private LoggerInterface $logger;
+
+    private MapCalendarToUser $mapCalendarToUser;
+
+    private UserRepository $userRepository;
+
+    public function __construct(
+        CalendarRangeRepository $calendarRangeRepository,
+        CalendarRangeSyncer $calendarRangeSyncer,
+        CalendarRepository $calendarRepository,
+        CalendarSyncer $calendarSyncer,
+        EntityManagerInterface $em,
+        LoggerInterface $logger,
+        MapCalendarToUser $mapCalendarToUser,
+        UserRepository $userRepository
+    ) {
+        $this->calendarRangeRepository = $calendarRangeRepository;
+        $this->calendarRangeSyncer = $calendarRangeSyncer;
+        $this->calendarRepository = $calendarRepository;
+        $this->calendarSyncer = $calendarSyncer;
+        $this->em = $em;
+        $this->logger = $logger;
+        $this->mapCalendarToUser = $mapCalendarToUser;
+        $this->userRepository = $userRepository;
+    }
+
+    public function __invoke(MSGraphChangeNotificationMessage $changeNotificationMessage): void
+    {
+        $user = $this->userRepository->find($changeNotificationMessage->getUserId());
+
+        if (null === $user) {
+            $this->logger->warning(__CLASS__ . ' notification concern non-existent user, skipping');
+
+            return;
+        }
+
+        foreach ($changeNotificationMessage->getContent()['value'] as $notification) {
+            $secret = $this->mapCalendarToUser->getSubscriptionSecret($user);
+
+            if ($secret !== ($notification['clientState'] ?? -1)) {
+                $this->logger->warning(__CLASS__ . ' could not validate secret, skipping');
+
+                continue;
+            }
+
+            $remoteId = $notification['resourceData']['id'];
+
+            // is this a calendar range ?
+            if (null !== $calendarRange = $this->calendarRangeRepository->findOneBy(['remoteId' => $remoteId])) {
+                $this->calendarRangeSyncer->handleCalendarRangeSync($calendarRange, $notification, $user);
+                $this->em->flush();
+            } elseif (null !== $calendar = $this->calendarRepository->findOneBy(['remoteId' => $remoteId])) {
+                $this->calendarSyncer->handleCalendarSync($calendar, $notification, $user);
+                $this->em->flush();
+            } else {
+                $this->logger->info(__CLASS__ . ' id not found in any calendar nor calendar range');
+            }
+        }
+
+        $this->em->flush();
+    }
+}

src/Bundle/ChillCalendarBundle/Messenger/Message/CalendarMessage.php

@@ -0,0 +1,104 @@
+<?php
+
+/**
+ * Chill is a software for social workers
+ *
+ * For the full copyright and license information, please view
+ * the LICENSE file that was distributed with this source code.
+ */
+
+declare(strict_types=1);
+
+namespace Chill\CalendarBundle\Messenger\Message;
+
+use Chill\CalendarBundle\Entity\Calendar;
+use Chill\CalendarBundle\Entity\Invite;
+use Chill\MainBundle\Entity\User;
+
+class CalendarMessage
+{
+    public const CALENDAR_PERSIST = 'CHILL_CALENDAR_CALENDAR_PERSIST';
+
+    public const CALENDAR_UPDATE = 'CHILL_CALENDAR_CALENDAR_UPDATE';
+
+    private string $action;
+
+    private int $byUserId;
+
+    private int $calendarId;
+
+    private array $newInvitesIds = [];
+
+    /**
+     * @var array<array{inviteId: int, userId: int, userEmail: int, userLabel: string}>
+     */
+    private array $oldInvites = [];
+
+    private ?int $previousCalendarRangeId = null;
+
+    private ?int $previousMainUserId = null;
+
+    public function __construct(
+        Calendar $calendar,
+        string $action,
+        User $byUser
+    ) {
+        $this->calendarId = $calendar->getId();
+        $this->byUserId = $byUser->getId();
+        $this->action = $action;
+        $this->previousCalendarRangeId = null !== $calendar->previousCalendarRange ?
+            $calendar->previousCalendarRange->getId() : null;
+        $this->previousMainUserId = null !== $calendar->previousMainUser ?
+            $calendar->previousMainUser->getId() : null;
+        $this->newInvitesIds = array_map(static fn (Invite $i) => $i->getId(), $calendar->newInvites);
+        $this->oldInvites = array_map(static function (Invite $i) {
+            return [
+                'inviteId' => $i->getId(),
+                'userId' => $i->getUser()->getId(),
+                'userEmail' => $i->getUser()->getEmail(),
+                'userLabel' => $i->getUser()->getLabel(),
+            ];
+        }, $calendar->oldInvites);
+    }
+
+    public function getAction(): string
+    {
+        return $this->action;
+    }
+
+    public function getByUserId(): ?int
+    {
+        return $this->byUserId;
+    }
+
+    public function getCalendarId(): ?int
+    {
+        return $this->calendarId;
+    }
+
+    /**
+     * @return array|int[]|null[]
+     */
+    public function getNewInvitesIds(): array
+    {
+        return $this->newInvitesIds;
+    }
+
+    /**
+     * @return array<array{inviteId: int, userId: int, userEmail: int, userLabel: string}>
+     */
+    public function getOldInvites(): array
+    {
+        return $this->oldInvites;
+    }
+
+    public function getPreviousCalendarRangeId(): ?int
+    {
+        return $this->previousCalendarRangeId;
+    }
+
+    public function getPreviousMainUserId(): ?int
+    {
+        return $this->previousMainUserId;
+    }
+}

src/Bundle/ChillCalendarBundle/Messenger/Message/CalendarRangeMessage.php

@@ -0,0 +1,53 @@
+<?php
+
+/**
+ * Chill is a software for social workers
+ *
+ * For the full copyright and license information, please view
+ * the LICENSE file that was distributed with this source code.
+ */
+
+declare(strict_types=1);
+
+namespace Chill\CalendarBundle\Messenger\Message;
+
+use Chill\CalendarBundle\Entity\CalendarRange;
+use Chill\MainBundle\Entity\User;
+
+class CalendarRangeMessage
+{
+    public const CALENDAR_RANGE_PERSIST = 'CHILL_CALENDAR_CALENDAR_RANGE_PERSIST';
+
+    public const CALENDAR_RANGE_UPDATE = 'CHILL_CALENDAR_CALENDAR_RANGE_UPDATE';
+
+    private string $action;
+
+    private ?int $byUserId = null;
+
+    private int $calendarRangeId;
+
+    public function __construct(CalendarRange $calendarRange, string $action, ?User $byUser)
+    {
+        $this->action = $action;
+        $this->calendarRangeId = $calendarRange->getId();
+
+        if (null !== $byUser) {
+            $this->byUserId = $byUser->getId();
+        }
+    }
+
+    public function getAction(): string
+    {
+        return $this->action;
+    }
+
+    public function getByUserId(): ?int
+    {
+        return $this->byUserId;
+    }
+
+    public function getCalendarRangeId(): ?int
+    {
+        return $this->calendarRangeId;
+    }
+}

src/Bundle/ChillCalendarBundle/Messenger/Message/CalendarRangeRemovedMessage.php

@@ -0,0 +1,57 @@
+<?php
+
+/**
+ * Chill is a software for social workers
+ *
+ * For the full copyright and license information, please view
+ * the LICENSE file that was distributed with this source code.
+ */
+
+declare(strict_types=1);
+
+namespace Chill\CalendarBundle\Messenger\Message;
+
+use Chill\CalendarBundle\Entity\CalendarRange;
+use Chill\MainBundle\Entity\User;
+
+class CalendarRangeRemovedMessage
+{
+    private ?int $byUserId = null;
+
+    private int $calendarRangeUserId;
+
+    private array $remoteAttributes;
+
+    private string $remoteId;
+
+    public function __construct(CalendarRange $calendarRange, ?User $byUser)
+    {
+        $this->remoteId = $calendarRange->getRemoteId();
+        $this->remoteAttributes = $calendarRange->getRemoteAttributes();
+        $this->calendarRangeUserId = $calendarRange->getUser()->getId();
+
+        if (null !== $byUser) {
+            $this->byUserId = $byUser->getId();
+        }
+    }
+
+    public function getByUserId(): ?int
+    {
+        return $this->byUserId;
+    }
+
+    public function getCalendarRangeUserId(): ?int
+    {
+        return $this->calendarRangeUserId;
+    }
+
+    public function getRemoteAttributes(): array
+    {
+        return $this->remoteAttributes;
+    }
+
+    public function getRemoteId(): string
+    {
+        return $this->remoteId;
+    }
+}

src/Bundle/ChillCalendarBundle/Messenger/Message/InviteUpdateMessage.php

@@ -0,0 +1,38 @@
+<?php
+
+/**
+ * Chill is a software for social workers
+ *
+ * For the full copyright and license information, please view
+ * the LICENSE file that was distributed with this source code.
+ */
+
+declare(strict_types=1);
+
+namespace Chill\CalendarBundle\Messenger\Message;
+
+use Chill\CalendarBundle\Entity\Invite;
+use Chill\MainBundle\Entity\User;
+
+class InviteUpdateMessage
+{
+    private int $byUserId;
+
+    private int $inviteId;
+
+    public function __construct(Invite $invite, User $byUser)
+    {
+        $this->inviteId = $invite->getId();
+        $this->byUserId = $byUser->getId();
+    }
+
+    public function getByUserId(): int
+    {
+        return $this->byUserId;
+    }
+
+    public function getInviteId(): int
+    {
+        return $this->inviteId;
+    }
+}

src/Bundle/ChillCalendarBundle/Messenger/Message/MSGraphChangeNotificationMessage.php

@@ -0,0 +1,35 @@
+<?php
+
+/**
+ * Chill is a software for social workers
+ *
+ * For the full copyright and license information, please view
+ * the LICENSE file that was distributed with this source code.
+ */
+
+declare(strict_types=1);
+
+namespace Chill\CalendarBundle\Messenger\Message;
+
+class MSGraphChangeNotificationMessage
+{
+    private array $content;
+
+    private int $userId;
+
+    public function __construct(array $content, int $userId)
+    {
+        $this->content = $content;
+        $this->userId = $userId;
+    }
+
+    public function getContent(): array
+    {
+        return $this->content;
+    }
+
+    public function getUserId(): int
+    {
+        return $this->userId;
+    }
+}

src/Bundle/ChillCalendarBundle/RemoteCalendar/Connector/MSGraph/EventsOnUserSubscriptionCreator.php

@@ -0,0 +1,133 @@
+<?php
+
+/**
+ * Chill is a software for social workers
+ *
+ * For the full copyright and license information, please view
+ * the LICENSE file that was distributed with this source code.
+ */
+
+declare(strict_types=1);
+
+namespace Chill\CalendarBundle\RemoteCalendar\Connector\MSGraph;
+
+use Chill\MainBundle\Entity\User;
+use DateTimeImmutable;
+use LogicException;
+use Psr\Log\LoggerInterface;
+use Symfony\Component\Routing\Generator\UrlGeneratorInterface;
+use Symfony\Contracts\HttpClient\Exception\ClientExceptionInterface;
+
+/**
+ * Create a subscription for a user.
+ */
+class EventsOnUserSubscriptionCreator
+{
+    private LoggerInterface $logger;
+
+    private MachineHttpClient $machineHttpClient;
+
+    private MapCalendarToUser $mapCalendarToUser;
+
+    private UrlGeneratorInterface $urlGenerator;
+
+    public function __construct(
+        LoggerInterface $logger,
+        MachineHttpClient $machineHttpClient,
+        MapCalendarToUser $mapCalendarToUser,
+        UrlGeneratorInterface $urlGenerator
+    ) {
+        $this->logger = $logger;
+        $this->machineHttpClient = $machineHttpClient;
+        $this->mapCalendarToUser = $mapCalendarToUser;
+        $this->urlGenerator = $urlGenerator;
+    }
+
+    /**
+     * @throws ClientExceptionInterface
+     * @throws \Symfony\Contracts\HttpClient\Exception\DecodingExceptionInterface
+     * @throws \Symfony\Contracts\HttpClient\Exception\RedirectionExceptionInterface
+     * @throws \Symfony\Contracts\HttpClient\Exception\ServerExceptionInterface
+     * @throws \Symfony\Contracts\HttpClient\Exception\TransportExceptionInterface
+     *
+     * @return array<secret: string, id: string, expiration: int>
+     */
+    public function createSubscriptionForUser(User $user, DateTimeImmutable $expiration): array
+    {
+        if (null === $userId = $this->mapCalendarToUser->getUserId($user)) {
+            throw new LogicException('no user id');
+        }
+
+        $subscription = [
+            'changeType' => 'deleted,updated',
+            'notificationUrl' => $this->urlGenerator->generate(
+                'chill_calendar_remote_msgraph_incoming_webhook_events',
+                ['userId' => $user->getId()],
+                UrlGeneratorInterface::ABSOLUTE_URL
+            ),
+            'resource' => "/users/{$userId}/calendar/events",
+            'clientState' => $secret = base64_encode(openssl_random_pseudo_bytes(92, $cstrong)),
+            'expirationDateTime' => $expiration->format(DateTimeImmutable::ATOM),
+        ];
+
+        try {
+            $subs = $this->machineHttpClient->request(
+                'POST',
+                '/v1.0/subscriptions',
+                [
+                    'json' => $subscription,
+                ]
+            )->toArray();
+        } catch (ClientExceptionInterface $e) {
+            $this->logger->error('could not create subscription for user events', [
+                'body' => $e->getResponse()->getContent(false),
+            ]);
+
+            return ['secret' => '', 'id' => '', 'expiration' => 0];
+        }
+
+        return ['secret' => $secret, 'id' => $subs['id'], 'expiration' => $expiration->getTimestamp()];
+    }
+
+    /**
+     * @throws ClientExceptionInterface
+     * @throws \Symfony\Contracts\HttpClient\Exception\DecodingExceptionInterface
+     * @throws \Symfony\Contracts\HttpClient\Exception\RedirectionExceptionInterface
+     * @throws \Symfony\Contracts\HttpClient\Exception\ServerExceptionInterface
+     * @throws \Symfony\Contracts\HttpClient\Exception\TransportExceptionInterface
+     *
+     * @return array<secret: string, id: string, expiration: int>
+     */
+    public function renewSubscriptionForUser(User $user, DateTimeImmutable $expiration): array
+    {
+        if (null === $userId = $this->mapCalendarToUser->getUserId($user)) {
+            throw new LogicException('no user id');
+        }
+
+        if (null === $subscriptionId = $this->mapCalendarToUser->getActiveSubscriptionId($user)) {
+            throw new LogicException('no user id');
+        }
+
+        $subscription = [
+            'expirationDateTime' => $expiration->format(DateTimeImmutable::ATOM),
+        ];
+
+        try {
+            $subs = $this->machineHttpClient->request(
+                'PATCH',
+                "/v1.0/subscriptions/{$subscriptionId}",
+                [
+                    'json' => $subscription,
+                ]
+            )->toArray();
+        } catch (ClientExceptionInterface $e) {
+            $this->logger->error('could not patch subscription for user events', [
+                'body' => $e->getResponse()->getContent(false),
+            ]);
+
+            return ['secret' => '', 'id' => '', 'expiration' => 0];
+        }
+
+        return ['secret' => $subs['clientState'], 'id' => $subs['id'], 'expiration' => $expiration->getTimestamp()];
+    }
+}

src/Bundle/ChillCalendarBundle/RemoteCalendar/Connector/MSGraph/MSGraphUserRepository.php

@@ -0,0 +1,77 @@
+<?php
+
+/**
+ * Chill is a software for social workers
+ *
+ * For the full copyright and license information, please view
+ * the LICENSE file that was distributed with this source code.
+ */
+
+declare(strict_types=1);
+
+namespace Chill\CalendarBundle\RemoteCalendar\Connector\MSGraph;
+
+use Chill\MainBundle\Entity\User;
+use DateInterval;
+use Doctrine\ORM\EntityManagerInterface;
+use Doctrine\ORM\Query\ResultSetMapping;
+use Doctrine\ORM\Query\ResultSetMappingBuilder;
+use function strtr;
+
+/**
+ * Contains classes and methods for fetching users with some calendar metadatas.
+ */
+class MSGraphUserRepository
+{
+    private const MOST_OLD_SUBSCRIPTION_OR_ANY_MS_GRAPH = <<<'SQL'
+        select
+            {select}
+        from users u
+        where
+            NOT attributes ?? 'msgraph'
+            OR NOT attributes->'msgraph' ?? 'subscription_events_expiration'
+            OR (attributes->'msgraph' ?? 'subscription_events_expiration' AND (attributes->'msgraph'->>'subscription_events_expiration')::int < EXTRACT(EPOCH FROM (NOW() + :interval::interval)))
+        LIMIT :limit OFFSET :offset
+        ;
+        SQL;
+
+    private EntityManagerInterface $entityManager;
+
+    public function __construct(EntityManagerInterface $entityManager)
+    {
+        $this->entityManager = $entityManager;
+    }
+
+    public function countByMostOldSubscriptionOrWithoutSubscriptionOrData(DateInterval $interval): int
+    {
+        $rsm = new ResultSetMapping();
+        $rsm->addScalarResult('c', 'c');
+
+        $sql = strtr(self::MOST_OLD_SUBSCRIPTION_OR_ANY_MS_GRAPH, [
+            '{select}' => 'COUNT(u) AS c',
+            'LIMIT :limit OFFSET :offset' => '',
+        ]);
+
+        return $this->entityManager->createNativeQuery($sql, $rsm)->setParameters([
+            'interval' => $interval,
+        ])->getSingleScalarResult();
+    }
+
+    /**
+     * @return array|User[]
+     */
+    public function findByMostOldSubscriptionOrWithoutSubscriptionOrData(DateInterval $interval, int $limit = 50, int $offset = 0): array
+    {
+        $rsm = new ResultSetMappingBuilder($this->entityManager);
+        $rsm->addRootEntityFromClassMetadata(User::class, 'u');
+
+        return $this->entityManager->createNativeQuery(
+            strtr(self::MOST_OLD_SUBSCRIPTION_OR_ANY_MS_GRAPH, ['{select}' => $rsm->generateSelectClause()]),
+            $rsm
+        )->setParameters([
+            'interval' => $interval,
+            'limit' => $limit,
+            'offset' => $offset,
+        ])->getResult();
+    }
+}

src/Bundle/ChillCalendarBundle/RemoteCalendar/Connector/MSGraph/MachineHttpClient.php

@@ -0,0 +1,75 @@
+<?php
+
+/**
+ * Chill is a software for social workers
+ *
+ * For the full copyright and license information, please view
+ * the LICENSE file that was distributed with this source code.
+ */
+
+declare(strict_types=1);
+
+namespace Chill\CalendarBundle\RemoteCalendar\Connector\MSGraph;
+
+use League\OAuth2\Client\Tool\BearerAuthorizationTrait;
+use LogicException;
+use Symfony\Contracts\HttpClient\HttpClientInterface;
+use Symfony\Contracts\HttpClient\ResponseInterface;
+use Symfony\Contracts\HttpClient\ResponseStreamInterface;
+
+class MachineHttpClient implements HttpClientInterface
+{
+    use BearerAuthorizationTrait;
+
+    private HttpClientInterface $decoratedClient;
+
+    private MachineTokenStorage $machineTokenStorage;
+
+    /**
+     * @param HttpClientInterface $decoratedClient
+     */
+    public function __construct(MachineTokenStorage $machineTokenStorage, ?HttpClientInterface $decoratedClient = null)
+    {
+        $this->decoratedClient = $decoratedClient ?? \Symfony\Component\HttpClient\HttpClient::create();
+        $this->machineTokenStorage = $machineTokenStorage;
+    }
+
+    /**
+     * @throws \Symfony\Contracts\HttpClient\Exception\TransportExceptionInterface
+     * @throws LogicException if method is not supported
+     */
+    public function request(string $method, string $url, array $options = []): ResponseInterface
+    {
+        $options['headers'] = array_merge(
+            $options['headers'] ?? [],
+            $this->getAuthorizationHeaders($this->machineTokenStorage->getToken())
+        );
+        $options['base_uri'] = 'https://graph.microsoft.com/v1.0/';
+
+        switch ($method) {
+            case 'GET':
+            case 'HEAD':
+            case 'DELETE':
+                $options['headers']['Accept'] = 'application/json';
+
+                break;
+
+            case 'POST':
+            case 'PUT':
+            case 'PATCH':
+                $options['headers']['Content-Type'] = 'application/json';
+
+                break;
+
+            default:
+                throw new LogicException("Method not supported: {$method}");
+        }
+
+        return $this->decoratedClient->request($method, $url, $options);
+    }
+
+    public function stream($responses, ?float $timeout = null): ResponseStreamInterface
+    {
+        return $this->decoratedClient->stream($responses, $timeout);
+    }
+}

src/Bundle/ChillCalendarBundle/RemoteCalendar/Connector/MSGraph/MachineTokenStorage.php

@@ -0,0 +1,50 @@
+<?php
+
+/**
+ * Chill is a software for social workers
+ *
+ * For the full copyright and license information, please view
+ * the LICENSE file that was distributed with this source code.
+ */
+
+declare(strict_types=1);
+
+namespace Chill\CalendarBundle\RemoteCalendar\Connector\MSGraph;
+
+use Chill\MainBundle\Redis\ChillRedis;
+use League\OAuth2\Client\Token\AccessTokenInterface;
+use TheNetworg\OAuth2\Client\Provider\Azure;
+use TheNetworg\OAuth2\Client\Token\AccessToken;
+
+class MachineTokenStorage
+{
+    private const KEY = 'msgraph_access_token';
+
+    private ?AccessTokenInterface $accessToken = null;
+
+    private Azure $azure;
+
+    private ChillRedis $chillRedis;
+
+    public function __construct(Azure $azure, ChillRedis $chillRedis)
+    {
+        $this->azure = $azure;
+        $this->chillRedis = $chillRedis;
+    }
+
+    public function getToken(): AccessTokenInterface
+    {
+        if (null === $this->accessToken || $this->accessToken->hasExpired()) {
+            $this->accessToken = $this->azure->getAccessToken('client_credentials', [
+                'scope' => 'https://graph.microsoft.com/.default',
+            ]);
+        }
+
+        return $this->accessToken;
+    }
+
+    public function storeToken(AccessToken $token): void
+    {
+        $this->chillRedis->set(self::KEY, serialize($token));
+    }
+}

src/Bundle/ChillCalendarBundle/RemoteCalendar/Connector/MSGraph/MapCalendarToUser.php

@@ -0,0 +1,184 @@
+<?php
+
+/**
+ * Chill is a software for social workers
+ *
+ * For the full copyright and license information, please view
+ * the LICENSE file that was distributed with this source code.
+ */
+
+declare(strict_types=1);
+
+namespace Chill\CalendarBundle\RemoteCalendar\Connector\MSGraph;
+
+use Chill\MainBundle\Entity\User;
+use DateTimeImmutable;
+use LogicException;
+use Psr\Log\LoggerInterface;
+use function array_key_exists;
+
+/**
+ * Write metadata to user, which allow to find his default calendar.
+ */
+class MapCalendarToUser
+{
+    public const EXPIRATION_SUBSCRIPTION_EVENT = 'subscription_events_expiration';
+
+    public const ID_SUBSCRIPTION_EVENT = 'subscription_events_id';
+
+    public const METADATA_KEY = 'msgraph';
+
+    public const SECRET_SUBSCRIPTION_EVENT = 'subscription_events_secret';
+
+    private LoggerInterface $logger;
+
+    private MachineHttpClient $machineHttpClient;
+
+    public function __construct(
+        MachineHttpClient $machineHttpClient,
+        LoggerInterface $logger
+    ) {
+        $this->machineHttpClient = $machineHttpClient;
+        $this->logger = $logger;
+    }
+
+    public function getActiveSubscriptionId(User $user): string
+    {
+        if (!array_key_exists(self::METADATA_KEY, $user->getAttributes())) {
+            throw new LogicException('do not contains msgraph metadata');
+        }
+
+        if (!array_key_exists(self::ID_SUBSCRIPTION_EVENT, $user->getAttributes()[self::METADATA_KEY])) {
+            throw new LogicException('do not contains metadata for subscription id');
+        }
+
+        return $user->getAttributes()[self::METADATA_KEY][self::ID_SUBSCRIPTION_EVENT];
+    }
+
+    public function getCalendarId(User $user): ?string
+    {
+        if (null === $msKey = ($user->getAttributes()[self::METADATA_KEY] ?? null)) {
+            return null;
+        }
+
+        return $msKey['defaultCalendarId'] ?? null;
+    }
+
+    public function getDefaultUserCalendar(string $idOrUserPrincipalName): ?array
+    {
+        $value = $this->machineHttpClient->request('GET', "users/{$idOrUserPrincipalName}/calendars", [
+            'query' => ['$filter' => 'isDefaultCalendar eq true'],
+        ])->toArray()['value'];
+
+        return $value[0] ?? null;
+    }
+
+    public function getSubscriptionSecret(User $user): string
+    {
+        if (!array_key_exists(self::METADATA_KEY, $user->getAttributes())) {
+            throw new LogicException('do not contains msgraph metadata');
+        }
+
+        if (!array_key_exists(self::SECRET_SUBSCRIPTION_EVENT, $user->getAttributes()[self::METADATA_KEY])) {
+            throw new LogicException('do not contains secret in msgraph');
+        }
+
+        return $user->getAttributes()[self::METADATA_KEY][self::SECRET_SUBSCRIPTION_EVENT];
+    }
+
+    public function getUserByEmail(string $email): ?array
+    {
+        $value = $this->machineHttpClient->request('GET', 'users', [
+            'query' => ['$filter' => "mail eq '{$email}'"],
+        ])->toArray()['value'];
+
+        return $value[0] ?? null;
+    }
+
+    public function getUserId(User $user): ?string
+    {
+        if (null === $msKey = ($user->getAttributes()[self::METADATA_KEY] ?? null)) {
+            return null;
+        }
+
+        return $msKey['id'] ?? null;
+    }
+
+    public function hasActiveSubscription(User $user): bool
+    {
+        if (!array_key_exists(self::METADATA_KEY, $user->getAttributes())) {
+            return false;
+        }
+
+        if (!array_key_exists(self::EXPIRATION_SUBSCRIPTION_EVENT, $user->getAttributes()[self::METADATA_KEY])) {
+            return false;
+        }
+
+        return $user->getAttributes()[self::METADATA_KEY][self::EXPIRATION_SUBSCRIPTION_EVENT]
+            >= (new DateTimeImmutable('now'))->getTimestamp();
+    }
+
+    public function hasSubscriptionSecret(User $user): bool
+    {
+        if (!array_key_exists(self::METADATA_KEY, $user->getAttributes())) {
+            return false;
+        }
+
+        return array_key_exists(self::SECRET_SUBSCRIPTION_EVENT, $user->getAttributes()[self::METADATA_KEY]);
+    }
+
+    public function hasUserId(User $user): bool
+    {
+        if (!array_key_exists(self::METADATA_KEY, $user->getAttributes())) {
+            return false;
+        }
+
+        return array_key_exists('id', $user->getAttributes()[self::METADATA_KEY]);
+    }
+
+    public function writeMetadata(User $user): User
+    {
+        if (null === $userData = $this->getUserByEmail($user->getEmailCanonical())) {
+            $this->logger->warning('[MapCalendarToUser] could not find user on msgraph', ['userId' => $user->getId(), 'email' => $user->getEmailCanonical()]);
+
+            return $this->writeNullData($user);
+        }
+
+        if (null === $defaultCalendar = $this->getDefaultUserCalendar($userData['id'])) {
+            $this->logger->warning('[MapCalendarToUser] could not find default calendar', ['userId' => $user->getId(), 'email' => $user->getEmailCanonical()]);
+
+            return $this->writeNullData($user);
+        }
+
+        return $user->setAttributes([self::METADATA_KEY => [
+            'id' => $userData['id'],
+            'userPrincipalName' => $userData['userPrincipalName'],
+            'defaultCalendarId' => $defaultCalendar['id'],
+        ]]);
+    }
+
+    /**
+     * @param int $expiration the expiration time as unix timestamp
+     */
+    public function writeSubscriptionMetadata(
+        User $user,
+        int $expiration,
+        ?string $id = null,
+        ?string $secret = null
+    ): void {
+        $user->setAttributeByDomain(self::METADATA_KEY, self::EXPIRATION_SUBSCRIPTION_EVENT, $expiration);
+
+        if (null !== $id) {
+            $user->setAttributeByDomain(self::METADATA_KEY, self::ID_SUBSCRIPTION_EVENT, $id);
+        }
+
+        if (null !== $secret) {
+            $user->setAttributeByDomain(self::METADATA_KEY, self::SECRET_SUBSCRIPTION_EVENT, $secret);
+        }
+    }
+
+    private function writeNullData(User $user): User
+    {
+        return $user->unsetAttribute(self::METADATA_KEY);
+    }
+}

src/Bundle/ChillCalendarBundle/RemoteCalendar/Connector/MSGraph/OnBehalfOfUserHttpClient.php

@@ -0,0 +1,70 @@
+<?php
+
+/**
+ * Chill is a software for social workers
+ *
+ * For the full copyright and license information, please view
+ * the LICENSE file that was distributed with this source code.
+ */
+
+declare(strict_types=1);
+
+namespace Chill\CalendarBundle\RemoteCalendar\Connector\MSGraph;
+
+use League\OAuth2\Client\Tool\BearerAuthorizationTrait;
+use LogicException;
+use Symfony\Contracts\HttpClient\HttpClientInterface;
+use Symfony\Contracts\HttpClient\ResponseInterface;
+use Symfony\Contracts\HttpClient\ResponseStreamInterface;
+
+class OnBehalfOfUserHttpClient
+{
+    use BearerAuthorizationTrait;
+
+    private HttpClientInterface $decoratedClient;
+
+    private OnBehalfOfUserTokenStorage $tokenStorage;
+
+    /**
+     * @param HttpClientInterface $decoratedClient
+     */
+    public function __construct(OnBehalfOfUserTokenStorage $tokenStorage, ?HttpClientInterface $decoratedClient = null)
+    {
+        $this->decoratedClient = $decoratedClient ?? \Symfony\Component\HttpClient\HttpClient::create();
+        $this->tokenStorage = $tokenStorage;
+    }
+
+    public function request(string $method, string $url, array $options = []): ResponseInterface
+    {
+        $options['headers'] = array_merge(
+            $options['headers'] ?? [],
+            $this->getAuthorizationHeaders($this->tokenStorage->getToken())
+        );
+        $options['base_uri'] = 'https://graph.microsoft.com/v1.0/';
+
+        switch ($method) {
+            case 'GET':
+            case 'HEAD':
+                $options['headers']['Accept'] = 'application/json';
+
+                break;
+
+            case 'POST':
+            case 'PUT':
+            case 'PATCH':
+                $options['headers']['Content-Type'] = 'application/json';
+
+                break;
+
+            default:
+                throw new LogicException("Method not supported: {$method}");
+        }
+
+        return $this->decoratedClient->request($method, $url, $options);
+    }
+
+    public function stream($responses, ?float $timeout = null): ResponseStreamInterface
+    {
+        return $this->decoratedClient->stream($responses, $timeout);
+    }
+}

src/Bundle/ChillCalendarBundle/RemoteCalendar/Connector/MSGraph/OnBehalfOfUserTokenStorage.php

@@ -0,0 +1,65 @@
+<?php
+
+/**
+ * Chill is a software for social workers
+ *
+ * For the full copyright and license information, please view
+ * the LICENSE file that was distributed with this source code.
+ */
+
+declare(strict_types=1);
+
+namespace Chill\CalendarBundle\RemoteCalendar\Connector\MSGraph;
+
+use LogicException;
+use Symfony\Component\HttpFoundation\Session\SessionInterface;
+use TheNetworg\OAuth2\Client\Provider\Azure;
+use TheNetworg\OAuth2\Client\Token\AccessToken;
+
+/**
+ * Store token obtained on behalf of a User.
+ */
+class OnBehalfOfUserTokenStorage
+{
+    public const MS_GRAPH_ACCESS_TOKEN = 'msgraph_access_token';
+
+    private Azure $azure;
+
+    private SessionInterface $session;
+
+    public function __construct(Azure $azure, SessionInterface $session)
+    {
+        $this->azure = $azure;
+        $this->session = $session;
+    }
+
+    public function getToken(): AccessToken
+    {
+        /** @var ?AccessToken $token */
+        $token = $this->session->get(self::MS_GRAPH_ACCESS_TOKEN, null);
+
+        if (null === $token) {
+            throw new LogicException('unexisting token');
+        }
+
+        if ($token->hasExpired()) {
+            $token = $this->azure->getAccessToken('refresh_token', [
+                'refresh_token' => $token->getRefreshToken(),
+            ]);
+
+            $this->setToken($token);
+        }
+
+        return $token;
+    }
+
+    public function hasToken(): bool
+    {
+        return $this->session->has(self::MS_GRAPH_ACCESS_TOKEN);
+    }
+
+    public function setToken(AccessToken $token): void
+    {
+        $this->session->set(self::MS_GRAPH_ACCESS_TOKEN, $token);
+    }
+}

src/Bundle/ChillCalendarBundle/RemoteCalendar/Connector/MSGraph/RemoteEventConverter.php

@@ -0,0 +1,231 @@
+<?php
+
+/**
+ * Chill is a software for social workers
+ *
+ * For the full copyright and license information, please view
+ * the LICENSE file that was distributed with this source code.
+ */
+
+declare(strict_types=1);
+
+namespace Chill\CalendarBundle\RemoteCalendar\Connector\MSGraph;
+
+use Chill\CalendarBundle\Entity\Calendar;
+use Chill\CalendarBundle\Entity\CalendarRange;
+use Chill\CalendarBundle\Entity\Invite;
+use Chill\CalendarBundle\RemoteCalendar\Model\RemoteEvent;
+use Chill\PersonBundle\Entity\Person;
+use Chill\PersonBundle\Templating\Entity\PersonRenderInterface;
+use DateTimeImmutable;
+use DateTimeZone;
+use RuntimeException;
+use Symfony\Component\Templating\EngineInterface;
+use Symfony\Contracts\Translation\TranslatorInterface;
+
+/**
+ * Convert Chill Calendar event to Remote MS Graph event, and MS Graph
+ * event to RemoteEvent.
+ */
+class RemoteEventConverter
+{
+    /**
+     * valid when the remote string contains also a timezone, like in
+     * lastModifiedDate.
+     */
+    public const REMOTE_DATETIMEZONE_FORMAT = 'Y-m-d\\TH:i:s.u?P';
+
+    private const REMOTE_DATE_FORMAT = 'Y-m-d\TH:i:s.u0';
+
+    private const REMOTE_DATETIME_WITHOUT_TZ_FORMAT = 'Y-m-d\TH:i:s.u?';
+
+    private DateTimeZone $defaultDateTimeZone;
+
+    private EngineInterface $engine;
+
+    private PersonRenderInterface $personRender;
+
+    private DateTimeZone $remoteDateTimeZone;
+
+    private TranslatorInterface $translator;
+
+    public function __construct(EngineInterface $engine, PersonRenderInterface $personRender, TranslatorInterface $translator)
+    {
+        $this->engine = $engine;
+        $this->translator = $translator;
+        $this->personRender = $personRender;
+        $this->defaultDateTimeZone = (new DateTimeImmutable())->getTimezone();
+        $this->remoteDateTimeZone = self::getRemoteTimeZone();
+    }
+
+    /**
+     * Transform a CalendarRange into a representation suitable for storing into MSGraph.
+     *
+     * @return array an array representation for event in MS Graph
+     */
+    public function calendarRangeToEvent(CalendarRange $calendarRange): array
+    {
+        return [
+            'subject' => $this->translator->trans('remote_calendar.calendar_range_title'),
+            'start' => [
+                'dateTime' => $calendarRange->getStartDate()->setTimezone($this->remoteDateTimeZone)
+                    ->format(self::REMOTE_DATE_FORMAT),
+                'timeZone' => 'UTC',
+            ],
+            'end' => [
+                'dateTime' => $calendarRange->getEndDate()->setTimezone($this->remoteDateTimeZone)
+                    ->format(self::REMOTE_DATE_FORMAT),
+                'timeZone' => 'UTC',
+            ],
+            'attendees' => [
+                [
+                    'emailAddress' => [
+                        'address' => $calendarRange->getUser()->getEmailCanonical(),
+                        'name' => $calendarRange->getUser()->getLabel(),
+                    ],
+                ],
+            ],
+            'isReminderOn' => false,
+        ];
+    }
+
+    public function calendarToEvent(Calendar $calendar): array
+    {
+        return array_merge(
+            [
+                'subject' => '[Chill] ' .
+                    implode(
+                        ', ',
+                        $calendar->getPersons()->map(function (Person $p) {
+                            return $this->personRender->renderString($p, []);
+                        })->toArray()
+                    ),
+                'start' => [
+                    'dateTime' => $calendar->getStartDate()->setTimezone($this->remoteDateTimeZone)
+                        ->format(self::REMOTE_DATE_FORMAT),
+                    'timeZone' => 'UTC',
+                ],
+                'end' => [
+                    'dateTime' => $calendar->getEndDate()->setTimezone($this->remoteDateTimeZone)
+                        ->format(self::REMOTE_DATE_FORMAT),
+                    'timeZone' => 'UTC',
+                ],
+                'allowNewTimeProposals' => false,
+                'transactionId' => 'calendar_' . $calendar->getId(),
+                'body' => [
+                    'contentType' => 'text',
+                    'content' => $this->engine->render(
+                        '@ChillCalendar/MSGraph/calendar_event_body.html.twig',
+                        ['calendar' => $calendar]
+                    ),
+                ],
+                'responseRequested' => true,
+            ],
+            $this->calendarToEventAttendeesOnly($calendar)
+        );
+    }
+
+    public function calendarToEventAttendeesOnly(Calendar $calendar): array
+    {
+        return [
+            'attendees' => $calendar->getInvites()->map(
+                function (Invite $i) {
+                    return $this->buildInviteToAttendee($i);
+                }
+            )->toArray(),
+        ];
+    }
+
+    public function convertAvailabilityToRemoteEvent(array $event): RemoteEvent
+    {
+        $startDate =
+            DateTimeImmutable::createFromFormat(self::REMOTE_DATE_FORMAT, $event['start']['dateTime'])
+                ->setTimezone($this->defaultDateTimeZone);
+        $endDate =
+            DateTimeImmutable::createFromFormat(self::REMOTE_DATE_FORMAT, $event['end']['dateTime'], $this->remoteDateTimeZone)
+                ->setTimezone($this->defaultDateTimeZone);
+
+        return new RemoteEvent(
+            uniqid('generated_'),
+            $this->translator->trans('remote_ms_graph.freebusy_statuses.' . $event['status']),
+            '',
+            $startDate,
+            $endDate
+        );
+    }
+
+    public static function convertStringDateWithoutTimezone(string $date): DateTimeImmutable
+    {
+        $d = DateTimeImmutable::createFromFormat(
+            self::REMOTE_DATETIME_WITHOUT_TZ_FORMAT,
+            $date,
+            self::getRemoteTimeZone()
+        );
+
+        if (false === $d) {
+            throw new RuntimeException("could not convert string date to datetime: {$date}");
+        }
+
+        return $d->setTimezone((new DateTimeImmutable())->getTimezone());
+    }
+
+    public static function convertStringDateWithTimezone(string $date): DateTimeImmutable
+    {
+        $d = DateTimeImmutable::createFromFormat(self::REMOTE_DATETIMEZONE_FORMAT, $date);
+
+        if (false === $d) {
+            throw new RuntimeException("could not convert string date to datetime: {$date}");
+        }
+
+        $d->setTimezone((new DateTimeImmutable())->getTimezone());
+
+        return $d;
+    }
+
+    public function convertToRemote(array $event): RemoteEvent
+    {
+        $startDate =
+            DateTimeImmutable::createFromFormat(self::REMOTE_DATE_FORMAT, $event['start']['dateTime'])
+                ->setTimezone($this->defaultDateTimeZone);
+        $endDate =
+            DateTimeImmutable::createFromFormat(self::REMOTE_DATE_FORMAT, $event['end']['dateTime'], $this->remoteDateTimeZone)
+                ->setTimezone($this->defaultDateTimeZone);
+
+        return new RemoteEvent(
+            $event['id'],
+            $event['subject'],
+            '',
+            $startDate,
+            $endDate
+        );
+    }
+
+    public function getLastModifiedDate(array $event): DateTimeImmutable
+    {
+        return DateTimeImmutable::createFromFormat(self::REMOTE_DATETIMEZONE_FORMAT, $event['lastModifiedDateTime']);
+    }
+
+    /**
+     * Return a string which format a DateTime to string. To be used in POST requests,.
+     */
+    public static function getRemoteDateTimeSimpleFormat(): string
+    {
+        return 'Y-m-d\TH:i:s';
+    }
+
+    public static function getRemoteTimeZone(): DateTimeZone
+    {
+        return new DateTimeZone('UTC');
+    }
+
+    private function buildInviteToAttendee(Invite $invite): array
+    {
+        return [
+            'emailAddress' => [
+                'address' => $invite->getUser()->getEmail(),
+                'name' => $invite->getUser()->getLabel(),
+            ],
+            'type' => 'Required',
+        ];
+    }
+}

src/Bundle/ChillCalendarBundle/RemoteCalendar/Connector/MSGraph/RemoteToLocalSync/CalendarRangeSyncer.php

@@ -0,0 +1,103 @@
+<?php
+
+/**
+ * Chill is a software for social workers
+ *
+ * For the full copyright and license information, please view
+ * the LICENSE file that was distributed with this source code.
+ */
+
+declare(strict_types=1);
+
+namespace Chill\CalendarBundle\RemoteCalendar\Connector\MSGraph\RemoteToLocalSync;
+
+use Chill\CalendarBundle\Entity\CalendarRange;
+use Chill\CalendarBundle\RemoteCalendar\Connector\MSGraph\MachineHttpClient;
+use Chill\CalendarBundle\RemoteCalendar\Connector\MSGraph\RemoteEventConverter;
+use Chill\MainBundle\Entity\User;
+use Doctrine\ORM\EntityManagerInterface;
+use Psr\Log\LoggerInterface;
+use RuntimeException;
+use Symfony\Contracts\HttpClient\Exception\ClientExceptionInterface;
+use Symfony\Contracts\HttpClient\HttpClientInterface;
+
+class CalendarRangeSyncer
+{
+    private EntityManagerInterface $em;
+
+    private LoggerInterface $logger;
+
+    private HttpClientInterface $machineHttpClient;
+
+    /**
+     * @param MachineHttpClient $machineHttpClient
+     */
+    public function __construct(
+        EntityManagerInterface $em,
+        LoggerInterface $logger,
+        HttpClientInterface $machineHttpClient
+    ) {
+        $this->em = $em;
+        $this->logger = $logger;
+        $this->machineHttpClient = $machineHttpClient;
+    }
+
+    public function handleCalendarRangeSync(CalendarRange $calendarRange, array $notification, User $user): void
+    {
+        switch ($notification['changeType']) {
+            case 'deleted':
+                // test if the notification is not linked to a Calendar
+                if (null !== $calendarRange->getCalendar()) {
+                    return;
+                }
+                $calendarRange->preventEnqueueChanges = true;
+
+                $this->logger->info(__CLASS__ . ' remove a calendar range because deleted on remote calendar');
+                $this->em->remove($calendarRange);
+
+                break;
+
+            case 'updated':
+                try {
+                    $new = $this->machineHttpClient->request(
+                        'GET',
+                        $notification['resource']
+                    )->toArray();
+                } catch (ClientExceptionInterface $clientException) {
+                    $this->logger->warning(__CLASS__ . ' could not retrieve event from ms graph. Already deleted ?', [
+                        'calendarRangeId' => $calendarRange->getId(),
+                        'remoteEventId' => $notification['resource'],
+                    ]);
+
+                    throw $clientException;
+                }
+
+                $lastModified = RemoteEventConverter::convertStringDateWithTimezone($new['lastModifiedDateTime']);
+
+                if ($calendarRange->getRemoteAttributes()['lastModifiedDateTime'] === $lastModified->getTimestamp()) {
+                    $this->logger->info(__CLASS__ . ' change key is equals. Source is probably a local update', [
+                        'calendarRangeId' => $calendarRange->getId(),
+                        'remoteEventId' => $notification['resource'],
+                    ]);
+
+                    return;
+                }
+
+                $startDate = RemoteEventConverter::convertStringDateWithoutTimezone($new['start']['dateTime']);
+                $endDate = RemoteEventConverter::convertStringDateWithoutTimezone($new['end']['dateTime']);
+
+                $calendarRange
+                    ->setStartDate($startDate)->setEndDate($endDate)
+                    ->addRemoteAttributes([
+                        'lastModifiedDateTime' => $lastModified->getTimestamp(),
+                        'changeKey' => $new['changeKey'],
+                    ])
+                    ->preventEnqueueChanges = true;
+
+                break;
+
+            default:
+                throw new RuntimeException('This changeType is not suppored: ' . $notification['changeType']);
+        }
+    }
+}

src/Bundle/ChillCalendarBundle/RemoteCalendar/Connector/MSGraph/RemoteToLocalSync/CalendarSyncer.php

@@ -0,0 +1,182 @@
+<?php
+
+/**
+ * Chill is a software for social workers
+ *
+ * For the full copyright and license information, please view
+ * the LICENSE file that was distributed with this source code.
+ */
+
+declare(strict_types=1);
+
+namespace Chill\CalendarBundle\RemoteCalendar\Connector\MSGraph\RemoteToLocalSync;
+
+use Chill\CalendarBundle\Entity\Calendar;
+use Chill\CalendarBundle\Entity\Invite;
+use Chill\CalendarBundle\RemoteCalendar\Connector\MSGraph\RemoteEventConverter;
+use Chill\MainBundle\Entity\User;
+use Chill\MainBundle\Repository\UserRepositoryInterface;
+use LogicException;
+use Psr\Log\LoggerInterface;
+use RuntimeException;
+use Symfony\Contracts\HttpClient\Exception\ClientExceptionInterface;
+use Symfony\Contracts\HttpClient\HttpClientInterface;
+use function in_array;
+
+class CalendarSyncer
+{
+    private LoggerInterface $logger;
+
+    private HttpClientInterface $machineHttpClient;
+
+    private UserRepositoryInterface $userRepository;
+
+    public function __construct(LoggerInterface $logger, HttpClientInterface $machineHttpClient, UserRepositoryInterface $userRepository)
+    {
+        $this->logger = $logger;
+        $this->machineHttpClient = $machineHttpClient;
+        $this->userRepository = $userRepository;
+    }
+
+    public function handleCalendarSync(Calendar $calendar, array $notification, User $user): void
+    {
+        switch ($notification['changeType']) {
+            case 'deleted':
+                $this->handleDeleteCalendar($calendar, $notification, $user);
+
+                break;
+
+            case 'updated':
+                $this->handleUpdateCalendar($calendar, $notification, $user);
+
+                break;
+
+            default:
+                throw new RuntimeException('this change type is not supported: ' . $notification['changeType']);
+        }
+    }
+
+    private function handleDeleteCalendar(Calendar $calendar, array $notification, User $user): void
+    {
+        $calendar
+            ->setStatus(Calendar::STATUS_CANCELED)
+            ->setCalendarRange(null);
+        $calendar->preventEnqueueChanges = true;
+    }
+
+    private function handleUpdateCalendar(Calendar $calendar, array $notification, User $user): void
+    {
+        try {
+            $new = $this->machineHttpClient->request(
+                'GET',
+                $notification['resource']
+            )->toArray();
+        } catch (ClientExceptionInterface $clientException) {
+            $this->logger->warning(__CLASS__ . ' could not retrieve event from ms graph. Already deleted ?', [
+                'calendarId' => $calendar->getId(),
+                'remoteEventId' => $notification['resource'],
+            ]);
+
+            throw $clientException;
+        }
+
+        if (false === $new['isOrganizer']) {
+            return;
+        }
+
+        $lastModified = RemoteEventConverter::convertStringDateWithTimezone(
+            $new['lastModifiedDateTime']
+        );
+
+        if ($calendar->getRemoteAttributes()['lastModifiedDateTime'] === $lastModified->getTimestamp()) {
+            $this->logger->info(__CLASS__ . ' change key is equals. Source is probably a local update', [
+                'calendarRangeId' => $calendar->getId(),
+                'remoteEventId' => $notification['resource'],
+            ]);
+
+            return;
+        }
+
+        $this->syncAttendees($calendar, $new['attendees']);
+
+        $startDate = RemoteEventConverter::convertStringDateWithoutTimezone($new['start']['dateTime']);
+        $endDate = RemoteEventConverter::convertStringDateWithoutTimezone($new['end']['dateTime']);
+
+        if ($startDate->getTimestamp() !== $calendar->getStartDate()->getTimestamp()) {
+            $calendar->setStartDate($startDate)->setStatus(Calendar::STATUS_MOVED);
+        }
+
+        if ($endDate->getTimestamp() !== $calendar->getEndDate()->getTimestamp()) {
+            $calendar->setEndDate($endDate)->setStatus(Calendar::STATUS_MOVED);
+        }
+
+        $calendar
+            ->addRemoteAttributes([
+                'lastModifiedDateTime' => $lastModified->getTimestamp(),
+                'changeKey' => $new['changeKey'],
+            ])
+            ->preventEnqueueChanges = true;
+    }
+
+    private function syncAttendees(Calendar $calendar, array $attendees): void
+    {
+        $emails = [];
+
+        foreach ($attendees as $attendee) {
+            $status = $attendee['status']['response'];
+
+            if ('organizer' === $status) {
+                continue;
+            }
+
+            $email = $attendee['emailAddress']['address'];
+            $emails[] = strtolower($email);
+            $user = $this->userRepository->findOneByUsernameOrEmail($email);
+
+            if (null === $user) {
+                continue;
+            }
+
+            if (!$calendar->isInvited($user)) {
+                $calendar->addUser($user);
+            }
+
+            $invite = $calendar->getInviteForUser($user);
+
+            switch ($status) {
+                // possible cases: none, organizer, tentativelyAccepted, accepted, declined, notResponded.
+                case 'none':
+                case 'notResponded':
+                    $invite->setStatus(Invite::PENDING);
+
+                    break;
+
+                case 'tentativelyAccepted':
+                    $invite->setStatus(Invite::TENTATIVELY_ACCEPTED);
+
+                    break;
+
+                case 'accepted':
+                    $invite->setStatus(Invite::ACCEPTED);
+
+                    break;
+
+                case 'declined':
+                    $invite->setStatus(Invite::DECLINED);
+
+                    break;
+
+                default:
+                    throw new LogicException('should not happens, not implemented: ' . $status);
+
+                    break;
+            }
+        }
+
+        foreach ($calendar->getUsers() as $user) {
+            if (!in_array(strtolower($user->getEmailCanonical()), $emails, true)) {
+                $calendar->removeUser($user);
+            }
+        }
+    }
+}

src/Bundle/ChillCalendarBundle/RemoteCalendar/Connector/MSGraphRemoteCalendarConnector.php

@@ -0,0 +1,661 @@
+<?php
+
+/**
+ * Chill is a software for social workers
+ *
+ * For the full copyright and license information, please view
+ * the LICENSE file that was distributed with this source code.
+ */
+
+declare(strict_types=1);
+
+namespace Chill\CalendarBundle\RemoteCalendar\Connector;
+
+use Chill\CalendarBundle\Entity\Calendar;
+use Chill\CalendarBundle\Entity\CalendarRange;
+use Chill\CalendarBundle\Entity\Invite;
+use Chill\CalendarBundle\RemoteCalendar\Connector\MSGraph\MachineHttpClient;
+use Chill\CalendarBundle\RemoteCalendar\Connector\MSGraph\MapCalendarToUser;
+use Chill\CalendarBundle\RemoteCalendar\Connector\MSGraph\OnBehalfOfUserHttpClient;
+use Chill\CalendarBundle\RemoteCalendar\Connector\MSGraph\OnBehalfOfUserTokenStorage;
+use Chill\CalendarBundle\RemoteCalendar\Connector\MSGraph\RemoteEventConverter;
+use Chill\CalendarBundle\Repository\CalendarRangeRepository;
+use Chill\MainBundle\Entity\User;
+use DateTimeImmutable;
+use Exception;
+use Psr\Log\LoggerInterface;
+use Symfony\Component\HttpFoundation\RedirectResponse;
+use Symfony\Component\HttpFoundation\Response;
+use Symfony\Component\Routing\Generator\UrlGeneratorInterface;
+use Symfony\Contracts\HttpClient\Exception\ClientExceptionInterface;
+use Symfony\Contracts\Translation\TranslatorInterface;
+use function count;
+
+class MSGraphRemoteCalendarConnector implements RemoteCalendarConnectorInterface
+{
+    private CalendarRangeRepository $calendarRangeRepository;
+
+    private LoggerInterface $logger;
+
+    private MachineHttpClient $machineHttpClient;
+
+    private MapCalendarToUser $mapCalendarToUser;
+
+    private RemoteEventConverter $remoteEventConverter;
+
+    private OnBehalfOfUserTokenStorage $tokenStorage;
+
+    private TranslatorInterface $translator;
+
+    private UrlGeneratorInterface $urlGenerator;
+
+    private OnBehalfOfUserHttpClient $userHttpClient;
+
+    public function __construct(
+        CalendarRangeRepository $calendarRangeRepository,
+        MachineHttpClient $machineHttpClient,
+        MapCalendarToUser $mapCalendarToUser,
+        LoggerInterface $logger,
+        OnBehalfOfUserTokenStorage $tokenStorage,
+        OnBehalfOfUserHttpClient $userHttpClient,
+        RemoteEventConverter $remoteEventConverter,
+        TranslatorInterface $translator,
+        UrlGeneratorInterface $urlGenerator
+    ) {
+        $this->calendarRangeRepository = $calendarRangeRepository;
+        $this->machineHttpClient = $machineHttpClient;
+        $this->mapCalendarToUser = $mapCalendarToUser;
+        $this->logger = $logger;
+        $this->remoteEventConverter = $remoteEventConverter;
+        $this->tokenStorage = $tokenStorage;
+        $this->translator = $translator;
+        $this->urlGenerator = $urlGenerator;
+        $this->userHttpClient = $userHttpClient;
+    }
+
+    public function getMakeReadyResponse(string $returnPath): Response
+    {
+        return new RedirectResponse($this->urlGenerator
+            ->generate('chill_calendar_remote_connect_azure', ['returnPath' => $returnPath]));
+    }
+
+    public function isReady(): bool
+    {
+        return $this->tokenStorage->hasToken();
+    }
+
+    public function listEventsForUser(User $user, DateTimeImmutable $startDate, DateTimeImmutable $endDate): array
+    {
+        $userId = $this->mapCalendarToUser->getUserId($user);
+
+        if (null === $userId) {
+            return [];
+        }
+
+        try {
+            $bareEvents = $this->userHttpClient->request(
+                'GET',
+                'users/' . $userId . '/calendarView',
+                [
+                    'query' => [
+                        'startDateTime' => $startDate->format(DateTimeImmutable::ATOM),
+                        'endDateTime' => $endDate->format(DateTimeImmutable::ATOM),
+                        '$select' => 'id,subject,start,end',
+                    ],
+                ]
+            )->toArray();
+
+            $ids = array_map(static function ($item) { return $item['id']; }, $bareEvents['value']);
+            $existingIdsInRange = $this->calendarRangeRepository->findRemoteIdsPresent($ids);
+
+            return array_values(
+                array_map(
+                    function ($item) {
+                        return $this->remoteEventConverter->convertToRemote($item);
+                    },
+                    // filter all event to keep only the one not in range
+                    array_filter(
+                        $bareEvents['value'],
+                        static function ($item) use ($existingIdsInRange) {
+                            return (!$existingIdsInRange[$item['id']]) ?? true;
+                        }
+                    )
+                )
+            );
+        } catch (ClientExceptionInterface $e) {
+            if (403 === $e->getResponse()->getStatusCode()) {
+                return $this->getScheduleTimesForUser($user, $startDate, $endDate);
+            }
+
+            $this->logger->debug('Could not get list of event on MSGraph', [
+                'error_code' => $e->getResponse()->getStatusCode(),
+                'error' => $e->getResponse()->getInfo(),
+            ]);
+
+            return [];
+        }
+    }
+
+    public function removeCalendarRange(string $remoteId, array $remoteAttributes, User $user): void
+    {
+        if ('' === $remoteId) {
+            return;
+        }
+
+        $this->removeEvent($remoteId, $user);
+    }
+
+    public function syncCalendar(Calendar $calendar, string $action, ?CalendarRange $previousCalendarRange, ?User $previousMainUser, ?array $oldInvites, ?array $newInvites): void
+    {
+        /*
+         * cases to support:
+         *
+         * * a calendar range is created:
+         *     * create on remote
+         *     * if calendar range is associated: remove the range
+         * * a Calendar change the CalendarRange:
+         *     * re-create the previous calendar range;
+         *     * remove the current calendar range
+         * * a calendar change the mainUser
+         *     * cancel the calendar in the previous mainUser
+         *     * recreate the previous calendar range in the previousMainUser, if any
+         *     * delete the current calendar range in the current mainUser, if any
+         *     * create the calendar in the current mainUser
+         *
+         */
+
+        if (!$calendar->hasRemoteId()) {
+            $this->createCalendarOnRemote($calendar);
+        } else {
+            if (null !== $previousMainUser) {
+                // cancel event in previousMainUserCalendar
+                $this->cancelOnRemote(
+                    $calendar->getRemoteId(),
+                    $this->translator->trans('remote_ms_graph.cancel_event_because_main_user_is_%label%', ['%label%' => $calendar->getMainUser()]),
+                    $previousMainUser,
+                    'calendar_' . $calendar->getRemoteId()
+                );
+                $this->createCalendarOnRemote($calendar);
+            } else {
+                $this->patchCalendarOnRemote($calendar, $newInvites);
+            }
+        }
+
+        if ($calendar->hasCalendarRange() && $calendar->getCalendarRange()->hasRemoteId()) {
+            $this->removeEvent(
+                $calendar->getCalendarRange()->getRemoteId(),
+                $calendar->getCalendarRange()->getUser()
+            );
+
+            $calendar->getCalendarRange()
+                ->addRemoteAttributes([
+                    'lastModifiedDateTime' => null,
+                    'changeKey' => null,
+                    'previousId' => $calendar->getCalendarRange()->getRemoteId(),
+                ])
+                ->setRemoteId('');
+        }
+
+        if (null !== $previousCalendarRange) {
+            $this->createRemoteCalendarRange($previousCalendarRange);
+        }
+    }
+
+    public function syncCalendarRange(CalendarRange $calendarRange): void
+    {
+        if ($calendarRange->hasRemoteId()) {
+            $this->updateRemoteCalendarRange($calendarRange);
+        } else {
+            $this->createRemoteCalendarRange($calendarRange);
+        }
+    }
+
+    public function syncInvite(Invite $invite): void
+    {
+        if ('' === $remoteId = $invite->getCalendar()->getRemoteId()) {
+            return;
+        }
+
+        if (null === $invite->getUser()) {
+            return;
+        }
+
+        if (null === $userId = $this->mapCalendarToUser->getUserId($invite->getUser())) {
+            return;
+        }
+
+        if ($invite->hasRemoteId()) {
+            $remoteIdAttendeeCalendar = $invite->getRemoteId();
+        } else {
+            $remoteIdAttendeeCalendar = $this->findRemoteIdOnUserCalendar($invite->getCalendar(), $invite->getUser());
+            $invite->setRemoteId($remoteIdAttendeeCalendar);
+        }
+
+        switch ($invite->getStatus()) {
+            case Invite::PENDING:
+                return;
+
+            case Invite::ACCEPTED:
+                $url = "/v1.0/users/{$userId}/calendar/events/{$remoteIdAttendeeCalendar}/accept";
+
+                break;
+
+            case Invite::TENTATIVELY_ACCEPTED:
+                $url = "/v1.0/users/{$userId}/calendar/events/{$remoteIdAttendeeCalendar}/tentativelyAccept";
+
+                break;
+
+            case Invite::DECLINED:
+                $url = "/v1.0/users/{$userId}/calendar/events/{$remoteIdAttendeeCalendar}/decline";
+
+                break;
+
+            default:
+                throw new Exception('not supported');
+        }
+
+        try {
+            $this->machineHttpClient->request(
+                'POST',
+                $url,
+                ['json' => ['sendResponse' => true]]
+            );
+        } catch (ClientExceptionInterface $e) {
+            $this->logger->warning('could not update calendar range to remote', [
+                'exception' => $e->getTraceAsString(),
+                'content' => $e->getResponse()->getContent(),
+                'calendarRangeId' => 'invite_' . $invite->getId(),
+            ]);
+
+            throw $e;
+        }
+    }
+
+    private function cancelOnRemote(string $remoteId, string $comment, User $user, string $identifier): void
+    {
+        $userId = $this->mapCalendarToUser->getUserId($user);
+
+        if (null === $userId) {
+            return;
+        }
+
+        try {
+            $this->machineHttpClient->request(
+                'POST',
+                "users/{$userId}/calendar/events/{$remoteId}/cancel",
+                [
+                    'json' => ['Comment' => $comment],
+                ]
+            );
+        } catch (ClientExceptionInterface $e) {
+            $this->logger->warning('could not update calendar range to remote', [
+                'exception' => $e->getTraceAsString(),
+                'content' => $e->getResponse()->getContent(),
+                'calendarRangeId' => $identifier,
+            ]);
+
+            throw $e;
+        }
+    }
+
+    private function createCalendarOnRemote(Calendar $calendar): void
+    {
+        $eventData = $this->remoteEventConverter->calendarToEvent($calendar);
+
+        [
+            'id' => $id,
+            'lastModifiedDateTime' => $lastModified,
+            'changeKey' => $changeKey
+        ] = $this->createOnRemote($eventData, $calendar->getMainUser(), 'calendar_' . $calendar->getId());
+
+        if (null === $id) {
+            return;
+        }
+
+        $calendar
+            ->setRemoteId($id)
+            ->addRemoteAttributes([
+                'lastModifiedDateTime' => $lastModified,
+                'changeKey' => $changeKey,
+            ]);
+    }
+
+    /**
+     * @param string $identifier an identifier for logging in case of something does not work
+     *
+     * @return array{?id: string, ?lastModifiedDateTime: int, ?changeKey: string}
+     */
+    private function createOnRemote(array $eventData, User $user, string $identifier): array
+    {
+        $userId = $this->mapCalendarToUser->getUserId($user);
+
+        if (null === $userId) {
+            $this->logger->warning('user does not have userId nor calendarId', [
+                'user_id' => $user->getId(),
+                'calendar_identifier' => $identifier,
+            ]);
+
+            return ['id' => null, 'lastModifiedDateTime' => null, 'changeKey' => null];
+        }
+
+        try {
+            $event = $this->machineHttpClient->request(
+                'POST',
+                'users/' . $userId . '/calendar/events',
+                [
+                    'json' => $eventData,
+                ]
+            )->toArray();
+        } catch (ClientExceptionInterface $e) {
+            $this->logger->warning('could not save calendar range to remote', [
+                'exception' => $e->getTraceAsString(),
+                'content' => $e->getResponse()->getContent(),
+                'calendar_identifier' => $identifier,
+            ]);
+
+            throw $e;
+        }
+
+        return [
+            'id' => $event['id'],
+            'lastModifiedDateTime' => $this->remoteEventConverter->getLastModifiedDate($event)->getTimestamp(),
+            'changeKey' => $event['changeKey'],
+        ];
+    }
+
+    private function createRemoteCalendarRange(CalendarRange $calendarRange): void
+    {
+        $userId = $this->mapCalendarToUser->getUserId($calendarRange->getUser());
+
+        if (null === $userId) {
+            $this->logger->warning('user does not have userId nor calendarId', [
+                'user_id' => $calendarRange->getUser()->getId(),
+                'calendar_range_id' => $calendarRange->getId(),
+            ]);
+
+            return;
+        }
+
+        $eventData = $this->remoteEventConverter->calendarRangeToEvent($calendarRange);
+
+        [
+            'id' => $id,
+            'lastModifiedDateTime' => $lastModified,
+            'changeKey' => $changeKey
+        ] = $this->createOnRemote(
+            $eventData,
+            $calendarRange->getUser(),
+            'calendar_range_' . $calendarRange->getId()
+        );
+
+        $calendarRange->setRemoteId($id)
+            ->addRemoteAttributes([
+                'lastModifiedDateTime' => $lastModified,
+                'changeKey' => $changeKey,
+            ]);
+    }
+
+    /**
+     * the remoteId is not the same across different user calendars. This method allow to find
+     * the correct remoteId in another calendar.
+     *
+     * For achieving this, the iCalUid is used.
+     */
+    private function findRemoteIdOnUserCalendar(Calendar $calendar, User $user): ?string
+    {
+        // find the icalUid on original user
+        $event = $this->getOnRemote($calendar->getMainUser(), $calendar->getRemoteId());
+        $userId = $this->mapCalendarToUser->getUserId($user);
+
+        if ('' === $iCalUid = ($event['iCalUId'] ?? '')) {
+            throw new Exception('no iCalUid for this event');
+        }
+
+        try {
+            $events = $this->machineHttpClient->request(
+                'GET',
+                "/v1.0/users/{$userId}/calendar/events",
+                [
+                    'query' => [
+                        '$select' => 'id',
+                        '$filter' => "iCalUId eq '{$iCalUid}'",
+                    ],
+                ]
+            )->toArray();
+        } catch (ClientExceptionInterface $clientException) {
+            throw $clientException;
+        }
+
+        if (1 !== count($events['value'])) {
+            throw new Exception('multiple events found with same iCalUid');
+        }
+
+        return $events['value'][0]['id'];
+    }
+
+    private function getOnRemote(User $user, string $remoteId): array
+    {
+        $userId = $this->mapCalendarToUser->getUserId($user);
+
+        if (null === $userId) {
+            throw new Exception('no remote calendar for this user', [
+                'user' => $user->getId(),
+                'remoteId' => $remoteId,
+            ]);
+        }
+
+        try {
+            $v = $this->machineHttpClient->request(
+                'GET',
+                'users/' . $userId . '/calendar/events/' . $remoteId
+            )->toArray();
+            dump($v);
+
+            return $v;
+        } catch (ClientExceptionInterface $e) {
+            $this->logger->warning('Could not get event from calendar', [
+                'remoteId' => $remoteId,
+            ]);
+
+            throw $e;
+        }
+    }
+
+    private function getScheduleTimesForUser(User $user, DateTimeImmutable $startDate, DateTimeImmutable $endDate): array
+    {
+        $userId = $this->mapCalendarToUser->getUserId($user);
+
+        if (null === $userId) {
+            return [];
+        }
+
+        if (null === $user->getEmailCanonical() || '' === $user->getEmailCanonical()) {
+            return [];
+        }
+
+        $body = [
+            'schedules' => [$user->getEmailCanonical()],
+            'startTime' => [
+                'dateTime' => ($startDate->setTimezone(RemoteEventConverter::getRemoteTimeZone())->format(RemoteEventConverter::getRemoteDateTimeSimpleFormat())),
+                'timeZone' => 'UTC',
+            ],
+            'endTime' => [
+                'dateTime' => ($endDate->setTimezone(RemoteEventConverter::getRemoteTimeZone())->format(RemoteEventConverter::getRemoteDateTimeSimpleFormat())),
+                'timeZone' => 'UTC',
+            ],
+        ];
+
+        try {
+            $response = $this->userHttpClient->request('POST', 'users/' . $userId . '/calendar/getSchedule', [
+                'json' => $body,
+            ])->toArray();
+        } catch (ClientExceptionInterface $e) {
+            $this->logger->debug('Could not get schedule on MSGraph', [
+                'error_code' => $e->getResponse()->getStatusCode(),
+                'error' => $e->getResponse()->getInfo(),
+            ]);
+
+            return [];
+        }
+
+        return array_map(
+            function ($item) {
+                return $this->remoteEventConverter->convertAvailabilityToRemoteEvent($item);
+            },
+            $response['value'][0]['scheduleItems']
+        );
+    }
+
+    private function patchCalendarOnRemote(Calendar $calendar, array $newInvites): void
+    {
+        $eventDatas = [];
+        $eventDatas[] = $this->remoteEventConverter->calendarToEvent($calendar);
+
+        if (0 < count($newInvites)) {
+            // it seems that invitaiton are always send, even if attendee changes are mixed with other datas
+            // $eventDatas[] = $this->remoteEventConverter->calendarToEventAttendeesOnly($calendar);
+        }
+
+        foreach ($eventDatas as $eventData) {
+            [
+                'id' => $id,
+                'lastModifiedDateTime' => $lastModified,
+                'changeKey' => $changeKey
+            ] = $this->patchOnRemote(
+                $calendar->getRemoteId(),
+                $eventData,
+                $calendar->getMainUser(),
+                'calendar_' . $calendar->getId()
+            );
+
+            $calendar->addRemoteAttributes([
+                'lastModifiedDateTime' => $lastModified,
+                'changeKey' => $changeKey,
+            ]);
+        }
+    }
+
+    /**
+     * @param string $identifier an identifier for logging in case of something does not work
+     *
+     * @return array{?id: string, ?lastModifiedDateTime: int, ?changeKey: string}
+     */
+    private function patchOnRemote(string $remoteId, array $eventData, User $user, string $identifier): array
+    {
+        $userId = $this->mapCalendarToUser->getUserId($user);
+
+        if (null === $userId) {
+            $this->logger->warning('user does not have userId nor calendarId', [
+                'user_id' => $user->getId(),
+                'calendar_identifier' => $identifier,
+            ]);
+
+            return ['id' => null, 'lastModifiedDateTime' => null, 'changeKey' => null];
+        }
+
+        try {
+            $event = $this->machineHttpClient->request(
+                'PATCH',
+                'users/' . $userId . '/calendar/events/' . $remoteId,
+                [
+                    'json' => $eventData,
+                ]
+            )->toArray();
+        } catch (ClientExceptionInterface $e) {
+            $this->logger->warning('could not update calendar range to remote', [
+                'exception' => $e->getTraceAsString(),
+                'calendarRangeId' => $identifier,
+            ]);
+
+            throw $e;
+        }
+
+        return [
+            'id' => $event['id'],
+            'lastModifiedDateTime' => $this->remoteEventConverter->getLastModifiedDate($event)->getTimestamp(),
+            'changeKey' => $event['changeKey'],
+        ];
+    }
+
+    private function removeEvent($remoteId, User $user): void
+    {
+        $userId = $this->mapCalendarToUser->getUserId($user);
+
+        try {
+            $this->machineHttpClient->request(
+                'DELETE',
+                'users/' . $userId . '/calendar/events/' . $remoteId
+            );
+        } catch (ClientExceptionInterface $e) {
+            $this->logger->warning('could not remove event from calendar', [
+                'event_remote_id' => $remoteId,
+                'user_id' => $user->getId(),
+            ]);
+        }
+    }
+
+    private function updateRemoteCalendarRange(CalendarRange $calendarRange): void
+    {
+        $userId = $this->mapCalendarToUser->getUserId($calendarRange->getUser());
+        $calendarId = $this->mapCalendarToUser->getCalendarId($calendarRange->getUser());
+
+        if (null === $userId || null === $calendarId) {
+            $this->logger->warning('user does not have userId nor calendarId', [
+                'user_id' => $calendarRange->getUser()->getId(),
+                'calendar_range_id' => $calendarRange->getId(),
+            ]);
+
+            return;
+        }
+
+        try {
+            $event = $this->machineHttpClient->request(
+                'GET',
+                'users/' . $userId . '/calendar/events/' . $calendarRange->getRemoteId()
+            )->toArray();
+        } catch (ClientExceptionInterface $e) {
+            $this->logger->warning('Could not get event from calendar', [
+                'calendar_range_id' => $calendarRange->getId(),
+                'calendar_range_remote_id' => $calendarRange->getRemoteId(),
+            ]);
+
+            throw $e;
+        }
+
+        if ($this->remoteEventConverter->getLastModifiedDate($event)->getTimestamp() > $calendarRange->getUpdatedAt()->getTimestamp()) {
+            $this->logger->info('Skip updating as the lastModified date seems more fresh than the database one', [
+                'calendar_range_id' => $calendarRange->getId(),
+                'calendar_range_remote_id' => $calendarRange->getRemoteId(),
+                'db_last_updated' => $calendarRange->getUpdatedAt()->getTimestamp(),
+                'remote_last_updated' => $this->remoteEventConverter->getLastModifiedDate($event)->getTimestamp(),
+            ]);
+
+            return;
+        }
+
+        $eventData = $this->remoteEventConverter->calendarRangeToEvent($calendarRange);
+
+        try {
+            $event = $this->machineHttpClient->request(
+                'PATCH',
+                'users/' . $userId . '/calendar/events/' . $calendarRange->getRemoteId(),
+                [
+                    'json' => $eventData,
+                ]
+            )->toArray();
+        } catch (ClientExceptionInterface $e) {
+            $this->logger->warning('could not update calendar range to remote', [
+                'exception' => $e->getTraceAsString(),
+                'calendarRangeId' => $calendarRange->getId(),
+            ]);
+
+            throw $e;
+        }
+
+        $calendarRange
+            ->addRemoteAttributes([
+                'lastModifiedDateTime' => $this->remoteEventConverter->getLastModifiedDate($event)->getTimestamp(),
+                'changeKey' => $event['changeKey'],
+            ]);
+    }
+}

src/Bundle/ChillCalendarBundle/RemoteCalendar/Connector/NullRemoteCalendarConnector.php

@@ -0,0 +1,54 @@
+<?php
+
+/**
+ * Chill is a software for social workers
+ *
+ * For the full copyright and license information, please view
+ * the LICENSE file that was distributed with this source code.
+ */
+
+declare(strict_types=1);
+
+namespace Chill\CalendarBundle\RemoteCalendar\Connector;
+
+use Chill\CalendarBundle\Entity\Calendar;
+use Chill\CalendarBundle\Entity\CalendarRange;
+use Chill\CalendarBundle\Entity\Invite;
+use Chill\MainBundle\Entity\User;
+use DateTimeImmutable;
+use LogicException;
+use Symfony\Component\HttpFoundation\Response;
+
+class NullRemoteCalendarConnector implements RemoteCalendarConnectorInterface
+{
+    public function getMakeReadyResponse(string $returnPath): Response
+    {
+        throw new LogicException('As this connector is always ready, this method should not be called');
+    }
+
+    public function isReady(): bool
+    {
+        return true;
+    }
+
+    public function listEventsForUser(User $user, DateTimeImmutable $startDate, DateTimeImmutable $endDate): array
+    {
+        return [];
+    }
+
+    public function removeCalendarRange(string $remoteId, array $remoteAttributes, User $user): void
+    {
+    }
+
+    public function syncCalendar(Calendar $calendar, string $action, ?CalendarRange $previousCalendarRange, ?User $previousMainUser, ?array $oldInvites, ?array $newInvites): void
+    {
+    }
+
+    public function syncCalendarRange(CalendarRange $calendarRange): void
+    {
+    }
+
+    public function syncInvite(Invite $invite): void
+    {
+    }
+}

src/Bundle/ChillCalendarBundle/RemoteCalendar/Connector/RemoteCalendarConnectorInterface.php

@@ -0,0 +1,52 @@
+<?php
+
+/**
+ * Chill is a software for social workers
+ *
+ * For the full copyright and license information, please view
+ * the LICENSE file that was distributed with this source code.
+ */
+
+declare(strict_types=1);
+
+namespace Chill\CalendarBundle\RemoteCalendar\Connector;
+
+use Chill\CalendarBundle\Entity\Calendar;
+use Chill\CalendarBundle\Entity\CalendarRange;
+use Chill\CalendarBundle\Entity\Invite;
+use Chill\CalendarBundle\RemoteCalendar\Model\RemoteEvent;
+use Chill\MainBundle\Entity\User;
+use DateTimeImmutable;
+use Symfony\Component\HttpFoundation\Response;
+
+interface RemoteCalendarConnectorInterface
+{
+    /**
+     * Return a response, more probably a RedirectResponse, where the user
+     * will be able to fullfill requirements to prepare this connector and
+     * make it ready.
+     */
+    public function getMakeReadyResponse(string $returnPath): Response;
+
+    /**
+     * Return true if the connector is ready to act as a proxy for reading
+     * remote calendars.
+     */
+    public function isReady(): bool;
+
+    /**
+     * @return array|RemoteEvent[]
+     */
+    public function listEventsForUser(User $user, DateTimeImmutable $startDate, DateTimeImmutable $endDate): array;
+
+    public function removeCalendarRange(string $remoteId, array $remoteAttributes, User $user): void;
+
+    /**
+     * @param array<array{inviteId: int, userId: int, userEmail: int, userLabel: string}> $oldInvites
+     */
+    public function syncCalendar(Calendar $calendar, string $action, ?CalendarRange $previousCalendarRange, ?User $previousMainUser, ?array $oldInvites, ?array $newInvites): void;
+
+    public function syncCalendarRange(CalendarRange $calendarRange): void;
+
+    public function syncInvite(Invite $invite): void;
+}

src/Bundle/ChillCalendarBundle/RemoteCalendar/DependencyInjection/RemoteCalendarCompilerPass.php

@@ -0,0 +1,75 @@
+<?php
+
+/**
+ * Chill is a software for social workers
+ *
+ * For the full copyright and license information, please view
+ * the LICENSE file that was distributed with this source code.
+ */
+
+declare(strict_types=1);
+
+namespace Chill\CalendarBundle\RemoteCalendar\DependencyInjection;
+
+use Chill\CalendarBundle\Command\AzureGrantAdminConsentAndAcquireToken;
+use Chill\CalendarBundle\Command\MapAndSubscribeUserCalendarCommand;
+use Chill\CalendarBundle\Controller\RemoteCalendarConnectAzureController;
+use Chill\CalendarBundle\RemoteCalendar\Connector\MSGraph\MachineHttpClient;
+use Chill\CalendarBundle\RemoteCalendar\Connector\MSGraph\MachineTokenStorage;
+use Chill\CalendarBundle\RemoteCalendar\Connector\MSGraphRemoteCalendarConnector;
+use Chill\CalendarBundle\RemoteCalendar\Connector\NullRemoteCalendarConnector;
+use Chill\CalendarBundle\RemoteCalendar\Connector\RemoteCalendarConnectorInterface;
+use RuntimeException;
+use Symfony\Component\DependencyInjection\Compiler\CompilerPassInterface;
+use Symfony\Component\DependencyInjection\ContainerBuilder;
+use Symfony\Contracts\HttpClient\HttpClientInterface;
+use TheNetworg\OAuth2\Client\Provider\Azure;
+
+class RemoteCalendarCompilerPass implements CompilerPassInterface
+{
+    public function process(ContainerBuilder $container)
+    {
+        $config = $container->getParameter('chill_calendar');
+        $connector = null;
+
+        if (!$config['remote_calendars_sync']['enabled']) {
+            $connector = NullRemoteCalendarConnector::class;
+        }
+
+        if ($config['remote_calendars_sync']['microsoft_graph']['enabled']) {
+            $connector = MSGraphRemoteCalendarConnector::class;
+
+            $container->setAlias(HttpClientInterface::class . ' $machineHttpClient', MachineHttpClient::class);
+        } else {
+            // remove services which cannot be loaded
+            $container->removeDefinition(MapAndSubscribeUserCalendarCommand::class);
+            $container->removeDefinition(AzureGrantAdminConsentAndAcquireToken::class);
+            $container->removeDefinition(RemoteCalendarConnectAzureController::class);
+            $container->removeDefinition(MachineTokenStorage::class);
+            $container->removeDefinition(MachineHttpClient::class);
+            $container->removeDefinition(MSGraphRemoteCalendarConnector::class);
+        }
+
+        if (!$container->hasAlias(Azure::class) && $container->hasDefinition('knpu.oauth2.client.azure')) {
+            $container->setAlias(Azure::class, 'knpu.oauth2.provider.azure');
+        }
+
+        if (null === $connector) {
+            throw new RuntimeException('Could not configure remote calendar');
+        }
+
+        foreach ([
+            NullRemoteCalendarConnector::class,
+            MSGraphRemoteCalendarConnector::class, ] as $serviceId) {
+            if ($connector === $serviceId) {
+                $container->getDefinition($serviceId)
+                    ->setDecoratedService(RemoteCalendarConnectorInterface::class);
+            } else {
+                // keep the container lighter by removing definitions
+                if ($container->hasDefinition($serviceId)) {
+                    $container->removeDefinition($serviceId);
+                }
+            }
+        }
+    }
+}

src/Bundle/ChillCalendarBundle/RemoteCalendar/Model/RemoteEvent.php

@@ -0,0 +1,49 @@
+<?php
+
+/**
+ * Chill is a software for social workers
+ *
+ * For the full copyright and license information, please view
+ * the LICENSE file that was distributed with this source code.
+ */
+
+declare(strict_types=1);
+
+namespace Chill\CalendarBundle\RemoteCalendar\Model;
+
+use DateTimeImmutable;
+use Symfony\Component\Serializer\Annotation as Serializer;
+
+class RemoteEvent
+{
+    public string $description;
+
+    /**
+     * @Serializer\Groups({"read"})
+     */
+    public DateTimeImmutable $endDate;
+
+    /**
+     * @Serializer\Groups({"read"})
+     */
+    public string $id;
+
+    /**
+     * @Serializer\Groups({"read"})
+     */
+    public DateTimeImmutable $startDate;
+
+    /**
+     * @Serializer\Groups({"read"})
+     */
+    public string $title;
+
+    public function __construct(string $id, string $title, string $description, DateTimeImmutable $startDate, DateTimeImmutable $endDate)
+    {
+        $this->id = $id;
+        $this->title = $title;
+        $this->description = $description;
+        $this->startDate = $startDate;
+        $this->endDate = $endDate;
+    }
+}

src/Bundle/ChillCalendarBundle/Repository/CalendarACLAwareRepository.php

@@ -0,0 +1,80 @@
+<?php
+
+/**
+ * Chill is a software for social workers
+ *
+ * For the full copyright and license information, please view
+ * the LICENSE file that was distributed with this source code.
+ */
+
+declare(strict_types=1);
+
+namespace Chill\CalendarBundle\Repository;
+
+use Chill\CalendarBundle\Entity\Calendar;
+use Chill\PersonBundle\Entity\AccompanyingPeriod;
+use DateTimeImmutable;
+use Doctrine\ORM\EntityManagerInterface;
+use Doctrine\ORM\QueryBuilder;
+
+class CalendarACLAwareRepository implements CalendarACLAwareRepositoryInterface
+{
+    private EntityManagerInterface $em;
+
+    public function __construct(EntityManagerInterface $em)
+    {
+        $this->em = $em;
+    }
+
+    public function buildQueryByAccompanyingPeriod(AccompanyingPeriod $period, ?DateTimeImmutable $startDate, ?DateTimeImmutable $endDate): QueryBuilder
+    {
+        $qb = $this->em->createQueryBuilder();
+        $qb->from(Calendar::class, 'c');
+
+        $andX = $qb->expr()->andX($qb->expr()->eq('c.accompanyingPeriod', ':period'));
+        $qb->setParameter('period', $period);
+
+        if (null !== $startDate) {
+            $andX->add($qb->expr()->gte('c.startDate', ':startDate'));
+            $qb->setParameter('startDate', $startDate);
+        }
+
+        if (null !== $endDate) {
+            $andX->add($qb->expr()->lte('c.endDate', ':endDate'));
+            $qb->setParameter('endDate', $endDate);
+        }
+
+        $qb->where($andX);
+
+        return $qb;
+    }
+
+    public function countByAccompanyingPeriod(AccompanyingPeriod $period, ?DateTimeImmutable $startDate, ?DateTimeImmutable $endDate): int
+    {
+        $qb = $this->buildQueryByAccompanyingPeriod($period, $startDate, $endDate)->select('count(c)');
+
+        return $qb->getQuery()->getSingleScalarResult();
+    }
+
+    /**
+     * @return array|Calendar[]
+     */
+    public function findByAccompanyingPeriod(AccompanyingPeriod $period, ?DateTimeImmutable $startDate, ?DateTimeImmutable $endDate, ?array $orderBy = [], ?int $offset = null, ?int $limit = null): array
+    {
+        $qb = $this->buildQueryByAccompanyingPeriod($period, $startDate, $endDate)->select('c');
+
+        foreach ($orderBy as $sort => $order) {
+            $qb->addOrderBy('c.' . $sort, $order);
+        }
+
+        if (null !== $offset) {
+            $qb->setFirstResult($offset);
+        }
+
+        if (null !== $limit) {
+            $qb->setMaxResults($limit);
+        }
+
+        return $qb->getQuery()->getResult();
+    }
+}

src/Bundle/ChillCalendarBundle/Repository/CalendarACLAwareRepositoryInterface.php

@@ -0,0 +1,26 @@
+<?php
+
+/**
+ * Chill is a software for social workers
+ *
+ * For the full copyright and license information, please view
+ * the LICENSE file that was distributed with this source code.
+ */
+
+declare(strict_types=1);
+
+namespace Chill\CalendarBundle\Repository;
+
+use Chill\CalendarBundle\Entity\Calendar;
+use Chill\PersonBundle\Entity\AccompanyingPeriod;
+use DateTimeImmutable;
+
+interface CalendarACLAwareRepositoryInterface
+{
+    public function countByAccompanyingPeriod(AccompanyingPeriod $period, ?DateTimeImmutable $startDate, ?DateTimeImmutable $endDate): int;
+
+    /**
+     * @return array|Calendar[]
+     */
+    public function findByAccompanyingPeriod(AccompanyingPeriod $period, ?DateTimeImmutable $startDate, ?DateTimeImmutable $endDate, ?array $orderBy = [], ?int $offset = null, ?int $limit = null): array;
+}

src/Bundle/ChillCalendarBundle/Repository/CalendarRangeRepository.php

@@ -12,48 +12,159 @@ declare(strict_types=1);
 namespace Chill\CalendarBundle\Repository;
 
 use Chill\CalendarBundle\Entity\CalendarRange;
-use Doctrine\Bundle\DoctrineBundle\Repository\ServiceEntityRepository;
-use Doctrine\Persistence\ManagerRegistry;
+use Chill\MainBundle\Entity\User;
+use DateTimeImmutable;
+use Doctrine\DBAL\Types\Types;
+use Doctrine\ORM\EntityManagerInterface;
+use Doctrine\ORM\EntityRepository;
+use Doctrine\ORM\Query\ResultSetMapping;
+use Doctrine\ORM\QueryBuilder;
+use Doctrine\Persistence\ObjectRepository;
+use function count;
 
-/**
- * @method CalendarRange|null find($id, $lockMode = null, $lockVersion = null)
- * @method CalendarRange|null findOneBy(array $criteria, array $orderBy = null)
- * @method CalendarRange[]    findAll()
- * @method CalendarRange[]    findBy(array $criteria, array $orderBy = null, $limit = null, $offset = null)
- */
-class CalendarRangeRepository extends ServiceEntityRepository
+class CalendarRangeRepository implements ObjectRepository
 {
-    public function __construct(ManagerRegistry $registry)
+    private EntityManagerInterface $em;
+
+    private EntityRepository $repository;
+
+    public function __construct(EntityManagerInterface $entityManager)
     {
-        parent::__construct($registry, CalendarRange::class);
+        $this->em = $entityManager;
+        $this->repository = $entityManager->getRepository(CalendarRange::class);
     }
 
-    // /**
-    //  * @return CalendarRange[] Returns an array of CalendarRange objects
-    //  */
-    /*
-    public function findByExampleField($value)
+    public function countByAvailableRangesForUser(User $user, DateTimeImmutable $from, DateTimeImmutable $to): int
     {
-        return $this->createQueryBuilder('c')
-            ->andWhere('c.exampleField = :val')
-            ->setParameter('val', $value)
-            ->orderBy('c.id', 'ASC')
-            ->setMaxResults(10)
-            ->getQuery()
-            ->getResult()
-        ;
+        return $this->buildQueryAvailableRangesForUser($user, $from, $to)
+            ->select('COUNT(cr)')
+            ->getQuery()->getSingleScalarResult();
     }
-     */
 
-    /*
-    public function findOneBySomeField($value): ?CalendarRange
+    public function find($id): ?CalendarRange
     {
-        return $this->createQueryBuilder('c')
-            ->andWhere('c.exampleField = :val')
-            ->setParameter('val', $value)
-            ->getQuery()
-            ->getOneOrNullResult()
-        ;
+        return $this->repository->find($id);
     }
+
+    /**
+     * @return array|CalendarRange[]
      */
+    public function findAll(): array
+    {
+        return $this->repository->findAll();
+    }
+
+    /**
+     * @return array|CalendarRange[]
+     */
+    public function findBy(array $criteria, ?array $orderBy = null, ?int $limit = null, ?int $offset = null)
+    {
+        return $this->repository->findBy($criteria, $orderBy, $limit, $offset);
+    }
+
+    /**
+     * @return array|CalendarRange[]
+     */
+    public function findByAvailableRangesForUser(
+        User $user,
+        DateTimeImmutable $from,
+        DateTimeImmutable $to,
+        ?int $limit = null,
+        ?int $offset = null
+    ): array {
+        $qb = $this->buildQueryAvailableRangesForUser($user, $from, $to);
+
+        if (null !== $limit) {
+            $qb->setMaxResults($limit);
+        }
+
+        if (null !== $offset) {
+            $qb->setFirstResult($offset);
+        }
+
+        return $qb->getQuery()->getResult();
+    }
+
+    public function findOneBy(array $criteria): ?CalendarRange
+    {
+        return $this->repository->findOneBy($criteria);
+    }
+
+    /**
+     * Given a list of remote ids, return an array where
+     * keys are the remoteIds, and value is a boolean, true if the
+     * id is present in database.
+     *
+     * @param array<int, string>|list<string> $remoteIds
+     *
+     * @return array<string, bool>
+     */
+    public function findRemoteIdsPresent(array $remoteIds): array
+    {
+        if (0 === count($remoteIds)) {
+            return [];
+        }
+
+        $sql = 'SELECT
+            sq.remoteId as remoteid,
+            EXISTS (SELECT 1 FROM chill_calendar.calendar_range cr WHERE cr.remoteId = sq.remoteId) AS present
+            FROM
+                (
+                    VALUES %remoteIds%
+                ) AS sq(remoteId);
+            ';
+
+        $remoteIdsStr = implode(
+            ', ',
+            array_fill(0, count($remoteIds), '((?))')
+        );
+
+        $rsm = new ResultSetMapping();
+        $rsm
+            ->addScalarResult('remoteid', 'remoteId', Types::STRING)
+            ->addScalarResult('present', 'present', Types::BOOLEAN);
+
+        $rows = $this->em
+            ->createNativeQuery(
+                strtr($sql, ['%remoteIds%' => $remoteIdsStr]),
+                $rsm
+            )
+            ->setParameters(array_values($remoteIds))
+            ->getResult();
+
+        $results = [];
+
+        foreach ($rows as $r) {
+            $results[$r['remoteId']] = $r['present'];
+        }
+
+        return $results;
+    }
+
+    public function getClassName(): string
+    {
+        return CalendarRange::class;
+    }
+
+    private function buildQueryAvailableRangesForUser(User $user, DateTimeImmutable $from, DateTimeImmutable $to): QueryBuilder
+    {
+        $qb = $this->repository->createQueryBuilder('cr');
+
+        $qb->leftJoin('cr.calendar', 'calendar');
+
+        return $qb
+            ->where(
+                $qb->expr()->andX(
+                    $qb->expr()->eq('cr.user', ':user'),
+                    $qb->expr()->gte('cr.startDate', ':startDate'),
+                    $qb->expr()->lte('cr.endDate', ':endDate'),
+                    $qb->expr()->isNull('calendar')
+                )
+            )
+            ->setParameters([
+                'user' => $user,
+                'startDate' => $from,
+                'endDate' => $to,
+            ]);
+    }
 }

src/Bundle/ChillCalendarBundle/Repository/CalendarRepository.php

@@ -12,52 +12,112 @@ declare(strict_types=1);
 namespace Chill\CalendarBundle\Repository;
 
 use Chill\CalendarBundle\Entity\Calendar;
-use Doctrine\Bundle\DoctrineBundle\Repository\ServiceEntityRepository;
+use Chill\PersonBundle\Entity\AccompanyingPeriod;
+use DateTimeImmutable;
+use Doctrine\ORM\EntityManagerInterface;
 use Doctrine\ORM\EntityRepository;
-use Doctrine\Persistence\ManagerRegistry;
+use Doctrine\ORM\QueryBuilder;
+use Doctrine\Persistence\ObjectRepository;
 
-/**
- * @method Calendar|null find($id, $lockMode = null, $lockVersion = null)
- * @method Calendar|null findOneBy(array $criteria, array $orderBy = null)
- * @method Calendar[]    findAll()
- * @method Calendar[]    findBy(array $criteria, array $orderBy = null, $limit = null, $offset = null)
- */
-class CalendarRepository extends ServiceEntityRepository
+class CalendarRepository implements ObjectRepository
 {
-    // private EntityRepository $repository;
+    private EntityRepository $repository;
 
-    public function __construct(ManagerRegistry $registry)
+    public function __construct(EntityManagerInterface $entityManager)
     {
-        parent::__construct($registry, Calendar::class);
-        // $this->repository = $entityManager->getRepository(AccompanyingPeriodWork::class);
+        $this->repository = $entityManager->getRepository(Calendar::class);
     }
 
-    // /**
-    //  * @return Calendar[] Returns an array of Calendar objects
-    //  */
-    /*
-    public function findByExampleField($value)
+    public function countByAccompanyingPeriod(AccompanyingPeriod $period): int
     {
-        return $this->createQueryBuilder('c')
-            ->andWhere('c.exampleField = :val')
-            ->setParameter('val', $value)
-            ->orderBy('c.id', 'ASC')
-            ->setMaxResults(10)
-            ->getQuery()
-            ->getResult()
-        ;
+        return $this->repository->count(['accompanyingPeriod' => $period]);
     }
+
+    public function find($id): ?Calendar
+    {
+        return $this->repository->find($id);
+    }
+
+    /**
+     * @return array|Calendar[]
      */
-
-    /*
-    public function findOneBySomeField($value): ?Calendar
+    public function findAll(): array
     {
-        return $this->createQueryBuilder('c')
-            ->andWhere('c.exampleField = :val')
-            ->setParameter('val', $value)
-            ->getQuery()
-            ->getOneOrNullResult()
-        ;
+        return $this->repository->findAll();
     }
+
+    /**
+     * @return array|Calendar[]
      */
+    public function findBy(array $criteria, ?array $orderBy = null, ?int $limit = null, ?int $offset = null): array
+    {
+        return $this->repository->findBy($criteria, $orderBy, $limit, $offset);
+    }
+
+    /**
+     * @return array|Calendar[]
+     */
+    public function findByAccompanyingPeriod(AccompanyingPeriod $period, ?array $orderBy = null, ?int $limit = null, ?int $offset = null): array
+    {
+        return $this->findBy(
+            [
+                'accompanyingPeriod' => $period,
+            ],
+            $orderBy,
+            $limit,
+            $orderBy
+        );
+    }
+
+    public function findByNotificationAvailable(DateTimeImmutable $startDate, DateTimeImmutable $endDate, ?int $limit = null, ?int $offset = null): array
+    {
+        $qb = $this->queryByNotificationAvailable($startDate, $endDate)->select('c');
+
+        if (null !== $limit) {
+            $qb->setMaxResults($limit);
+        }
+
+        if (null !== $offset) {
+            $qb->setFirstResult($offset);
+        }
+
+        return $qb->getQuery()->getResult();
+    }
+
+    public function findOneBy(array $criteria): ?Calendar
+    {
+        return $this->repository->findOneBy($criteria);
+    }
+
+    public function getClassName()
+    {
+        return Calendar::class;
+    }
+
+    private function queryByNotificationAvailable(DateTimeImmutable $startDate, DateTimeImmutable $endDate): QueryBuilder
+    {
+        $qb = $this->repository->createQueryBuilder('c');
+
+        $qb->where(
+            $qb->expr()->andX(
+                $qb->expr()->eq('c.sendSMS', ':true'),
+                $qb->expr()->gte('c.startDate', ':startDate'),
+                $qb->expr()->lt('c.startDate', ':endDate'),
+                $qb->expr()->orX(
+                    $qb->expr()->eq('c.smsStatus', ':pending'),
+                    $qb->expr()->eq('c.smsStatus', ':cancel_pending')
+                )
+            )
+        );
+
+        $qb->setParameters([
+            'true' => true,
+            'startDate' => $startDate,
+            'endDate' => $endDate,
+            'pending' => Calendar::SMS_PENDING,
+            'cancel_pending' => Calendar::SMS_CANCEL_PENDING,
+        ]);
+
+        return $qb;
+    }
 }

src/Bundle/ChillCalendarBundle/Repository/InviteRepository.php

@@ -12,48 +12,47 @@ declare(strict_types=1);
 namespace Chill\CalendarBundle\Repository;
 
 use Chill\CalendarBundle\Entity\Invite;
-use Doctrine\Bundle\DoctrineBundle\Repository\ServiceEntityRepository;
-use Doctrine\Persistence\ManagerRegistry;
+use Doctrine\ORM\EntityManagerInterface;
+use Doctrine\ORM\EntityRepository;
+use Doctrine\Persistence\ObjectRepository;
 
-/**
- * @method Invite|null find($id, $lockMode = null, $lockVersion = null)
- * @method Invite|null findOneBy(array $criteria, array $orderBy = null)
- * @method Invite[]    findAll()
- * @method Invite[]    findBy(array $criteria, array $orderBy = null, $limit = null, $offset = null)
- */
-class InviteRepository extends ServiceEntityRepository
+class InviteRepository implements ObjectRepository
 {
-    public function __construct(ManagerRegistry $registry)
+    private EntityRepository $entityRepository;
+
+    public function __construct(EntityManagerInterface $em)
     {
-        parent::__construct($registry, Invite::class);
+        $this->entityRepository = $em->getRepository(Invite::class);
     }
 
-    // /**
-    //  * @return Invite[] Returns an array of Invite objects
-    //  */
-    /*
-    public function findByExampleField($value)
+    public function find($id): ?Invite
     {
-        return $this->createQueryBuilder('i')
-            ->andWhere('i.exampleField = :val')
-            ->setParameter('val', $value)
-            ->orderBy('i.id', 'ASC')
-            ->setMaxResults(10)
-            ->getQuery()
-            ->getResult()
-        ;
+        return $this->entityRepository->find($id);
     }
-     */
 
-    /*
-    public function findOneBySomeField($value): ?Invite
-    {
-        return $this->createQueryBuilder('i')
-            ->andWhere('i.exampleField = :val')
-            ->setParameter('val', $value)
-            ->getQuery()
-            ->getOneOrNullResult()
-        ;
-    }
+    /**
+     * @return array|Invite[]
      */
+    public function findAll(): array
+    {
+        return $this->entityRepository->findAll();
+    }
+
+    /**
+     * @return array|Invite[]
+     */
+    public function findBy(array $criteria, ?array $orderBy = null, ?int $limit = null, ?int $offset = null)
+    {
+        return $this->entityRepository->findBy($criteria, $orderBy, $limit, $offset);
+    }
+
+    public function findOneBy(array $criteria): ?Invite
+    {
+        return $this->entityRepository->findOneBy($criteria);
+    }
+
+    public function getClassName(): string
+    {
+        return Invite::class;
+    }
 }

src/Bundle/ChillCalendarBundle/Resources/config/services.yml

@@ -3,9 +3,8 @@ services:
 
     Chill\CalendarBundle\Repository\:
         autowire: true
+        autoconfigure: true
         resource: '../../Repository/'
-        tags:
-            - { name: 'doctrine.repository_service' }
 
     Chill\CalendarBundle\Menu\:
         autowire: true
@@ -13,7 +12,32 @@ services:
         resource: '../../Menu/'
         tags: ['chill.menu_builder']
 
+    Chill\CalendarBundle\Command\:
+        autowire: true
+        autoconfigure: true
+        resource: '../../Command/'
+
+    Chill\CalendarBundle\Messenger\:
+        autowire: true
+        autoconfigure: true
+        resource: '../../Messenger/'
+
+    Chill\CalendarBundle\Command\AzureGrantAdminConsentAndAcquireToken:
+        autoconfigure: true
+        autowire: true
+        arguments:
+            $azure: '@knpu.oauth2.provider.azure'
+        tags: ['console.command']
+
     Chill\CalendarBundle\Security\:
         autoconfigure: true
         autowire: true
         resource: '../../Security/'
+
+    Chill\CalendarBundle\Service\:
+        autoconfigure: true
+        autowire: true
+        resource: '../../Service/'
+
+    Chill\CalendarBundle\Service\ShortMessageForCalendarBuilderInterface:
+        alias: Chill\CalendarBundle\Service\DefaultShortMessageForCalendarBuider

src/Bundle/ChillCalendarBundle/Resources/config/services/event.yml

@@ -7,4 +7,37 @@ services:
                 name: 'doctrine.orm.entity_listener'
                 event: 'postPersist'
                 entity: 'Chill\ActivityBundle\Entity\Activity'
-        
+
+    Chill\CalendarBundle\Messenger\Doctrine\CalendarRangeEntityListener:
+        autowire: true
+        autoconfigure: true
+        tags:
+            -
+                name: 'doctrine.orm.entity_listener'
+                event: 'postPersist'
+                entity: 'Chill\CalendarBundle\Entity\CalendarRange'
+            -
+                name: 'doctrine.orm.entity_listener'
+                event: 'postUpdate'
+                entity: 'Chill\CalendarBundle\Entity\CalendarRange'
+            -
+                name: 'doctrine.orm.entity_listener'
+                event: 'postRemove'
+                entity: 'Chill\CalendarBundle\Entity\CalendarRange'
+
+    Chill\CalendarBundle\Messenger\Doctrine\CalendarEntityListener:
+        autowire: true
+        autoconfigure: true
+        tags:
+            -
+                name: 'doctrine.orm.entity_listener'
+                event: 'postPersist'
+                entity: 'Chill\CalendarBundle\Entity\Calendar'
+            -
+                name: 'doctrine.orm.entity_listener'
+                event: 'postUpdate'
+                entity: 'Chill\CalendarBundle\Entity\Calendar'
+            -
+                name: 'doctrine.orm.entity_listener'
+                event: 'postRemove'
+                entity: 'Chill\CalendarBundle\Entity\Calendar'

src/Bundle/ChillCalendarBundle/Resources/config/services/form.yml

@@ -1,10 +1,6 @@
 ---
-services:    
-    chill.calendar.form.type.calendar:
-        class: Chill\CalendarBundle\Form\CalendarType
-        arguments:
-            - "@chill.main.helper.translatable_string"
-            - "@doctrine.orm.entity_manager"
-
-        tags:
-            - { name: form.type, alias: chill_calendarbundle_calendar }
+services:
+    Chill\CalendarBundle\Form\:
+        resource: './../../Form'
+        autowire: true
+        autoconfigure: true

src/Bundle/ChillCalendarBundle/Resources/config/services/remote_calendar.yaml

@@ -0,0 +1,15 @@
+services:
+    _defaults:
+        autoconfigure: true
+        autowire: true
+
+    Chill\CalendarBundle\RemoteCalendar\Connector\RemoteCalendarConnectorInterface: ~
+
+    Chill\CalendarBundle\RemoteCalendar\Connector\NullRemoteCalendarConnector: ~
+
+    Chill\CalendarBundle\RemoteCalendar\Connector\MSGraphRemoteCalendarConnector: ~
+
+    Chill\CalendarBundle\RemoteCalendar\Connector\MSGraph\:
+        resource: '../../RemoteCalendar/Connector/MSGraph/'
+
+

src/Bundle/ChillCalendarBundle/Resources/public/module/Invite/answer.js

@@ -0,0 +1,33 @@
+
+import { createApp } from 'vue';
+import Answer from 'ChillCalendarAssets/vuejs/Invite/Answer';
+import { _createI18n } from 'ChillMainAssets/vuejs/_js/i18n';
+
+const i18n = _createI18n({});
+
+document.addEventListener('DOMContentLoaded', function (e) {
+  console.log('dom loaded answer');
+  document.querySelectorAll('div[invite-answer]').forEach(function (el) {
+    console.log('element found', el);
+
+    const app = createApp({
+      components: {
+        Answer,
+      },
+      data() {
+        return {
+          status: el.dataset.status,
+          calendarId: Number.parseInt(el.dataset.calendarId),
+        }
+      },
+      template: '<answer :calendarId="calendarId" :status="status" @statusChanged="onStatusChanged"></answer>',
+      methods: {
+        onStatusChanged: function(newStatus) {
+          this.$data.status = newStatus;
+        },
+      }
+    });
+
+    app.use(i18n).mount(el);
+  });
+});

src/Bundle/ChillCalendarBundle/Resources/public/vuejs/Calendar/App.vue

@@ -1,27 +1,83 @@
 <template>
+
+  <teleport to="#mainUser">
+
+    <h2 class="chill-red">Utilisateur principal</h2>
+    <div>
+      <div>
+        <div v-if="null !== this.$store.getters.getMainUser">
+          <calendar-active :user="this.$store.getters.getMainUser" ></calendar-active>
+        </div>
+        <pick-entity
+          :multiple="false"
+          :types="['user']"
+          :uniqid="'main_user_calendar'"
+          :picked="null !== this.$store.getters.getMainUser ? [this.$store.getters.getMainUser] : []"
+          :removableIfSet="false"
+          :displayPicked="false"
+          @addNewEntity="setMainUser"
+        ></pick-entity>
+      </div>
+    </div>
+  </teleport>
+
   <concerned-groups></concerned-groups>
+
+  <teleport to="#schedule">
+    <div class="row mb-3" v-if="activity.startDate !== null">
+      <label class="col-form-label col-sm-4">Date</label>
+      <div class="col-sm-8">
+        {{ $d(activity.startDate, 'long') }} - {{ $d(activity.endDate, 'hoursOnly') }}
+        <span v-if="activity.calendarRange === null">(Pas de plage de disponibilité sélectionnée)</span>
+        <span v-else>(Une plage de disponibilité sélectionnée)</span>
+      </div>
+    </div>
+  </teleport>
+
   <location></location>
-  <teleport to="#calendarControls">
-    <calendar-user-selector
-      v-bind:users="users"
-      v-bind:calendarEvents="calendarEvents"
-      v-bind:updateEventsSource="updateEventsSource"
-      v-bind:showMyCalendar="showMyCalendar"
-      v-bind:toggleMyCalendar="toggleMyCalendar"
-      v-bind:toggleWeekends="toggleWeekends" >
-    </calendar-user-selector>
-  </teleport>
-  <teleport to="#fullCalendar">
-    <FullCalendar ref="fullCalendar" :options="calendarOptions">
-      <template v-slot:eventContent='arg'>
-        <b>{{ arg.timeText }}</b>
-        <i>&nbsp;{{ arg.event.title }}</i>
-      </template>
-    </FullCalendar>
-  </teleport>
+
+
+
+    <teleport to="#fullCalendar">
+      <div class="calendar-actives">
+        <template class="" v-for="u in getActiveUsers" :key="u.id">
+          <calendar-active :user="u" :invite="this.$store.getters.getInviteForUser(u)"></calendar-active>
+        </template>
+      </div>
+      <div class="display-options row justify-content-between">
+        <div class="col-sm col-xs-12">
+          <div class="input-group mb-3">
+            <label class="input-group-text" for="slotDuration">Durée des créneaux</label>
+            <select v-model="this.slotDuration" id="slotDuration" class="form-select">
+              <option value="00:05:00">5 minutes</option>
+              <option value="00:10:00">10 minutes</option>
+              <option value="00:15:00">15 minutes</option>
+              <option value="00:30:00">30 minutes</option>
+            </select>
+          </div>
+        </div>
+        <div class="col-sm col-xs-12">
+          <div class="float-end">
+            <div class="input-group mb-3">
+              <div class="input-group-text">
+                <input id="showHideWE" class="form-check-input mt-0" type="checkbox" v-model="this.hideWeekEnds">
+                <label for="showHideWE" class="form-check-label"> Masquer les week-ends</label>
+              </div>
+            </div>
+          </div>
+        </div>
+      </div>
+      <FullCalendar ref="fullCalendar" :options="calendarOptions">
+        <template v-slot:eventContent='arg'>
+          <b>{{ arg.timeText }}</b>
+          <i>&nbsp;{{ arg.event.title }}</i>
+        </template>
+      </FullCalendar>
+    </teleport>
 </template>
 
 <script>
+//import {mapGetters} from 'vuex';
 import ConcernedGroups from 'ChillActivityAssets/vuejs/Activity/components/ConcernedGroups.vue';
 import Location from 'ChillActivityAssets/vuejs/Activity/components/Location.vue';
 import CalendarUserSelector from '../_components/CalendarUserSelector/CalendarUserSelector.vue';
@@ -31,126 +87,154 @@ import FullCalendar from '@fullcalendar/vue3';
 import dayGridPlugin from '@fullcalendar/daygrid';
 import interactionPlugin from '@fullcalendar/interaction';
 import timeGridPlugin from '@fullcalendar/timegrid';
-// import listPlugin from '@fullcalendar/list';
+import CalendarActive from './Components/CalendarActive';
+import PickEntity from 'ChillMainAssets/vuejs/PickEntity/PickEntity.vue';
+import {mapGetters, mapState} from "vuex";
 
 export default {
   name: "App",
   components: {
     ConcernedGroups,
     Location,
-    CalendarUserSelector,
-    FullCalendar
+    FullCalendar,
+    CalendarActive,
+    PickEntity,
   },
   data() {
     return {
       errorMsg: [],
-      users: {
-        loaded: [],
-        selected: [],
-        logged: null
-      },
-      calendarEvents: {
-        loaded: [],
-        selected: [],
-        user: [],
-        current: {
-            events: [{
-                title: 'plage prévue',
-                start: window.startDate,
-                end: window.endDate
-            }],
-            id: window.mainUser,
-            color: '#bbbbbb'
-          }
-      },
-      selectedEvent: null,
-      previousSelectedEvent: null,
-      previousSelectedEventColor: null,
       showMyCalendar: false,
-      calendarOptions: {
+      slotDuration: '00:10:00',
+      hideWeekEnds: true,
+    }
+  },
+  computed: {
+    ...mapGetters(['getMainUser']),
+    ...mapState(['activity']),
+    events() {
+      return this.$store.getters.getEventSources;
+    },
+    calendarOptions() {
+      return {
         locale: frLocale,
-        plugins: [ dayGridPlugin, interactionPlugin, timeGridPlugin ],
+        plugins: [dayGridPlugin, interactionPlugin, timeGridPlugin, dayGridPlugin],
         initialView: 'timeGridWeek',
-        initialDate: window.startDate !== undefined ? window.startDate : new Date(),
-        eventSource: [],
+        initialDate: this.$store.getters.getInitialDate,
+        eventSources: this.events,
         selectable: true,
+        datesSet: this.onDatesSet,
         select: this.onDateSelect,
         eventChange: this.onEventChange,
         eventClick: this.onEventClick,
-      //   eventMouseEnter: this.onEventMouseEnter,
-      //   eventMouseLeave: this.onEventMouseLeave,
         selectMirror: true,
         editable: true,
-        weekends: false,
+        weekends: !this.hideWeekEnds,
         headerToolbar: {
           left: 'prev,next today',
           center: 'title',
-          right: 'dayGridMonth,timeGridWeek,timeGridDay,listMonth,listWeek,listDay'
+          right: 'dayGridMonth,timeGridWeek,dayGridThreeDays,timeGridDay',
         },
+        views: {
+          timeGrid: {
+            slotEventOverlap: false,
+            slotDuration: this.slotDuration,
+            //scrollTime: '10:00:00',
+          },
+          dayGridThreeDays: {
+            type: 'dayGridWeek',
+            duration: { days: 3},
+            buttonText: this.$t('list_three_days'),
+          },
+        },
+      };
+    },
+    getActiveUsers() {
+      const users = [];
+      for (const id of this.$store.state.currentView.users.keys()) {
+        users.push(this.$store.getters.getUserDataById(id).user);
       }
+      return users;
     }
   },
   methods: {
-    init() {
-      this.updateEventsSource();
-    },
-    toggleMyCalendar(value) {
-      this.showMyCalendar = value;
-    },
-    toggleWeekends: function() {
-      this.calendarOptions.weekends = !this.calendarOptions.weekends;
-    },
-    updateEventsSource() {
-      this.calendarOptions.eventSources = [];
-      this.calendarOptions.eventSources.push(...this.calendarEvents.selected);
-      if (window.startDate !== undefined) {
-         this.calendarOptions.eventSources.push(this.calendarEvents.current);
-      }
-      if (this.showMyCalendar) {
-          this.calendarOptions.eventSources.push(this.calendarEvents.user);
-      }
-    },
-    unSelectPreviousEvent(event) {
-      if (event) {
-        if (typeof event.setProp === 'function') {
-          event.setProp('backgroundColor', this.previousSelectedEventColor);
-          event.setProp('borderColor', this.previousSelectedEventColor);
-          event.setProp('textColor','#444444');
-          event.setProp('title','');
+    setMainUser(user) {
+      console.log('setMainUser APP', user);
+
+      if (user.id !== this.$store.getters.getMainUser && (
+          this.$store.state.activity.calendarRange !== null
+          || this.$store.state.activity.startDate !== null
+          || this.$store.state.activity.endDate !== null
+        )
+      ) {
+        if (!window.confirm(this.$t('change_main_user_will_reset_event_data'))) {
+          return;
         }
       }
+
+      this.$store.dispatch('setMainUser', user);
+      this.$store.commit('showUserOnCalendar', {user, ranges: true, remotes: true});
+    },
+    removeMainUser(user) {
+      console.log('removeMainUser APP', user);
+
+      window.alert(this.$t('main_user_is_mandatory'));
+      return;
+    },
+    onDatesSet(event) {
+      console.log('onDatesSet', event);
+      this.$store.dispatch('setCurrentDatesView', {start: event.start, end: event.end});
     },
     onDateSelect(payload) {
-      // console.log(payload)
-      this.unSelectPreviousEvent(this.selectedEvent);
-      Object.assign(payload, {users: this.users});
-      Object.assign(payload, {title: 'Choisir cette plage'}); //TODO does not display
-      //payload.event.setProp('title', 'Choisir cette plage');
-      this.$store.dispatch('createEvent', payload);
+      console.log('onDateSelect', payload);
+
+      // show an alert if changing mainUser
+      if ((this.$store.getters.getMainUser !== null
+        && this.$store.state.me.id !== this.$store.getters.getMainUser.id)
+        || this.$store.getters.getMainUser === null) {
+        if (!window.confirm(this.$t('will_change_main_user_for_me'))) {
+          return;
+        } else {
+          this.$store.commit('showUserOnCalendar', {user: this.$store.state.me, remotes: true, ranges: true})
+        }
+      }
+
+      this.$store.dispatch('setEventTimes', {start: payload.start, end: payload.end});
     },
     onEventChange(payload) {
-      this.$store.dispatch('updateEvent', payload);
+      console.log('onEventChange', payload);
+      if (this.$store.state.activity.calendarRange !== null) {
+        throw new Error("not allowed to edit a calendar associated with a calendar range");
+      }
+      this.$store.dispatch('setEventTimes', {start: payload.event.start, end: payload.event.end});
     },
     onEventClick(payload) {
-      this.previousSelectedEvent = this.selectedEvent;
-      this.previousSelectedEventColor = payload.event.extendedProps.sourceColor;
-      this.selectedEvent = payload.event;
-      this.unSelectPreviousEvent(this.previousSelectedEvent);
-      payload.event.setProp('backgroundColor','#3788d8');
-      payload.event.setProp('borderColor','#3788d8');
-      payload.event.setProp('title', 'Choisir cette plage');
-      payload.event.setProp('textColor','#ffffff');
+      if (payload.event.extendedProps.is !== 'range') {
+        // do nothing when clicking on remote
+        return;
+      }
+
+      // show an alert if changing mainUser
+      if (this.$store.getters.getMainUser !== null
+        && payload.event.extendedProps.userId !== this.$store.getters.getMainUser.id) {
+        if (!window.confirm(this.$t('this_calendar_range_will_change_main_user'))) {
+          return;
+        }
+      }
+
+      this.$store.dispatch('associateCalendarToRange', {range: payload.event});
     },
-    onEventMouseEnter(payload) {
-      payload.event.setProp('borderColor','#444444');
-    },
-    onEventMouseLeave(payload) {
-      payload.event.setProp('borderColor','#ffffff');
-    }
   },
-  mounted() {
-    this.init();
-  }
 }
 </script>
 
+<style>
+.calendar-actives {
+  display: flex;
+  flex-direction: row;
+  flex-wrap: wrap;
+}
+
+.display-options {
+  margin-top: 1rem;
+}
+</style>

src/Bundle/ChillCalendarBundle/Resources/public/vuejs/Calendar/Components/CalendarActive.vue

@@ -0,0 +1,80 @@
+<template>
+  <div :style="style" class="calendar-active">
+    <span class="badge-user">
+      {{ user.text }}
+      <template v-if="invite !== null">
+        <i v-if="invite.status === 'accepted'" class="fa fa-check"></i>
+        <i v-else-if="invite.status === 'declined'" class="fa fa-times"></i>
+        <i v-else-if="invite.status === 'pending'" class="fa fa-question-o"></i>
+        <i v-else-if="invite.status === 'tentative'" class="fa fa-question"></i>
+        <span v-else="">{{ invite.status }}</span>
+      </template>
+    </span>
+    <span class="form-check-inline form-switch">
+      <input class="form-check-input" type="checkbox" id="flexSwitchCheckDefault" v-model="rangeShow">
+      &nbsp;<label class="form-check-label" for="flexSwitchCheckDefault" title="Disponibilités"><i class="fa fa-calendar-check-o"></i></label>
+    </span>
+    <span class="form-check-inline form-switch">
+      <input class="form-check-input" type="checkbox" id="flexSwitchCheckDefault" v-model="remoteShow">
+      &nbsp;<label class="form-check-label" for="flexSwitchCheckDefault" title="Agenda"><i class="fa fa-calendar"></i></label>
+    </span>
+  </div>
+</template>
+
+<script>
+import {mapGetters} from 'vuex';
+
+export default {
+  name: "CalendarActive",
+  props: {
+    user: {
+      type: Object,
+      required: true
+    },
+    invite: {
+      type: Object,
+      required: false,
+      default: null,
+    }
+  },
+  computed: {
+    style() {
+      return {
+        backgroundColor: this.$store.getters.getUserData(this.user).mainColor,
+      };
+    },
+    rangeShow: {
+      set (value) {
+        this.$store.commit('showUserOnCalendar', {user: this.user, ranges: value});
+      },
+      get() {
+        return this.$store.getters.isRangeShownOnCalendarForUser(this.user);
+      }
+    },
+    remoteShow: {
+      set (value) {
+        this.$store.commit('showUserOnCalendar', {user: this.user, remotes: value});
+      },
+      get() {
+        return this.$store.getters.isRemoteShownOnCalendarForUser(this.user);
+      }
+    },
+  }
+}
+</script>
+
+<style scoped lang="scss">
+
+.calendar-active {
+  margin: 0 0.25rem 0.25rem 0;
+  padding: 0.5rem;
+
+  border-radius: 0.5rem;
+
+  color: var(--bs-blue);
+
+  & > .badge-user {
+    margin-right: 0.5rem;
+  }
+}
+</style>

src/Bundle/ChillCalendarBundle/Resources/public/vuejs/Calendar/api.js

@@ -0,0 +1,48 @@
+import {fetchResults} from 'ChillMainAssets/lib/api/apiMethods';
+import {datetimeToISO} from 'ChillMainAssets/chill/js/date';
+
+const whoami = () => {
+  const url = `/api/1.0/main/whoami.json`;
+  return fetch(url)
+    .then(response => {
+      if (response.ok) {
+        return response.json();
+      }
+      throw {
+        msg: 'Error while getting whoami.',
+        sta: response.status,
+        txt: response.statusText,
+        err: new Error(),
+        body: response.body
+      };
+    });
+};
+
+/**
+ *
+ * @param user
+ * @param Date start
+ * @param Date end
+ * @return Promise
+ */
+const fetchCalendarRangeForUser = (user, start, end) => {
+  const uri = `/api/1.0/calendar/calendar-range-available/${user.id}.json`;
+  const dateFrom = datetimeToISO(start);
+  const dateTo = datetimeToISO(end);
+
+  return fetchResults(uri, {dateFrom, dateTo});
+}
+
+const fetchCalendarRemoteForUser = (user, start, end) => {
+  const uri = `/api/1.0/calendar/proxy/calendar/by-user/${user.id}/events`;
+  const dateFrom = datetimeToISO(start);
+  const dateTo = datetimeToISO(end);
+
+  return fetchResults(uri, {dateFrom, dateTo});
+}
+
+export {
+  whoami,
+  fetchCalendarRangeForUser,
+  fetchCalendarRemoteForUser,
+};

src/Bundle/ChillCalendarBundle/Resources/public/vuejs/Calendar/const.js

@@ -0,0 +1,19 @@
+
+const COLORS = [ /* from https://colorbrewer2.org/#type=qualitative&scheme=Set3&n=12 */
+  '#8dd3c7',
+  '#ffffb3',
+  '#bebada',
+  '#fb8072',
+  '#80b1d3',
+  '#fdb462',
+  '#b3de69',
+  '#fccde5',
+  '#d9d9d9',
+  '#bc80bd',
+  '#ccebc5',
+  '#ffed6f'
+];
+
+export {
+  COLORS,
+};

src/Bundle/ChillCalendarBundle/Resources/public/vuejs/Calendar/i18n.js

@@ -1,19 +1,24 @@
-import { personMessages } from 'ChillPersonAssets/vuejs/_js/i18n'
-import { calendarUserSelectorMessages } from '../_components/CalendarUserSelector/js/i18n';
-import { activityMessages } from 'ChillActivityAssets/vuejs/Activity/i18n';
+import {personMessages} from 'ChillPersonAssets/vuejs/_js/i18n'
+import {calendarUserSelectorMessages} from '../_components/CalendarUserSelector/js/i18n';
+import {activityMessages} from 'ChillActivityAssets/vuejs/Activity/i18n';
 
 const appMessages = {
-   fr: {
-      choose_your_date: "Sélectionnez votre plage",
-      activity: {
-         add_persons: "Ajouter des personnes concernées",
-         bloc_persons: "Usagers",
-         bloc_persons_associated: "Usagers du parcours",
-         bloc_persons_not_associated: "Tiers non-pro.",
-         bloc_thirdparty: "Tiers professionnels",
-         bloc_users: "T(M)S",
-      }
-   }
+  fr: {
+    choose_your_date: "Sélectionnez votre plage",
+    activity: {
+      add_persons: "Ajouter des personnes concernées",
+      bloc_persons: "Usagers",
+      bloc_persons_associated: "Usagers du parcours",
+      bloc_persons_not_associated: "Tiers non-pro.",
+      bloc_thirdparty: "Tiers professionnels",
+      bloc_users: "T(M)S",
+    },
+    this_calendar_range_will_change_main_user: "Cette plage de disponibilité n'est pas celle de l'utilisateur principal. Si vous continuez, l'utilisateur principal sera adapté. Êtes-vous sûr·e ?",
+    will_change_main_user_for_me: "Vous ne pouvez pas écrire dans le calendrier d'un autre utilisateur. Voulez-vous être l'utilisateur principal de ce rendez-vous ?",
+    main_user_is_mandatory: "L'utilisateur principal est requis. Vous pouvez le modifier, mais pas le supprimer",
+    change_main_user_will_reset_event_data: "Modifier l'utilisateur principal nécessite de choisir une autre plage de disponibilité ou un autre horaire. Ces informations seront perdues. Êtes-vous sûr·e de vouloir continuer ?",
+    list_three_days: 'Liste 3 jours',
+  }
 }
 
 Object.assign(appMessages.fr, personMessages.fr);
@@ -21,5 +26,5 @@ Object.assign(appMessages.fr, calendarUserSelectorMessages.fr);
 Object.assign(appMessages.fr, activityMessages.fr);
 
 export {
-   appMessages
+  appMessages
 };

src/Bundle/ChillCalendarBundle/Resources/public/vuejs/Calendar/store.js

@@ -1,236 +0,0 @@
-import 'es6-promise/auto';
-import { createStore } from 'vuex';
-import { postLocation } from 'ChillActivityAssets/vuejs/Activity/api';
-import {
-    getLocations, getLocationTypeByDefaultFor,
-    getUserCurrentLocation
-} from "../../../../../ChillActivityBundle/Resources/public/vuejs/Activity/api";
-
-const debug = process.env.NODE_ENV !== 'production';
-
-const addIdToValue = (string, id) => {
-   let array = string ? string.split(',') : [];
-   array.push(id.toString());
-   let str = array.join();
-   return str;
-};
-
-const removeIdFromValue = (string, id) => {
-   let array = string.split(',');
-   array = array.filter(el => el !== id.toString());
-   let str = array.join();
-   return str;
-};
-
-/*
-* Assign missing keys for the ConcernedGroups component
-*/
-const mapEntity = (entity) => {
-   Object.assign(entity, {thirdParties: entity.professionals, users: entity.invites});
-   return entity;
-};
-
-const store = createStore({
-   strict: debug,
-   state: {
-     activity: mapEntity(window.entity), // activity is the calendar entity actually
-     currentEvent: null,
-     availableLocations: [],
-   },
-   getters: {
-      suggestedEntities(state) {
-         if (typeof(state.activity.accompanyingPeriod) === 'undefined') {
-           return [];
-         }
-         const allEntities = [
-           ...store.getters.suggestedPersons,
-           ...store.getters.suggestedRequestor,
-           ...store.getters.suggestedUser,
-           ...store.getters.suggestedResources
-         ];
-         const uniqueIds = [...new Set(allEntities.map(i => `${i.type}-${i.id}`))];
-         return Array.from(uniqueIds, id => allEntities.filter(r => `${r.type}-${r.id}` === id)[0]);
-       },
-       suggestedPersons(state) {
-         const existingPersonIds = state.activity.persons.map(p => p.id);
-         return state.activity.accompanyingPeriod.participations
-           .filter(p => p.endDate === null)
-           .map(p => p.person)
-           .filter(p => !existingPersonIds.includes(p.id))
-       },
-      suggestedRequestor(state) {
-        if (state.activity.accompanyingPeriod.requestor === null) {
-            return [];
-        }
-
-        const existingPersonIds = state.activity.persons.map(p => p.id);
-        const existingThirdPartyIds = state.activity.thirdParties.map(p => p.id);
-        return [state.activity.accompanyingPeriod.requestor]
-          .filter(r =>
-            (r.type === 'person' && !existingPersonIds.includes(r.id)) ||
-            (r.type === 'thirdparty' && !existingThirdPartyIds.includes(r.id))
-          );
-      },
-      suggestedUser(state) {
-          if (null === state.activity.users) {
-              return [];
-          }
-          const existingUserIds = state.activity.users.map(p => p.id);
-          return [state.activity.accompanyingPeriod.user]
-            .filter(
-              u => u !== null && !existingUserIds.includes(u.id)
-            );
-      },
-      suggestedResources(state) {
-        const resources = state.activity.accompanyingPeriod.resources;
-        const existingPersonIds = state.activity.persons.map(p => p.id);
-        const existingThirdPartyIds = state.activity.thirdParties.map(p => p.id);
-        return state.activity.accompanyingPeriod.resources
-          .map(r => r.resource)
-          .filter(r =>
-            (r.type === 'person' && !existingPersonIds.includes(r.id)) ||
-            (r.type === 'thirdparty' && !existingThirdPartyIds.includes(r.id))
-          );
-      }
-   },
-   mutations: {
-
-      // ConcernedGroups
-      addPersonsInvolved(state, payload) {
-         //console.log('### mutation addPersonsInvolved', payload.result.type);
-         switch (payload.result.type) {
-            case 'person':
-               state.activity.persons.push(payload.result);
-               break;
-            case 'thirdparty':
-               state.activity.thirdParties.push(payload.result);
-               break;
-            case 'user':
-               state.activity.users.push(payload.result);
-               break;
-         };
-      },
-      removePersonInvolved(state, payload) {
-         //console.log('### mutation removePersonInvolved', payload.type);
-         switch (payload.type) {
-            case 'person':
-               state.activity.persons = state.activity.persons.filter(person => person !== payload);
-               break;
-            case 'thirdparty':
-               state.activity.thirdParties = state.activity.thirdParties.filter(thirdparty => thirdparty !== payload);
-               break;
-            case 'user':
-               state.activity.users = state.activity.users.filter(user => user !== payload);
-               break;
-         };
-      },
-      // Calendar
-      setEvents(state, payload) {
-         // console.log(payload)
-         state.currentEvent = {start: payload.start, end: payload.end}
-      },
-      // Location
-      updateLocation(state, value) {
-         // console.log('### mutation: updateLocation', value);
-         state.activity.location = value;
-      }
-   },
-   actions: {
-      addPersonsInvolved({ commit }, payload) {
-         // console.log('### action addPersonsInvolved', payload.result.type);
-         switch (payload.result.type) {
-            case 'person':
-               let aPersons = document.getElementById("chill_activitybundle_activity_persons");
-               aPersons.value = addIdToValue(aPersons.value, payload.result.id);
-               break;
-            case 'thirdparty':
-               let aThirdParties = document.getElementById("chill_activitybundle_activity_professionals");
-               aThirdParties.value = addIdToValue(aThirdParties.value, payload.result.id);
-               break;
-            case 'user':
-               let aUsers = document.getElementById("chill_activitybundle_activity_invites");
-               aUsers.value = addIdToValue(aUsers.value, payload.result.id);
-               break;
-         };
-         commit('addPersonsInvolved', payload);
-      },
-      removePersonInvolved({ commit }, payload) {
-         //console.log('### action removePersonInvolved', payload);
-         switch (payload.type) {
-            case 'person':
-               let aPersons = document.getElementById("chill_activitybundle_activity_persons");
-               aPersons.value = removeIdFromValue(aPersons.value, payload.id);
-               break;
-            case 'thirdparty':
-               let aThirdParties = document.getElementById("chill_activitybundle_activity_professionals");
-               aThirdParties.value = removeIdFromValue(aThirdParties.value, payload.id);
-               break;
-            case 'user':
-               let aUsers = document.getElementById("chill_activitybundle_activity_invites");
-               aUsers.value = removeIdFromValue(aUsers.value, payload.id);
-               break;
-         };
-         commit('removePersonInvolved', payload);
-      },
-
-      // Calendar
-      createEvent({ commit }, payload) {
-         console.log('### action createEvent', payload);
-         let startDateInput = document.getElementById("chill_activitybundle_activity_startDate");
-         startDateInput.value = payload.startStr;
-         let endDateInput = document.getElementById("chill_activitybundle_activity_endDate");
-         endDateInput.value = payload.endStr;
-         let mainUserInput = document.getElementById("chill_activitybundle_activity_mainUser");
-         mainUserInput.value = payload.users.logged.id;
-         commit('setEvents', payload);
-      },
-      updateEvent({ commit }, payload) {
-         console.log('### action updateEvent', payload);
-         let startDateInput = document.getElementById("chill_activitybundle_activity_startDate");
-         startDateInput.value = payload.event.start.toISOString();
-         let endDateInput = document.getElementById("chill_activitybundle_activity_endDate");
-         endDateInput.value = payload.event.end.toISOString();
-         let calendarRangeInput = document.getElementById("chill_activitybundle_activity_calendarRange");
-         calendarRangeInput.value = Number(payload.event.extendedProps.calendarRangeId);
-         let mainUserInput = document.getElementById("chill_activitybundle_activity_mainUser");
-         mainUserInput.value = Number(payload.event.source.id);
-         commit('setEvents', payload);
-      },
-
-      // Location
-      updateLocation({ commit }, value) {
-         console.log('### action: updateLocation', value);
-         let hiddenLocation = document.getElementById("chill_activitybundle_activity_location");
-         if (value.onthefly) {
-             const body = {
-                 "type": "location",
-                 "name": value.name === '__AccompanyingCourseLocation__' ? null : value.name,
-                 "locationType": {
-                     "id": value.locationType.id,
-                     "type": "location-type"
-                 }
-             };
-             if (value.address.id) {
-                 Object.assign(body, {
-                     "address": {
-                         "id": value.address.id
-                     },
-                 })
-             }
-             postLocation(body)
-                 .then(
-                     location => hiddenLocation.value = location.id
-                 ).catch(
-                     err => {
-                         console.log(err.message);
-                     }
-                 );
-         } else {
-             hiddenLocation.value = value.id;
-         }
-         commit("updateLocation", value);
-      }
-  }
-});
-
-export default store;

src/Bundle/ChillCalendarBundle/Resources/public/vuejs/Calendar/store/actions.js

@@ -0,0 +1,218 @@
+import {toRaw} from "vue";
+import {
+  addIdToValue,
+  removeIdFromValue,
+  mapEntity
+} from './utils';
+import {
+  fetchCalendarRangeForUser,
+  fetchCalendarRemoteForUser,
+} from './../api';
+import {datetimeToISO} from 'ChillMainAssets/chill/js/date';
+
+/**
+ * This will store a unique key for each value, and prevent to launch the same
+ * request multiple times, when fetching user calendars.
+ *
+ * Actually, each time a user is added or removed, the methods "dateSet" is executed and this
+ * sparkle a request by user to get the calendar data. When the calendar data is fetched, it is
+ * immediatly added to the calendar which, in turn , launch the event dateSet and re-launch fetch
+ * queries which has not yet ended. Storing the queries already executed prevent this loop.
+ *
+ * @type {Set<String>}
+ */
+const fetchings = new Set();
+
+export default {
+  setCurrentDatesView({commit, dispatch}, {start, end}) {
+    commit('setCurrentDatesView', {start, end});
+
+    return dispatch('fetchCalendarEvents');
+  },
+  fetchCalendarEvents({state, getters, dispatch}) {
+    if (state.currentView.start === null && state.currentView.end === null) {
+      return Promise.resolve();
+    }
+
+    let promises = [];
+    for (const uid of state.currentView.users.keys()) {
+      let unique = `${uid}, ${state.currentView.start.toISOString()}, ${state.currentView.end.toISOString()}`;
+
+      if (fetchings.has(unique)) {
+        console.log('prevent from fetching for a user', unique);
+        continue;
+      }
+
+      fetchings.add(unique);
+
+      promises.push(
+        dispatch(
+          'fetchCalendarRangeForUser',
+          {user: state.usersData.get(uid).user, start: state.currentView.start, end: state.currentView.end}
+        )
+      );
+      promises.push(
+        dispatch(
+          'fetchCalendarRemotesForUser',
+          {user: state.usersData.get(uid).user, start: state.currentView.start, end: state.currentView.end}
+        )
+      );
+    }
+
+    return Promise.all(promises);
+  },
+  fetchCalendarRangeForUser({commit, getters}, {user, start, end}) {
+    if (!getters.isCalendarRangeLoadedForUser({user, start, end})) {
+      return fetchCalendarRangeForUser(user, start, end).then((ranges) => {
+        commit('addCalendarRangesForUser', {user, ranges, start, end});
+
+        return Promise.resolve();
+      });
+    }
+  },
+  fetchCalendarRemotesForUser({commit, getters}, {user, start, end}) {
+    if (!getters.isCalendarRemoteLoadedForUser({user, start, end})) {
+      return fetchCalendarRemoteForUser(user, start, end).then((remotes) => {
+        commit('addCalendarRemotesForUser', {user, remotes, start, end});
+
+        return Promise.resolve();
+      });
+    }
+  },
+  addPersonsInvolved({commit, dispatch}, payload) {
+    console.log('### action addPersonsInvolved', payload.result.type);
+    console.log('### action addPersonsInvolved payload result', payload.result);
+    switch (payload.result.type) {
+      case 'person':
+        let aPersons = document.getElementById("chill_activitybundle_activity_persons");
+        aPersons.value = addIdToValue(aPersons.value, payload.result.id);
+        break;
+      case 'thirdparty':
+        let aThirdParties = document.getElementById("chill_activitybundle_activity_professionals");
+        aThirdParties.value = addIdToValue(aThirdParties.value, payload.result.id);
+        break;
+      case 'user':
+        let aUsers = document.getElementById("chill_activitybundle_activity_users");
+        aUsers.value = addIdToValue(aUsers.value, payload.result.id);
+        commit('showUserOnCalendar', {user: payload.result, ranges: false, remotes: true});
+        dispatch('fetchCalendarEvents');
+        break;
+    }
+    ;
+    commit('addPersonsInvolved', payload);
+  },
+  removePersonInvolved({commit}, payload) {
+    //console.log('### action removePersonInvolved', payload);
+    switch (payload.type) {
+      case 'person':
+        let aPersons = document.getElementById("chill_activitybundle_activity_persons");
+        aPersons.value = removeIdFromValue(aPersons.value, payload.id);
+        break;
+      case 'thirdparty':
+        let aThirdParties = document.getElementById("chill_activitybundle_activity_professionals");
+        aThirdParties.value = removeIdFromValue(aThirdParties.value, payload.id);
+        break;
+      case 'user':
+        let aUsers = document.getElementById("chill_activitybundle_activity_users");
+        aUsers.value = removeIdFromValue(aUsers.value, payload.id);
+        break;
+    }
+    ;
+    commit('removePersonInvolved', payload);
+  },
+
+  // Calendar
+  /**
+   * set event startDate and endDate.
+   *
+   * if the mainUser is different from "me", it will replace the mainUser
+   *
+   * @param commit
+   * @param state
+   * @param getters
+   * @param start
+   * @param end
+   */
+  setEventTimes({commit, state, getters}, {start, end}) {
+    console.log('### action createEvent', {start, end});
+    let startDateInput = document.getElementById("chill_activitybundle_activity_startDate");
+    startDateInput.value = null !== start ? datetimeToISO(start) : '';
+    let endDateInput = document.getElementById("chill_activitybundle_activity_endDate");
+    endDateInput.value = null !== end ? datetimeToISO(end) : '';
+    let calendarRangeInput = document.getElementById("chill_activitybundle_activity_calendarRange");
+    calendarRangeInput.value = "";
+
+    if (getters.getMainUser === null || getters.getMainUser.id !== state.me.id) {
+      let mainUserInput = document.getElementById("chill_activitybundle_activity_mainUser");
+      mainUserInput.value = state.me.id;
+      commit('setMainUser', state.me);
+    }
+
+    commit('setEventTimes', {start, end});
+  },
+  associateCalendarToRange({state, commit, dispatch}, {range}) {
+    console.log('### action associateCAlendarToRange', range);
+    let startDateInput = document.getElementById("chill_activitybundle_activity_startDate");
+    startDateInput.value = null !== range ? datetimeToISO(range.start) : "";
+    let endDateInput = document.getElementById("chill_activitybundle_activity_endDate");
+    endDateInput.value = null !== range ? datetimeToISO(range.end) : "";
+    let calendarRangeInput = document.getElementById("chill_activitybundle_activity_calendarRange");
+    calendarRangeInput.value = null !== range ? Number(range.extendedProps.calendarRangeId) : "";
+
+    if (null !== range) {
+      const userId = range.extendedProps.userId;
+      if (state.activity.mainUser !== null && state.activity.mainUser.id !== userId) {
+        dispatch('setMainUser', state.usersData.get(userId).user);
+
+        // TODO: remove persons involved with this user
+      }
+    }
+
+    commit('associateCalendarToRange', {range});
+    return Promise.resolve();
+  },
+  setMainUser({commit, dispatch, state}, mainUser) {
+    console.log('setMainUser', mainUser);
+
+    let mainUserInput = document.getElementById("chill_activitybundle_activity_mainUser");
+    mainUserInput.value = Number(mainUser.id);
+
+    return dispatch('associateCalendarToRange', { range: null }).then(() => {
+      commit('setMainUser', mainUser);
+    });
+  },
+
+  // Location
+  updateLocation({commit}, value) {
+    console.log('### action: updateLocation', value);
+    let hiddenLocation = document.getElementById("chill_activitybundle_activity_location");
+    if (value.onthefly) {
+      const body = {
+        "type": "location",
+        "name": value.name === '__AccompanyingCourseLocation__' ? null : value.name,
+        "locationType": {
+          "id": value.locationType.id,
+          "type": "location-type"
+        }
+      };
+      if (value.address.id) {
+        Object.assign(body, {
+          "address": {
+            "id": value.address.id
+          },
+        })
+      }
+      postLocation(body)
+        .then(
+          location => hiddenLocation.value = location.id
+        ).catch(
+        err => {
+          console.log(err.message);
+        }
+      );
+    } else {
+      hiddenLocation.value = value.id;
+    }
+    commit("updateLocation", value);
+  }
+}

src/Bundle/ChillCalendarBundle/Resources/public/vuejs/Calendar/store/getters.js

@@ -0,0 +1,250 @@
+import {calendarRangeToFullCalendarEvent} from './utils';
+
+export default {
+  /**
+   * get the main user of the event/Calendar
+   *
+   * @param state
+   * @returns {*|null}
+   */
+  getMainUser(state) {
+    return state.activity.mainUser || null;
+  },
+  /**
+   * return the date of the event/Calendar
+   *
+   * @param state
+   * @returns {Date}
+   */
+  getEventDate(state) {
+    if (null === state.activity.start) {
+      return new Date();
+    }
+    throw 'transform date to object ?';
+  },
+  /**
+   * Compute the event sources to show on the FullCalendar
+   *
+   * @param state
+   * @param getters
+   * @returns {[]}
+   */
+  getEventSources(state, getters) {
+    let sources = [];
+
+    // current calendar
+    if (state.activity.startDate !== null && state.activity.endDate !== null) {
+      const s = {
+        id: 'current',
+        backgroundColor: '#3788d8',
+        borderColor: '#3788d8',
+        textColor: '#ffffff',
+        events: [
+          {
+            title: "Rendez-vous",
+            start: state.activity.startDate,
+            end: state.activity.endDate,
+            allDay: false,
+          }
+        ],
+        editable: state.activity.calendarRange === null,
+      };
+
+      sources.push(s);
+    }
+
+    for (const [userId, kinds] of state.currentView.users.entries()) {
+      if (!state.usersData.has(userId)) {
+        console.log('try to get events on a user which not exists', userId);
+        continue;
+      }
+
+      const userData = state.usersData.get(userId);
+
+      if (kinds.ranges && userData.calendarRanges.length > 0) {
+        const s = {
+          id: `ranges_${userId}`,
+          events: userData.calendarRanges.filter(r => state.activity.calendarRange === null || r.calendarRangeId !== state.activity.calendarRange.calendarRangeId),
+          color: userData.mainColor,
+          backgroundColor: 'white',
+          textColor: 'black',
+          editable: false,
+        };
+
+        sources.push(s);
+      }
+
+      if (kinds.remotes && userData.remotes.length > 0) {
+        const s = {
+          'id': `remote_${userId}`,
+          events: userData.remotes,
+          color: userData.mainColor,
+          textColor: 'black',
+          editable: false,
+        };
+
+        sources.push(s);
+      }
+    }
+
+    return sources;
+  },
+  getInitialDate(state) {
+    return state.activity.startDate;
+  },
+  getInviteForUser: (state) => (user) => {
+    return state.activity.invites.find(i => i.user.id === user.id);
+  },
+  /**
+   * get the user data for a specific user
+   *
+   * @param state
+   * @returns {function(*): unknown}
+   */
+  getUserData: (state) => (user) => {
+    return state.usersData.get(user.id);
+  },
+  getUserDataById: (state) => (userId) => {
+    return state.usersData.get(userId);
+  },
+  /**
+   * return true if the user has an entry in userData
+   *
+   * @param state
+   * @returns {function(*): boolean}
+   */
+  hasUserData: (state) => (user) => {
+    return state.usersData.has(user.id);
+  },
+  hasUserDataById: (state) => (userId) => {
+    return state.usersData.has(userId);
+  },
+  /**
+   * return true if there was a fetch query for event between this date (start and end),
+   * those date are included.
+   *
+   * @param state
+   * @param getters
+   * @returns {(function({user: *, start: *, end: *}): (boolean))|*}
+   */
+  isCalendarRangeLoadedForUser: (state, getters) => ({user, start, end}) => {
+    if (!getters.hasUserData(user)) {
+      return false;
+    }
+
+    for (let interval of getters.getUserData(user).calendarRangesLoaded) {
+      if (start >= interval.start && end <= interval.end) {
+        return true;
+      }
+    }
+
+    return false;
+  },
+  /**
+   * return true if there was a fetch query for event between this date (start and end),
+   * those date are included.
+   *
+   * @param state
+   * @param getters
+   * @returns {(function({user: *, start: *, end: *}): (boolean))|*}
+   */
+  isCalendarRemoteLoadedForUser: (state, getters) => ({user, start, end}) => {
+    if (!getters.hasUserData(user)) {
+      return false;
+    }
+
+    for (let interval of getters.getUserData(user).remotesLoaded) {
+      if (start >= interval.start && end <= interval.end) {
+        return true;
+      }
+    }
+
+    return false;
+  },
+  /**
+   * return true if the user ranges are shown on calendar
+   *
+   * @param state
+   * @returns boolean
+   */
+  isRangeShownOnCalendarForUser: (state) => (user) => {
+    const k = state.currentView.users.get(user.id);
+    if (typeof k === 'undefined') {
+      console.error('try to determinate if calendar range is shown and user is not in currentView');
+      return false;
+    }
+
+    return k.ranges;
+  },
+
+  /**
+   * return true if the user remote is shown on calendar
+   * @param state
+   * @returns boolean
+   */
+  isRemoteShownOnCalendarForUser: (state) => (user) => {
+    const k = state.currentView.users.get(user.id);
+    if (typeof k === 'undefined') {
+      console.error('try to determinate if calendar range is shown and user is not in currentView');
+      return false;
+    }
+
+    return k.remotes;
+  },
+
+
+  suggestedEntities(state, getters) {
+    if (typeof (state.activity.accompanyingPeriod) === 'undefined') {
+      return [];
+    }
+    const allEntities = [
+      ...getters.suggestedPersons,
+      ...getters.suggestedRequestor,
+      ...getters.suggestedUser,
+      ...getters.suggestedResources
+    ];
+    const uniqueIds = [...new Set(allEntities.map(i => `${i.type}-${i.id}`))];
+    return Array.from(uniqueIds, id => allEntities.filter(r => `${r.type}-${r.id}` === id)[0]);
+  },
+  suggestedPersons(state) {
+    const existingPersonIds = state.activity.persons.map(p => p.id);
+    return state.activity.accompanyingPeriod.participations
+      .filter(p => p.endDate === null)
+      .map(p => p.person)
+      .filter(p => !existingPersonIds.includes(p.id))
+  },
+  suggestedRequestor(state) {
+    if (state.activity.accompanyingPeriod.requestor === null) {
+      return [];
+    }
+
+    const existingPersonIds = state.activity.persons.map(p => p.id);
+    const existingThirdPartyIds = state.activity.thirdParties.map(p => p.id);
+    return [state.activity.accompanyingPeriod.requestor]
+      .filter(r =>
+        (r.type === 'person' && !existingPersonIds.includes(r.id)) ||
+        (r.type === 'thirdparty' && !existingThirdPartyIds.includes(r.id))
+      );
+  },
+  suggestedUser(state) {
+    if (null === state.activity.users) {
+      return [];
+    }
+    const existingUserIds = state.activity.users.map(p => p.id);
+    return [state.activity.accompanyingPeriod.user]
+      .filter(
+        u => u !== null && !existingUserIds.includes(u.id)
+      );
+  },
+  suggestedResources(state) {
+    const resources = state.activity.accompanyingPeriod.resources;
+    const existingPersonIds = state.activity.persons.map(p => p.id);
+    const existingThirdPartyIds = state.activity.thirdParties.map(p => p.id);
+    return state.activity.accompanyingPeriod.resources
+      .map(r => r.resource)
+      .filter(r =>
+        (r.type === 'person' && !existingPersonIds.includes(r.id)) ||
+        (r.type === 'thirdparty' && !existingThirdPartyIds.includes(r.id))
+      );
+  }
+}

src/Bundle/ChillCalendarBundle/Resources/public/vuejs/Calendar/store/index.js

@@ -0,0 +1,64 @@
+import 'es6-promise/auto';
+import { createStore } from 'vuex';
+import { toRaw } from 'vue';
+import { postLocation } from 'ChillActivityAssets/vuejs/Activity/api';
+import getters from './getters';
+import actions from './actions';
+import mutations from './mutations';
+import { mapEntity } from './utils';
+import { whoami } from '../api';
+
+import {
+    getLocations, getLocationTypeByDefaultFor,
+    getUserCurrentLocation
+} from "ChillActivityAssets/vuejs/Activity/api";
+
+const debug = process.env.NODE_ENV !== 'production';
+
+const store = createStore({
+   strict: debug,
+   state: {
+     activity: mapEntity(window.entity), // activity is the calendar entity actually
+     currentEvent: null,
+     availableLocations: [],
+     /**
+      * the current user
+      */
+     me: null,
+     /**
+      * store information about current view
+      */
+     currentView: {
+       start: null,
+       end: null,
+       users: new Map(),
+     },
+     /**
+      * store a list of existing event, to avoid storing them twice
+      */
+     existingEvents: new Set(),
+     /**
+      * store user data
+      */
+     usersData: new Map(),
+   },
+    getters,
+    mutations,
+    actions,
+});
+
+whoami().then(me => {
+    store.commit('setWhoAmiI', me);
+});
+
+if (null !== store.getters.getMainUser) {
+  store.commit('showUserOnCalendar', {ranges: true, remotes: true, user: store.getters.getMainUser});
+}
+
+for (let u of store.state.activity.users) {
+  store.commit('showUserOnCalendar', {ranges: false, remotes: false, user: u});
+}
+
+console.log('store', store);
+
+export default store;

src/Bundle/ChillCalendarBundle/Resources/public/vuejs/Calendar/store/mutations.js

@@ -0,0 +1,176 @@
+import {
+  createUserData,
+  calendarRangeToFullCalendarEvent,
+  remoteToFullCalendarEvent,
+} from './utils';
+
+export default {
+  setWhoAmiI(state, me) {
+    state.me = me;
+  },
+  setCurrentDatesView(state, {start, end}) {
+    state.currentView.start = start;
+    state.currentView.end = end;
+  },
+  showUserOnCalendar(state, {user, ranges, remotes}) {
+    if (!state.usersData.has(user.id)) {
+      state.usersData.set(user.id, createUserData(user, state.usersData.size));
+    }
+
+    const cur = state.currentView.users.get(user.id);
+
+    state.currentView.users.set(
+      user.id,
+      {
+        ranges: typeof ranges !== 'undefined' ? ranges : cur.ranges,
+        remotes: typeof remotes !== 'undefined' ? remotes : cur.remotes,
+      }
+    );
+  },
+  /**
+   * Set the event start and end to the given start and end,
+   * and remove eventually the calendar range.
+   *
+   * @param state
+   * @param Date start
+   * @param Date end
+   */
+  setEventTimes(state, {start, end}) {
+    state.activity.startDate = start;
+    state.activity.endDate = end;
+    state.activity.calendarRange = null;
+  },
+  /**
+   * Set the event's start and end from the calendar range data,
+   * and associate event to calendar range.
+   *
+   * @param state
+   * @param range
+   */
+  associateCalendarToRange(state, {range}) {
+    console.log('associateCalendarToRange', range);
+
+    if (null === range) {
+      state.activity.calendarRange = null;
+      state.activity.startDate = null;
+      state.activity.endDate = null;
+
+      return;
+    }
+
+    console.log('userId', range.extendedProps.userId);
+
+    const r = state.usersData.get(range.extendedProps.userId).calendarRanges
+      .find(r => r.calendarRangeId === range.extendedProps.calendarRangeId);
+
+    if (typeof r === 'undefined') {
+      throw Error('Could not find managed calendar range');
+    }
+
+    console.log('range found', r);
+
+    state.activity.startDate = range.start;
+    state.activity.endDate = range.end;
+    state.activity.calendarRange = r;
+
+    console.log('activity', state.activity);
+  },
+
+  setMainUser(state, user) {
+    state.activity.mainUser = user;
+  },
+
+  // ConcernedGroups
+  addPersonsInvolved(state, payload) {
+    //console.log('### mutation addPersonsInvolved', payload.result.type);
+    switch (payload.result.type) {
+      case 'person':
+        state.activity.persons.push(payload.result);
+        break;
+      case 'thirdparty':
+        state.activity.thirdParties.push(payload.result);
+        break;
+      case 'user':
+        state.activity.users.push(payload.result);
+        break;
+    }
+    ;
+  },
+  removePersonInvolved(state, payload) {
+    //console.log('### mutation removePersonInvolved', payload.type);
+    switch (payload.type) {
+      case 'person':
+        state.activity.persons = state.activity.persons.filter(person => person !== payload);
+        break;
+      case 'thirdparty':
+        state.activity.thirdParties = state.activity.thirdParties.filter(thirdparty => thirdparty !== payload);
+        break;
+      case 'user':
+        state.activity.users = state.activity.users.filter(user => user !== payload);
+        break;
+    }
+    ;
+  },
+  /**
+   * Add CalendarRange object for an user
+   *
+   * @param state
+   * @param user
+   * @param ranges
+   * @param start
+   * @param end
+   */
+  addCalendarRangesForUser(state, {user, ranges, start, end}) {
+    let userData;
+    if (state.usersData.has(user.id)) {
+      userData = state.usersData.get(user.id);
+    } else {
+      userData = createUserData(user, state.usersData.size);
+      state.usersData.set(user.id, userData);
+    }
+
+    const eventRanges = ranges
+      .filter(r => !state.existingEvents.has(`range_${r.id}`))
+      .map(r => {
+        // add to existing ids
+        state.existingEvents.add(`range_${r.id}`);
+        return r;
+      })
+      .map(r => calendarRangeToFullCalendarEvent(r));
+
+    userData.calendarRanges = userData.calendarRanges.concat(eventRanges);
+    userData.calendarRangesLoaded.push({start, end});
+  },
+  addCalendarRemotesForUser(state, {user, remotes, start, end}) {
+    let userData;
+    if (state.usersData.has(user.id)) {
+      userData = state.usersData.get(user.id);
+    } else {
+      userData = createUserData(user, state.usersData.size);
+      state.usersData.set(user.id, userData);
+    }
+
+    const eventRemotes = remotes
+      .filter(r => !state.existingEvents.has(`remote_${r.id}`))
+      .map(r => {
+        // add to existing ids
+        state.existingEvents.add(`remote_${r.id}`);
+        return r;
+      })
+      .map(r => remoteToFullCalendarEvent(r));
+
+    userData.remotes = userData.remotes.concat(eventRemotes);
+    userData.remotesLoaded.push({start, end});
+  },
+  /*
+// Calendar
+setEvents(state, payload) {
+    console.log(payload)
+    state.currentEvent = {start: payload.start, end: payload.end}
+},*/
+  // Location
+  updateLocation(state, value) {
+    console.log('### mutation: updateLocation', value);
+    state.activity.location = value;
+  }
+};

src/Bundle/ChillCalendarBundle/Resources/public/vuejs/Calendar/store/utils.js

@@ -0,0 +1,85 @@
+import {COLORS} from '../const';
+import {ISOToDatetime} from 'ChillMainAssets/chill/js/date';
+
+const addIdToValue = (string, id) => {
+  let array = string ? string.split(',') : [];
+  array.push(id.toString());
+  let str = array.join();
+  return str;
+};
+
+const removeIdFromValue = (string, id) => {
+  let array = string.split(',');
+  array = array.filter(el => el !== id.toString());
+  let str = array.join();
+  return str;
+};
+
+/*
+* Assign missing keys for the ConcernedGroups component
+*/
+const mapEntity = (entity) => {
+  let calendar =  { ...entity};
+  Object.assign(calendar, {thirdParties: entity.professionals});
+
+  if (entity.startDate !== null ) {
+    calendar.startDate = ISOToDatetime(entity.startDate.datetime);
+  }
+  if (entity.endDate !== null) {
+    calendar.endDate = ISOToDatetime(entity.endDate.datetime);
+  }
+
+  if (entity.calendarRange !== null) {
+    calendar.calendarRange.calendarRangeId = entity.calendarRange.id;
+    calendar.calendarRange.id = `range_${entity.calendarRange.id}`;
+  }
+
+  return calendar;
+};
+
+const createUserData = (user, colorIndex) => {
+  const colorId = colorIndex % COLORS.length;
+  console.log('colorId', colorId);
+  return {
+    user: user,
+    calendarRanges: [],
+    calendarRangesLoaded: [],
+    remotes: [],
+    remotesLoaded: [],
+    mainColor: COLORS[colorId],
+  }
+}
+
+const calendarRangeToFullCalendarEvent = (entity) => {
+  return {
+    id: `range_${entity.id}`,
+    title: "(" + entity.user.text + ")",
+    start: entity.startDate.datetime8601,
+    end: entity.endDate.datetime8601,
+    allDay: false,
+    userId: entity.user.id,
+    calendarRangeId: entity.id,
+    is: 'range',
+  };
+}
+
+const remoteToFullCalendarEvent = (entity) => {
+  console.log(entity);
+  return {
+    id: `range_${entity.id}`,
+    title: entity.title,
+    start: entity.startDate.datetime8601,
+    end: entity.endDate.datetime8601,
+    allDay: false,
+    is: 'remote',
+  };
+}
+
+export {
+  addIdToValue,
+  calendarRangeToFullCalendarEvent,
+  removeIdFromValue,
+  remoteToFullCalendarEvent,
+  mapEntity,
+  createUserData,
+};

src/Bundle/ChillCalendarBundle/Resources/public/vuejs/Invite/Answer.vue

@@ -0,0 +1,95 @@
+<template>
+  <div class="btn-group" role="group">
+    <button id="btnGroupDrop1" type="button" class="btn btn-misc dropdown-toggle" data-bs-toggle="dropdown" aria-expanded="false">
+      <template v-if="status === Statuses.PENDING">
+        <span class="fa fa-hourglass"></span> {{ $t('Give_an_answer')}}
+      </template>
+      <template v-else-if="status === Statuses.ACCEPTED">
+        <span class="fa fa-check"></span> {{ $t('Accepted')}}
+      </template>
+      <template v-else-if="status === Statuses.DECLINED">
+        <span class="fa fa-times"></span> {{ $t('Declined')}}
+      </template>
+      <template v-else-if="status === Statuses.TENTATIVELY_ACCEPTED">
+        <span class="fa fa-question"></span> {{ $t('Tentative')}}
+      </template>
+    </button>
+    <ul class="dropdown-menu" aria-labelledby="btnGroupDrop1">
+      <li v-if="status !== Statuses.ACCEPTED"><a class="dropdown-item" @click="changeStatus(Statuses.ACCEPTED)"><i class="fa fa-check" aria-hidden="true"></i> {{ $t('Accept') }}</a></li>
+      <li v-if="status !== Statuses.DECLINED"><a class="dropdown-item" @click="changeStatus(Statuses.DECLINED)"><i class="fa fa-times" aria-hidden="true"></i> {{ $t('Decline') }}</a></li>
+      <li v-if="status !== Statuses.TENTATIVELY_ACCEPTED"><a class="dropdown-item" @click="changeStatus(Statuses.TENTATIVELY_ACCEPTED)"><i class="fa fa-question"></i> {{ $t('Tentatively_accept') }}</a></li>
+      <li v-if="status !== Statuses.PENDING"><a class="dropdown-item" @click="changeStatus(Statuses.PENDING)"><i class="fa fa-hourglass-o"></i> {{ $t('Set_pending') }}</a></li>
+    </ul>
+  </div>
+
+</template>
+
+<script lang="ts">
+import {defineComponent, PropType} from 'vue';
+
+const  ACCEPTED = 'accepted';
+const  DECLINED = 'declined';
+const  PENDING = 'pending';
+const  TENTATIVELY_ACCEPTED = 'tentative';
+
+const i18n = {
+  messages: {
+    fr: {
+      "Give_an_answer": "Répondre",
+      "Accepted": "Accepté",
+      "Declined": "Refusé",
+      "Tentative": "Accepté provisoirement",
+      "Accept": "Accepter",
+      "Decline": "Refuser",
+      "Tentatively_accept": "Accepter provisoirement",
+      "Set_pending": "Ne pas répondre",
+    }
+  }
+};
+
+export default defineComponent({
+  name: "Answer",
+  i18n,
+  props: {
+    calendarId: { type: Number, required: true},
+    status: {type: String as PropType<"accepted" | "declined" | "pending" | "tentative">, required: true},
+  },
+  emits: {
+    statusChanged(payload: "accepted" | "declined" | "pending" | "tentative") {
+      return true;
+    },
+  },
+  data() {
+    return {
+      Statuses: {
+        ACCEPTED,
+        DECLINED,
+        PENDING,
+        TENTATIVELY_ACCEPTED,
+      },
+    }
+  },
+  methods: {
+    changeStatus: function (newStatus: "accepted" | "declined" | "pending" | "tentative") {
+      console.log('changeStatus', newStatus);
+      const url = `/api/1.0/calendar/calendar/${this.$props.calendarId}/answer/${newStatus}.json`;
+      window.fetch(url, {
+        method: 'POST',
+      }).then((r: Response) => {
+        if (!r.ok) {
+          console.error('could not confirm answer', newStatus);
+          return;
+        }
+        console.log('answer sent', newStatus);
+        this.$emit('statusChanged', newStatus);
+      });
+    },
+  }
+})
+
+</script>
+
+<style scoped>
+
+</style>
+

src/Bundle/ChillCalendarBundle/Resources/public/vuejs/_api/api.js

@@ -4,6 +4,7 @@
 * @returns {Promise} a promise containing all Calendar ranges objects
 */
 const fetchCalendarRanges = () => {
+  return Promise.resolve([]);
    const url = `/api/1.0/calendar/calendar-range-available.json`;
    return fetch(url)
       .then(response => {
@@ -12,17 +13,9 @@ const fetchCalendarRanges = () => {
       });
 };
 
-const fetchCalendarRangesByUser = (userId, startDate = null, endDate = null) => {
-   let url = '';
-
-   if (null !== startDate && null !== endDate) {
-      url = `/api/1.0/calendar/calendar-range-available.json?user=${userId}&start=${startDate}&end=${endDate}`;
-   } else if (null !== startDate) {
-      url = `/api/1.0/calendar/calendar-range-available.json?user=${userId}&start=${startDate}`;
-   } else {
-      url = `/api/1.0/calendar/calendar-range-available.json?user=${userId}`;
-   }
-
+const fetchCalendarRangesByUser = (userId) => {
+  return Promise.resolve([]);
+   const url = `/api/1.0/calendar/calendar-range-available.json?user=${userId}`;
    return fetch(url)
       .then(response => {
          if (response.ok) { return response.json(); }
@@ -36,6 +29,7 @@ const fetchCalendarRangesByUser = (userId, startDate = null, endDate = null) =>
 * @returns {Promise} a promise containing all Calendar objects
 */
 const fetchCalendar = (mainUserId) => {
+  return Promise.resolve([]);
    const url = `/api/1.0/calendar/calendar.json?main_user=${mainUserId}&item_per_page=1000`;
    return fetch(url)
       .then(response => {

src/Bundle/ChillCalendarBundle/Resources/views/Admin/index.html.twig

@@ -0,0 +1,13 @@
+{% extends "@ChillMain/Admin/layoutWithVerticalMenu.html.twig" %}
+
+{% block vertical_menu_content %}
+    {{ chill_menu('admin_calendar', {
+        'layout': '@ChillMain/Admin/menu_admin_section.html.twig',
+    }) }}
+{% endblock %}
+
+{% block layout_wvm_content %}
+    {% block admin_content %}<!-- block content empty -->
+        <h1>{{ 'Calendar configuration' |trans }}</h1>
+    {% endblock %}
+{% endblock  %}

src/Bundle/ChillCalendarBundle/Resources/views/Calendar/confirm_deleteByAccompanyingCourse.html.twig

@@ -9,8 +9,8 @@
         {
             'title'             : 'Remove calendar item'|trans,
             'confirm_question'  : 'Are you sure you want to remove the calendar item?'|trans,
-            'cancel_route'      : 'chill_calendar_calendar_list',
-            'cancel_parameters' : { 'accompanying_period_id' : accompanyingCourse.id, 'id' : calendar.id },
+            'cancel_route'      : 'chill_calendar_calendar_list_by_period',
+            'cancel_parameters' : { 'id' : accompanyingCourse.id },
             'form'              : delete_form
         } ) }}
 {% endblock %}

src/Bundle/ChillCalendarBundle/Resources/views/Calendar/edit.html.twig

@@ -3,9 +3,9 @@
 {{ form_start(form) }}
 {{ form_errors(form) }}
 
-{%- if form.mainUser is defined -%}
-    {{ form_row(form.mainUser) }}
-{% endif %}
+<div id="calendar"></div> {# <=== vue component #}
+
+<div id="mainUser"></div> {# <=== vue component: mainUser #}
 
 <h2 class="chill-red">{{ 'Concerned groups'|trans }}</h2>
 
@@ -26,6 +26,13 @@
 
 <h2 class="chill-red">{{ 'Calendar data'|trans }}</h2>
 
+<div id="schedule"></div>
+
+{%- if form.location is defined -%}
+    {{ form_row(form.location) }}
+    <div id="location"></div>
+{% endif %}
+
 {%- if form.startDate is defined -%}
     {{ form_row(form.startDate) }}
 {% endif %}
@@ -38,15 +45,16 @@
     {{ form_row(form.calendarRange) }}
 {% endif %}
 
-{%- if form.location is defined -%}
-    {{ form_row(form.location) }}
-    <div id="location"></div>
-{% endif %}
+<div id="fullCalendar"></div>
 
 {%- if form.comment is defined -%}
     {{ form_row(form.comment) }}
 {% endif %}
 
+{%- if form.privateComment is defined -%}
+    {{ form_row(form.privateComment) }}
+{% endif %}
+
 {%- if form.sendSMS is defined -%}
     {{ form_row(form.sendSMS) }}
 {% endif %}
@@ -55,7 +63,6 @@
     <div id="calendarControls"></div>
 {% endif %}
 
-<div id="fullCalendar"></div>
 
 <ul class="record_actions sticky-form-buttons">
   <li class="cancel">
@@ -64,7 +71,7 @@
       {%- if context == 'user' -%}
       href="{{ chill_return_path_or('chill_calendar_calendar_list', { 'user_id': user.id } )}}"
       {%- elseif context == 'accompanyingCourse' -%}
-      href="{{ chill_return_path_or('chill_calendar_calendar_list', { 'accompanying_period_id': accompanyingCourse.id } )}}"
+      href="{{ chill_return_path_or('chill_calendar_calendar_list_by_period', { 'id': accompanyingCourse.id } )}}"
       {%- endif -%}
       >
       {{ 'Cancel'|trans|chill_return_path_label }}
@@ -72,7 +79,7 @@
   </li>
   <li>
     <button class="btn btn-create" type="submit">
-      {{ 'Update'|trans }}
+      {{ 'Save'|trans }}
     </button>
   </li>
 </ul>

src/Bundle/ChillCalendarBundle/Resources/views/Calendar/editByAccompanyingCourse.html.twig

@@ -7,7 +7,6 @@
 {% block content %}
 <div class="calendar-edit">
 
-    <div id="calendar"></div> {# <=== vue component #}
     {% include 'ChillCalendarBundle:Calendar:edit.html.twig' with {'context': 'accompanyingCourse'} %}
 
 </div>
@@ -16,10 +15,6 @@
 {% block js %}
     {{ parent() }}
     <script type="text/javascript">
-        window.addEventListener('DOMContentLoaded', function (e) {
-            chill.displayAlertWhenLeavingModifiedForm('form[name="{{ form.vars.form.vars.name }}"]',
-            '{{ "You are going to leave a page with unsubmitted data. Are you sure you want to leave ?"|trans }}');
-        });
         window.entity = {{ entity_json|json_encode|raw }};
         window.startDate = {{ entity.startDate|date('Y-m-d H:i:s')|json_encode|raw }};
         window.endDate = {{ entity.endDate|date('Y-m-d H:i:s')|json_encode|raw }};

src/Bundle/ChillCalendarBundle/Resources/views/Calendar/listByAccompanyingCourse.html.twig

@@ -7,11 +7,22 @@
 {% set user_id = null %}
 {% set accompanying_course_id = accompanyingCourse.id %}
 
+{% block js %}
+    {{ parent() }}
+    {{ encore_entry_script_tags('mod_answer') }}
+{% endblock %}
+
+{% block css %}
+    {{ parent() }}
+    {{ encore_entry_link_tags('mod_answer') }}
+{% endblock %}
+
 {% block content %}
 
 <h1>{{ 'Calendar list' |trans }}</h1>
+    {{ filterOrder|chill_render_filter_order_helper }}
 
-{% if calendarItems|length == 0 %}
+    {% if calendarItems|length == 0 %}
     <p class="chill-no-data-statement">
         {{ "There is no calendar items."|trans }}
         <a href="{{ path('chill_calendar_calendar_new', {'user_id': user_id, 'accompanying_period_id': accompanying_course_id}) }}" class="btn btn-create button-small"></a>
@@ -25,63 +36,35 @@
             <div class="item-bloc">
                 <div class="item-row main">
                     <div class="item-col">
+                        <div class="wrap-header">
+                            <div class="wl-row">
+                                <div class="wl-col title">
+                                    {% if calendar.endDate.diff(calendar.startDate).days >= 1 %}
+                                        <p class="date-label">{{ calendar.startDate|format_datetime('short', 'short') }} - {{ calendar.endDate|format_datetime('short', 'short') }}</p>
+                                    {% else %}
+                                        <p class="date-label">{{ calendar.startDate|format_datetime('short', 'short') }} - {{ calendar.endDate|format_datetime('none', 'short') }}</p>
+                                    {% endif %}
 
-                        {% if calendar.startDate and calendar.endDate %}
-                            {% if calendar.endDate.diff(calendar.startDate).days >= 1 %}
-                                <h3>{{ "From the day"|trans }} {{ calendar.startDate|format_datetime('medium', 'short') }} </h3>
-                                <h3>{{ "to the day"|trans }} {{ calendar.endDate|format_datetime('medium', 'short') }}</h3>
-                            {% else %}
-                                <h3>{{ calendar.startDate|format_date('full') }} </h3>
-                                <h3>{{ calendar.startDate|format_datetime('none', 'short', locale='fr') }} - {{ calendar.endDate|format_datetime('none', 'short', locale='fr') }}</h3>
+                                    <div class="duration">
+                                        <p>
+                                            <i class="fa fa-fw fa-hourglass-end"></i>
+                                            {{ calendar.duration|date('%H:%I')}}
+                                        </p>
+                                    </div>
 
-                                <div class="duration">
-                                    <p>
-                                        <i class="fa fa-fw fa-hourglass-end"></i>
-                                        {{ calendar.endDate.diff(calendar.startDate)|date("%H:%M")}}
-                                    </p>
                                 </div>
-                            {% endif %}
+                            </div>
+                        </div>
 
-                        {% endif %}
+                        <div class="item-col">
+                            <ul class="list-content">
+                                {% if calendar.mainUser is not empty %}
+                                    <span class="badge-user">{{ calendar.mainUser|chill_entity_render_box }}</span>
+                                {% endif %}
+                            </ul>
+                        </div>
 
                     </div>
-                    <div class="item-col">
-                        <ul class="list-content">
-                            {% if calendar.user %}
-                            <li>
-                                <b>{{ 'by'|trans }}{{ calendar.user.usernameCanonical }}</b>
-                            </li>
-                            {% endif %}
-
-                            {% if calendar.mainUser is not empty %}
-                            <li>
-                                <b>{{ 'main user concerned'|trans }}: {{ calendar.mainUser.usernameCanonical }}</b>
-                            </li>
-                            {% endif %}
-
-                        </ul>
-                        <ul class="record_actions">
-                            <li>
-                                <a href="{{ path('chill_calendar_calendar_show', { 'id': calendar.id, 'user_id': user_id, 'accompanying_period_id': accompanying_course_id }) }}" class="btn btn-show "></a>
-                            </li>
-                            {# TOOD
-                            {% if is_granted('CHILL_ACTIVITY_UPDATE', calendar) %}
-                            #}
-                            <li>
-                                <a href="{{ path('chill_calendar_calendar_edit', { 'id': calendar.id, 'user_id': user_id, 'accompanying_period_id': accompanying_course_id }) }}" class="btn btn-update "></a>
-                            </li>
-                            {# TOOD
-                            {% endif %}
-                            {% if is_granted('CHILL_ACTIVITY_DELETE', calendar) %}
-                            #}
-                            <li>
-                                <a href="{{ path('chill_calendar_calendar_delete', { 'id': calendar.id, 'user_id' : user_id, 'accompanying_period_id': accompanying_course_id } ) }}" class="btn btn-delete "></a>
-                            </li>
-                            {#
-                            {% endif %}
-                            #}
-                        </ul>
-                    </div>
                 </div>
 
                 {%
@@ -90,11 +73,11 @@
                     or calendar.thirdParties|length > 0
                     or calendar.users|length > 0
                 %}
-                <div class="item-row details">
+                <div class="item-row details separator">
                     <div class="item-col">
                         {% include 'ChillActivityBundle:Activity:concernedGroups.html.twig' with {
-                            'context': accompanyingCourse,
-                            'render': 'row',
+                            'context': 'calendar_accompanyingCourse',
+                            'render': 'wrap-list',
                             'entity': calendar
                         } %}
                     </div>
@@ -107,6 +90,37 @@
                 </div>
                 {% endif %}
 
+                <div class="item-row separator">
+                    <ul class="record_actions">
+                        {% if (calendar.isInvited(app.user)) %}
+                            {% set invite = calendar.inviteForUser(app.user) %}
+                            <li>
+                                <div invite-answer data-status="{{ invite.status|e('html_attr') }}" data-calendar-id="{{ calendar.id|e('html_attr') }}"></div>
+                            </li>
+                        {% endif %}
+                        <li>
+                            <a href="{{ path('chill_calendar_calendar_show', { 'id': calendar.id, 'user_id': user_id, 'accompanying_period_id': accompanying_course_id }) }}" class="btn btn-show "></a>
+                        </li>
+                        {# TOOD
+                            {% if is_granted('CHILL_ACTIVITY_UPDATE', calendar) %}
+                        #}
+                        <li>
+                            <a href="{{ path('chill_calendar_calendar_edit', { 'id': calendar.id, 'user_id': user_id, 'accompanying_period_id': accompanying_course_id }) }}" class="btn btn-update "></a>
+                        </li>
+                        {# TOOD
+                            {% endif %}
+                            {% if is_granted('CHILL_ACTIVITY_DELETE', calendar) %}
+                        #}
+                        <li>
+                            <a href="{{ path('chill_calendar_calendar_delete', { 'id': calendar.id, 'user_id' : user_id, 'accompanying_period_id': accompanying_course_id } ) }}" class="btn btn-delete "></a>
+                        </li>
+                        {#
+                        {% endif %}
+                        #}
+                    </ul>
+
+                </div>
+
             </div>
         {% endfor %}
 
@@ -118,10 +132,17 @@
 {% endif %}
 
 
-<ul class="record_actions">
+<ul class="record_actions sticky-form-buttons">
+    {% if accompanyingCourse.user is not same as(null) %}
+        <li>
+            <a href="{{ path('chill_calendar_calendar_new', {'user_id': user_id, 'accompanying_period_id': accompanying_course_id, 'mainUser': accompanyingCourse.user.id }) }}" class="btn btn-create">
+                {{ 'chill_calendar.Create for referrer'|trans }}
+            </a>
+        </li>
+    {% endif %}
     <li>
         <a href="{{ path('chill_calendar_calendar_new', {'user_id': user_id, 'accompanying_period_id': accompanying_course_id}) }}" class="btn btn-create">
-            {{ 'Add a new calendar' | trans }}
+            {{ 'Create'|trans }}
         </a>
     </li>
 </ul>

src/Bundle/ChillCalendarBundle/Resources/views/Calendar/new.html.twig

@@ -3,12 +3,16 @@
 {{ form_start(form) }}
 {{ form_errors(form) }}
 
+<div id="calendar"></div> {# <=== vue component #}
+
+<div id="mainUser"></div> {# <=== vue component: mainUser #}
+
+<h2 class="chill-red">{{ 'Concerned groups'|trans }}</h2>
+
 {%- if form.mainUser is defined -%}
     {{ form_row(form.mainUser) }}
 {% endif %}
 
-<h2 class="chill-red">{{ 'Concerned groups'|trans }}</h2>
-
 {%- if form.persons is defined -%}
     {{ form_widget(form.persons) }}
 {% endif %}
@@ -26,6 +30,13 @@
 
 <h2 class="chill-red">{{ 'Calendar data'|trans }}</h2>
 
+<div id="schedule"></div>
+
+{%- if form.location is defined -%}
+    {{ form_row(form.location) }}
+    <div id="location"></div>
+{% endif %}
+
 {%- if form.startDate is defined -%}
     {{ form_row(form.startDate) }}
 {% endif %}
@@ -34,38 +45,42 @@
     {{ form_row(form.endDate) }}
 {% endif %}
 
-{%- if form.location is defined -%}
-    {{ form_row(form.location) }}
-    <div id="location"></div>
+{%- if form.calendarRange is defined -%}
+    {{ form_row(form.calendarRange) }}
 {% endif %}
 
+<div id="fullCalendar"></div>
+
 {%- if form.comment is defined -%}
     {{ form_row(form.comment) }}
 {% endif %}
 
+{%- if form.privateComment is defined -%}
+    {{ form_row(form.privateComment) }}
+{% endif %}
+
 {%- if form.sendSMS is defined -%}
     {{ form_row(form.sendSMS) }}
 {% endif %}
 
-<div id="fullCalendar"></div>
 
 <ul class="record_actions sticky-form-buttons">
-  <li class="cancel">
-    <a
-      class="btn btn-cancel"
-      {%- if context == 'person' -%}
-      href="{{ chill_return_path_or('chill_calendar_calendar_list', { 'person_id': person.id } )}}"
-      {%- else -%}
-      href="{{ chill_return_path_or('chill_calendar_calendar_list', { 'accompanying_period_id': accompanyingCourse.id } )}}"
-      {%- endif -%}
-      >
-      {{ 'Cancel'|trans|chill_return_path_label }}
-    </a>
-  </li>
-  <li>
-    <button class="btn btn-create" type="submit">
-      {{ 'Create'|trans }}
-    </button>
-  </li>
+    <li class="cancel">
+        <a
+        class="btn btn-cancel"
+        {%- if context == 'person' -%}
+        href="{{ chill_return_path_or('chill_calendar_calendar_list', { 'person_id': person.id } )}}"
+        {%- else -%}
+        href="{{ chill_return_path_or('chill_calendar_calendar_list_by_period', { 'id': accompanyingCourse.id } )}}"
+        {%- endif -%}
+        >
+        {{ 'Cancel'|trans|chill_return_path_label }}
+        </a>
+    </li>
+    <li>
+        <button class="btn btn-create" type="submit">
+        {{ 'Create'|trans }}
+        </button>
+    </li>
 </ul>
 {{ form_end(form) }}

src/Bundle/ChillCalendarBundle/Resources/views/Calendar/newByAccompanyingCourse.html.twig

@@ -15,11 +15,8 @@
 
 {% block js %}
     {{ parent() }}
+    {{ encore_entry_script_tags('mod_pickentity_type') }}
     <script type="text/javascript">
-        window.addEventListener('DOMContentLoaded', function (e) {
-            chill.displayAlertWhenLeavingUnsubmittedForm('form[name="{{ form.vars.form.vars.name }}"]',
-            '{{ "You are going to leave a page with unsubmitted data. Are you sure you want to leave ?"|trans }}');
-        });
         window.entity = {{ entity_json|json_encode|raw }};
     </script>
     {{ encore_entry_script_tags('vue_calendar') }}
@@ -28,6 +25,7 @@
 {% block css %}
     {{ parent() }}
     {{ encore_entry_link_tags('vue_calendar') }}
+    {{ encore_entry_link_tags('mod_pickentity_type') }}
 {% endblock %}
 
 {% block block_post_menu %}

src/Bundle/ChillCalendarBundle/Resources/views/CalendarShortMessage/short_message.txt.twig

@@ -0,0 +1 @@
+Votre travailleur social {{ calendar.mainUser.label }} vous rencontrera le {{ calendar.startDate|format_date('short', locale='fr') }} à {{ calendar.startDate|format_time('short', locale='fr') }} - LIEU.{% if calendar.mainUser.mainLocation is not null and calendar.mainUser.mainLocation.phonenumber1 is not null %} En cas d'indisponibilité, appelez-nous au {{ calendar.mainUser.mainLocation.phonenumber1|chill_format_phonenumber }}.{% endif %}

src/Bundle/ChillCalendarBundle/Resources/views/CalendarShortMessage/short_message_canceled.twig

@@ -0,0 +1 @@
+Votre RDV avec votre travailleur social {{ calendar.mainUser.label }} prévu le {{ calendar.startDate|format_date('short', locale='fr') }} à {{ calendar.startDate|format_time('short', locale='fr') }} est annulé. {% if calendar.mainUser.mainLocation is not null and calendar.mainUser.mainLocation.phonenumber1 is not null %} En cas de question, appelez-nous au {{ calendar.mainUser.mainLocation.phonenumber1|chill_format_phonenumber }}.{% endif %}

src/Bundle/ChillCalendarBundle/Resources/views/CancelReason/edit.html.twig

@@ -0,0 +1,11 @@
+{% extends '@ChillMain/CRUD/Admin/index.html.twig' %}
+
+{% block title %}
+    {% include('@ChillMain/CRUD/_edit_title.html.twig') %}
+{% endblock %}
+
+{% block admin_content %}
+    {% embed '@ChillMain/CRUD/_edit_content.html.twig' %}
+        {% block content_form_actions_save_and_show %}{% endblock %}
+    {% endembed %}
+{% endblock admin_content %}

src/Bundle/ChillCalendarBundle/Resources/views/CancelReason/index.html.twig

@@ -0,0 +1,43 @@
+{% extends '@ChillMain/CRUD/Admin/index.html.twig' %}
+
+{% block admin_content %}
+    {% embed '@ChillMain/CRUD/_index.html.twig' %}
+        {% block table_entities_thead_tr %}
+            <th>{{ 'Id'|trans }}</th>
+            <th>{{ 'Name'|trans }}</th>
+            <th>{{ 'canceledBy'|trans }}</th>
+            <th>{{ 'active'|trans }}</th>
+            <th>&nbsp;</th>
+        {% endblock %}
+
+        {% block table_entities_tbody %}
+            {% for entity in entities %}
+                <tr>
+                    <td>{{ entity.id }}</td>
+                    <td>{{ entity.name|localize_translatable_string }}</td>
+                    <td>{{ entity.canceledBy }}</td>
+                    <td style="text-align:center;">
+						{%- if entity.active -%}
+							<i class="fa fa-check-square-o"></i>
+						{%- else -%}
+							<i class="fa fa-square-o"></i>
+						{%- endif -%}
+					</td>
+                    <td>
+                        <ul class="record_actions">
+                            <li>
+                                <a href="{{ chill_path_add_return_path('chill_crud_calendar_cancel-reason_edit', { 'id': entity.id }) }}" class="btn btn-edit"></a>
+                            </li>
+                        </ul>
+                    </td>
+                </tr>
+             {% endfor %}
+        {% endblock %}
+
+        {% block actions_before %}
+            <li class='cancel'>
+                <a href="{{ path('chill_main_admin_central') }}" class="btn btn-cancel">{{'Back to the admin'|trans}}</a>
+            </li>
+        {% endblock %}
+    {% endembed %}
+{% endblock %}

src/Bundle/ChillCalendarBundle/Resources/views/CancelReason/new.html.twig

@@ -0,0 +1,12 @@
+{% extends '@ChillMain/CRUD/Admin/index.html.twig' %}
+
+{% block title %}
+    {% include('@ChillMain/CRUD/_new_title.html.twig') %}
+{% endblock %}
+
+{% block admin_content %}
+    {% embed '@ChillMain/CRUD/_new_content.html.twig' %}
+        {% block content_form_actions_save_and_show %}{% endblock %}
+    {% endembed %}
+{% endblock admin_content %}
+

src/Bundle/ChillCalendarBundle/Resources/views/MSGraph/calendar_event_body.html.twig

@@ -0,0 +1,16 @@
+Ce rendez-vous a été généré automatiquement par Chill.
+
+Pour modifier ou supprimer ce rendez-vous, utilisez l’adresse suivante:
+
+{{ absolute_url(path('chill_calendar_calendar_edit', {'id': calendar.id, '_locale': 'fr'})) }}
+
+{{ calendar.comment.comment|nl2br }}
+
+Usagers et tiers concernés:
+
+{% for p in calendar.persons %}
+- {{ p|chill_entity_render_string }}
+{%- endfor -%}
+{% for t in calendar.professionals %}
+- {{ t|chill_entity_render_string }}
+{% endfor %}

src/Bundle/ChillCalendarBundle/Resources/views/_invite.html.twig

@@ -0,0 +1,14 @@
+{% macro invite_span(invite) %}
+    {% if invite.status == 'accepted' %}
+        {% set fa = 'check' %}
+    {% elseif invite.status == 'declined' %}
+        {% set fa = 'times' %}
+    {% elseif invite.status == 'pending' %}
+        {% set fa = 'hourglass' %}
+    {% elseif invite.status == 'tentative' %}
+        {% set fa = 'question' %}
+    {% else %}
+        {% set fa = invite.status %}
+    {% endif %}
+    <i class="fa fa-{{ fa }}" title="{{ ('invite.'~invite.status)|trans|e('html_attr') }}"></i>
+{% endmacro %}

src/Bundle/ChillCalendarBundle/Security/Voter/CalendarVoter.php

@@ -1,5 +1,14 @@
 <?php
 
+/**
+ * Chill is a software for social workers
+ *
+ * For the full copyright and license information, please view
+ * the LICENSE file that was distributed with this source code.
+ */
+
+declare(strict_types=1);
+
 namespace Chill\CalendarBundle\Security\Voter;
 
 use Chill\MainBundle\Security\Authorization\AbstractChillVoter;
@@ -7,8 +16,8 @@ use Chill\MainBundle\Security\Authorization\VoterHelperFactoryInterface;
 use Chill\MainBundle\Security\Authorization\VoterHelperInterface;
 use Chill\MainBundle\Security\ProvideRoleHierarchyInterface;
 use Chill\PersonBundle\Entity\AccompanyingPeriod;
-use Chill\PersonBundle\Entity\Person;
 use Chill\PersonBundle\Security\Authorization\AccompanyingPeriodVoter;
+use LogicException;
 use Symfony\Component\Security\Core\Authentication\Token\TokenInterface;
 use Symfony\Component\Security\Core\Security;
 
@@ -16,12 +25,10 @@ class CalendarVoter extends AbstractChillVoter implements ProvideRoleHierarchyIn
 {
     public const SEE = 'CHILL_CALENDAR_CALENDAR_SEE';
 
-
     private Security $security;
 
     private VoterHelperInterface $voterHelper;
 
-
     public function __construct(
         Security $security,
         VoterHelperFactoryInterface $voterHelperFactory
@@ -33,11 +40,6 @@ class CalendarVoter extends AbstractChillVoter implements ProvideRoleHierarchyIn
             ->build();
     }
 
-    public function getRolesWithHierarchy(): array
-    {
-        return ['Calendar' => $this->getRoles()];
-    }
-
     public function getRoles(): array
     {
         return [
@@ -45,6 +47,11 @@ class CalendarVoter extends AbstractChillVoter implements ProvideRoleHierarchyIn
         ];
     }
 
+    public function getRolesWithHierarchy(): array
+    {
+        return ['Calendar' => $this->getRoles()];
+    }
+
     public function getRolesWithoutScope(): array
     {
         return [];
@@ -60,20 +67,18 @@ class CalendarVoter extends AbstractChillVoter implements ProvideRoleHierarchyIn
         if ($subject instanceof AccompanyingPeriod) {
             switch ($attribute) {
                 case self::SEE:
-
                     if ($subject->getStep() === AccompanyingPeriod::STEP_DRAFT) {
                         return false;
                     }
 
                     // we first check here that the user has read access to the period
                     return $this->security->isGranted(AccompanyingPeriodVoter::SEE, $subject);
+
                 default:
-                    throw new \LogicException('subject not implemented');
+                    throw new LogicException('subject not implemented');
             }
         }
 
-        throw new \LogicException('attribute not implemented');
+        throw new LogicException('attribute not implemented');
     }
-
-
 }

src/Bundle/ChillCalendarBundle/Security/Voter/InviteVoter.php

@@ -0,0 +1,35 @@
+<?php
+
+/**
+ * Chill is a software for social workers
+ *
+ * For the full copyright and license information, please view
+ * the LICENSE file that was distributed with this source code.
+ */
+
+declare(strict_types=1);
+
+namespace Chill\CalendarBundle\Security\Voter;
+
+use Chill\CalendarBundle\Entity\Invite;
+use Symfony\Component\Security\Core\Authentication\Token\TokenInterface;
+use Symfony\Component\Security\Core\Authorization\Voter\Voter;
+
+class InviteVoter extends Voter
+{
+    public const ANSWER = 'CHILL_CALENDAR_INVITE_ANSWER';
+
+    protected function supports($attribute, $subject): bool
+    {
+        return $subject instanceof Invite && self::ANSWER === $attribute;
+    }
+
+    /**
+     * @param string $attribute
+     * @param Invite $subject
+     */
+    protected function voteOnAttribute($attribute, $subject, TokenInterface $token): bool
+    {
+        return $token->getUser() === $subject->getUser();
+    }
+}

src/Bundle/ChillCalendarBundle/Service/ShortMessageNotification/BulkCalendarShortMessageSender.php

@@ -0,0 +1,64 @@
+<?php
+
+/**
+ * Chill is a software for social workers
+ *
+ * For the full copyright and license information, please view
+ * the LICENSE file that was distributed with this source code.
+ */
+
+declare(strict_types=1);
+
+namespace Chill\CalendarBundle\Service\ShortMessageNotification;
+
+use Chill\CalendarBundle\Entity\Calendar;
+use DateTimeImmutable;
+use Doctrine\ORM\EntityManagerInterface;
+use Psr\Log\LoggerInterface;
+use Symfony\Component\Messenger\MessageBusInterface;
+
+class BulkCalendarShortMessageSender
+{
+    private EntityManagerInterface $em;
+
+    private LoggerInterface $logger;
+
+    private MessageBusInterface $messageBus;
+
+    private ShortMessageForCalendarBuilderInterface $messageForCalendarBuilder;
+
+    private CalendarForShortMessageProvider $provider;
+
+    public function __construct(CalendarForShortMessageProvider $provider, EntityManagerInterface $em, LoggerInterface $logger, MessageBusInterface $messageBus, ShortMessageForCalendarBuilderInterface $messageForCalendarBuilder)
+    {
+        $this->provider = $provider;
+        $this->em = $em;
+        $this->logger = $logger;
+        $this->messageBus = $messageBus;
+        $this->messageForCalendarBuilder = $messageForCalendarBuilder;
+    }
+
+    public function sendBulkMessageToEligibleCalendars()
+    {
+        $countCalendars = 0;
+        $countSms = 0;
+
+        foreach ($this->provider->getCalendars(new DateTimeImmutable('now')) as $calendar) {
+            $smses = $this->messageForCalendarBuilder->buildMessageForCalendar($calendar);
+
+            foreach ($smses as $sms) {
+                $this->messageBus->dispatch($sms);
+                ++$countSms;
+            }
+
+            $this->em
+                ->createQuery('UPDATE ' . Calendar::class . ' c SET c.smsStatus = :smsStatus WHERE c.id = :id')
+                ->setParameters(['smsStatus' => Calendar::SMS_SENT, 'id' => $calendar->getId()])
+                ->execute();
+            ++$countCalendars;
+            $this->em->refresh($calendar);
+        }
+
+        $this->logger->info(__CLASS__ . 'a bulk of messages was sent', ['count_calendars' => $countCalendars, 'count_sms' => $countSms]);
+    }
+}

src/Bundle/ChillCalendarBundle/Service/ShortMessageNotification/CalendarForShortMessageProvider.php

@@ -0,0 +1,69 @@
+<?php
+
+/**
+ * Chill is a software for social workers
+ *
+ * For the full copyright and license information, please view
+ * the LICENSE file that was distributed with this source code.
+ */
+
+declare(strict_types=1);
+
+namespace Chill\CalendarBundle\Service\ShortMessageNotification;
+
+use Chill\CalendarBundle\Entity\Calendar;
+use Chill\CalendarBundle\Repository\CalendarRepository;
+use DateTimeImmutable;
+use Doctrine\ORM\EntityManagerInterface;
+use function count;
+
+class CalendarForShortMessageProvider
+{
+    private CalendarRepository $calendarRepository;
+
+    private EntityManagerInterface $em;
+
+    private RangeGeneratorInterface $rangeGenerator;
+
+    public function __construct(
+        CalendarRepository $calendarRepository,
+        EntityManagerInterface $em,
+        RangeGeneratorInterface $rangeGenerator
+    ) {
+        $this->calendarRepository = $calendarRepository;
+        $this->em = $em;
+        $this->rangeGenerator = $rangeGenerator;
+    }
+
+    /**
+     * Generate calendars instance.
+     *
+     * Warning: this method takes care of clearing the EntityManager at regular interval
+     *
+     * @return iterable|Calendar[]
+     */
+    public function getCalendars(DateTimeImmutable $at): iterable
+    {
+        ['startDate' => $startDate, 'endDate' => $endDate] = $this->rangeGenerator
+            ->generateRange($at);
+
+        $offset = 0;
+        $batchSize = 10;
+
+        $calendars = $this->calendarRepository
+            ->findByNotificationAvailable($startDate, $endDate, $batchSize, $offset);
+
+        do {
+            foreach ($calendars as $calendar) {
+                ++$offset;
+
+                yield $calendar;
+            }
+
+            $this->em->clear();
+
+            $calendars = $this->calendarRepository
+                ->findByNotificationAvailable($startDate, $endDate, $batchSize, $offset);
+        } while (count($calendars) === $batchSize);
+    }
+}

src/Bundle/ChillCalendarBundle/Service/ShortMessageNotification/DefaultRangeGenerator.php

@@ -0,0 +1,68 @@
+<?php
+
+/**
+ * Chill is a software for social workers
+ *
+ * For the full copyright and license information, please view
+ * the LICENSE file that was distributed with this source code.
+ */
+
+declare(strict_types=1);
+
+namespace Chill\CalendarBundle\Service\ShortMessageNotification;
+
+use DateInterval;
+use Monolog\DateTimeImmutable;
+use UnexpectedValueException;
+
+/**
+ * * Lundi => Envoi des rdv du mardi et mercredi.
+ * * Mardi => Envoi des rdv du jeudi.
+ * * Mercredi => Envoi des rdv du vendredi
+ * * Jeudi => envoi des rdv du samedi et dimanche
+ * * Vendredi => Envoi des rdv du lundi.
+ */
+class DefaultRangeGenerator implements RangeGeneratorInterface
+{
+    public function generateRange(\DateTimeImmutable $date): array
+    {
+        $onMidnight = DateTimeImmutable::createFromFormat('Y-m-d H:i:s', $date->format('Y-m-d') . ' 00:00:00');
+
+        switch ($dow = (int) $onMidnight->format('w')) {
+            case 6: // Saturday
+            case 0: // Sunday
+                return ['startDate' => null, 'endDate' => null];
+
+            case 1: // Monday
+                // send for Tuesday and Wednesday
+                $startDate = $onMidnight->add(new DateInterval('P1D'));
+                $endDate = $startDate->add(new DateInterval('P2D'));
+
+                break;
+
+            case 2: // tuesday
+            case 3: // wednesday
+                $startDate = $onMidnight->add(new DateInterval('P2D'));
+                $endDate = $startDate->add(new DateInterval('P1D'));
+
+                break;
+
+            case 4: // thursday
+                $startDate = $onMidnight->add(new DateInterval('P2D'));
+                $endDate = $startDate->add(new DateInterval('P2D'));
+
+                break;
+
+            case 5: // friday
+                $startDate = $onMidnight->add(new DateInterval('P3D'));
+                $endDate = $startDate->add(new DateInterval('P1D'));
+
+                break;
+
+            default:
+                throw new UnexpectedValueException('a day of a week should not have the value: ' . $dow);
+        }
+
+        return ['startDate' => $startDate, 'endDate' => $endDate];
+    }
+}

src/Bundle/ChillCalendarBundle/Service/ShortMessageNotification/DefaultShortMessageForCalendarBuilder.php

@@ -0,0 +1,58 @@
+<?php
+
+/**
+ * Chill is a software for social workers
+ *
+ * For the full copyright and license information, please view
+ * the LICENSE file that was distributed with this source code.
+ */
+
+declare(strict_types=1);
+
+namespace Chill\CalendarBundle\Service\ShortMessageNotification;
+
+use Chill\CalendarBundle\Entity\Calendar;
+use Chill\MainBundle\Service\ShortMessage\ShortMessage;
+use Symfony\Component\Templating\EngineInterface;
+
+class DefaultShortMessageForCalendarBuilder implements ShortMessageForCalendarBuilderInterface
+{
+    private EngineInterface $engine;
+
+    public function __construct(
+        EngineInterface $engine
+    ) {
+        $this->engine = $engine;
+    }
+
+    public function buildMessageForCalendar(Calendar $calendar): array
+    {
+        if (true !== $calendar->getSendSMS()) {
+            return [];
+        }
+
+        $toUsers = [];
+
+        foreach ($calendar->getPersons() as $person) {
+            if (false === $person->getAcceptSMS() || null === $person->getAcceptSMS() || null === $person->getMobilenumber()) {
+                continue;
+            }
+
+            if (Calendar::SMS_PENDING === $calendar->getSmsStatus()) {
+                $toUsers[] = new ShortMessage(
+                    $this->engine->render('@ChillCalendar/CalendarShortMessage/short_message.txt.twig', ['calendar' => $calendar]),
+                    $person->getMobilenumber(),
+                    ShortMessage::PRIORITY_LOW
+                );
+            } elseif (Calendar::SMS_CANCEL_PENDING === $calendar->getSmsStatus()) {
+                $toUsers[] = new ShortMessage(
+                    $this->engine->render('@ChillCalendar/CalendarShortMessage/short_message_canceled.txt.twig', ['calendar' => $calendar]),
+                    $person->getMobilenumber(),
+                    ShortMessage::PRIORITY_LOW
+                );
+            }
+        }
+
+        return $toUsers;
+    }
+}

src/Bundle/ChillCalendarBundle/Service/ShortMessageNotification/RangeGeneratorInterface.php

@@ -0,0 +1,22 @@
+<?php
+
+/**
+ * Chill is a software for social workers
+ *
+ * For the full copyright and license information, please view
+ * the LICENSE file that was distributed with this source code.
+ */
+
+declare(strict_types=1);
+
+namespace Chill\CalendarBundle\Service\ShortMessageNotification;
+
+use DateTimeImmutable;
+
+interface RangeGeneratorInterface
+{
+    /**
+     * @return array<startDate: \DateTimeImmutable, endDate: \DateTimeImmutable>
+     */
+    public function generateRange(DateTimeImmutable $date): array;
+}

src/Bundle/ChillCalendarBundle/Service/ShortMessageNotification/ShortMessageForCalendarBuilderInterface.php

@@ -0,0 +1,23 @@
+<?php
+
+/**
+ * Chill is a software for social workers
+ *
+ * For the full copyright and license information, please view
+ * the LICENSE file that was distributed with this source code.
+ */
+
+declare(strict_types=1);
+
+namespace Chill\CalendarBundle\Service\ShortMessageNotification;
+
+use Chill\CalendarBundle\Entity\Calendar;
+use Chill\MainBundle\Service\ShortMessage\ShortMessage;
+
+interface ShortMessageForCalendarBuilderInterface
+{
+    /**
+     * @return array|ShortMessage[]
+     */
+    public function buildMessageForCalendar(Calendar $calendar): array;
+}

src/Bundle/ChillCalendarBundle/Tests/Controller/RemoteCalendarMSGraphSyncControllerTest.php

@@ -0,0 +1,85 @@
+<?php
+
+/**
+ * Chill is a software for social workers
+ *
+ * For the full copyright and license information, please view
+ * the LICENSE file that was distributed with this source code.
+ */
+
+declare(strict_types=1);
+
+namespace Chill\CalendarBundle\Tests\Controller;
+
+use Symfony\Bundle\FrameworkBundle\Test\WebTestCase;
+use Symfony\Component\Messenger\Transport\InMemoryTransport;
+
+/**
+ * @internal
+ * @coversNothing
+ */
+final class RemoteCalendarMSGraphSyncControllerTest extends WebTestCase
+{
+    private const SAMPLE_BODY = <<<'JSON'
+        {
+            "value": [
+                {
+                    "subscriptionId": "739703eb-80c4-4c03-b15a-ca370f19624b",
+                    "subscriptionExpirationDateTime": "2022-06-09T02:40:28-07:00",
+                    "changeType": "updated",
+                    "resource": "Users/4feb0ae3-7ffb-48dd-891e-c86b2cdeefd4/Events/AAMkADM1MTdlMGIzLTZhZWUtNDQ0ZC05Y2M4LWViMjhmOWJlMDhhMQBGAAAAAAA5e3965gkBSLcU1p00sMSyBwAHduaxajFfTpv0kchk_m1FAAAAAAENAAAHduaxajFfTpv0kchk_m1FAAAl1BupAAA=",
+                    "resourceData": {
+                        "@odata.type": "#Microsoft.Graph.Event",
+                        "@odata.id": "Users/4feb0ae3-7ffb-48dd-891e-c86b2cdeefd4/Events/AAMkADM1MTdlMGIzLTZhZWUtNDQ0ZC05Y2M4LWViMjhmOWJlMDhhMQBGAAAAAAA5e3965gkBSLcU1p00sMSyBwAHduaxajFfTpv0kchk_m1FAAAAAAENAAAHduaxajFfTpv0kchk_m1FAAAl1BupAAA=",
+                        "@odata.etag": "W/\"DwAAABYAAAAHduaxajFfTpv0kchk+m1FAAAlyzAU\"",
+                        "id": "AAMkADM1MTdlMGIzLTZhZWUtNDQ0ZC05Y2M4LWViMjhmOWJlMDhhMQBGAAAAAAA5e3965gkBSLcU1p00sMSyBwAHduaxajFfTpv0kchk_m1FAAAAAAENAAAHduaxajFfTpv0kchk_m1FAAAl1BupAAA="
+                    },
+                    "clientState": "2k05qlr3ds2KzvUP3Ps4A+642fYaI8ThxHGIGbNr2p0MnNkmzxLTNEMxpMc/UEuDkBHfID7OYWj4DQc94vlEkPBdsh9sGTTkHxIE68hqkKkDKhwvfvdj6lS6Dus=",
+                    "tenantId": "421bf216-3f48-47bd-a7cf-8b1995cb24bd"
+                }
+            ]
+        }
+        JSON;
+
+    protected function setUp(): void
+    {
+        self::bootKernel();
+    }
+
+    public function testSendNotification(): void
+    {
+        $client = self::createClient();
+        $client->request(
+            'POST',
+            '/public/incoming-hook/calendar/msgraph/events/23',
+            [],
+            [],
+            [],
+            self::SAMPLE_BODY
+        );
+
+        $this->assertResponseIsSuccessful();
+        $this->assertResponseStatusCodeSame(202);
+
+        /** @var InMemoryTransport $transport */
+        $transport = self::$container->get('messenger.transport.async');
+        $this->assertCount(1, $transport->getSent());
+    }
+
+    public function testValidateSubscription(): void
+    {
+        $client = self::createClient();
+        $client->request(
+            'POST',
+            '/public/incoming-hook/calendar/msgraph/events/23?validationToken=something%20to%20decode'
+        );
+
+        $this->assertResponseIsSuccessful();
+
+        $response = $client->getResponse();
+
+        $this->assertResponseHasHeader('Content-Type');
+        $this->assertStringContainsString('text/plain', $response->headers->get('Content-Type'));
+        $this->assertEquals('something to decode', $response->getContent());
+    }
+}

src/Bundle/ChillCalendarBundle/Tests/Entity/CalendarTest.php

@@ -0,0 +1,56 @@
+<?php
+
+/**
+ * Chill is a software for social workers
+ *
+ * For the full copyright and license information, please view
+ * the LICENSE file that was distributed with this source code.
+ */
+
+declare(strict_types=1);
+
+namespace Chill\CalendarBundle\Tests\Entity;
+
+use Chill\CalendarBundle\Entity\Calendar;
+use Chill\MainBundle\Entity\User;
+use PHPUnit\Framework\TestCase;
+
+/**
+ * @internal
+ * @coversNothing
+ */
+final class CalendarTest extends TestCase
+{
+    public function testAddUser()
+    {
+        $calendar = new Calendar();
+
+        $this->assertCount(0, $calendar->getInvites());
+        $this->assertCount(0, $calendar->getUsers());
+
+        $calendar->addUser($user0 = new User());
+
+        $this->assertCount(1, $calendar->getInvites());
+        $this->assertCount(1, $calendar->getUsers());
+        $this->assertSame($user0, $calendar->getUsers()->first());
+
+        $calendar->addUser($user1 = new User());
+
+        $this->assertCount(2, $calendar->getInvites());
+        $this->assertCount(2, $calendar->getUsers());
+        $this->assertContains($user0, $calendar->getUsers());
+        $this->assertContains($user1, $calendar->getUsers());
+
+        $calendar->removeUser($user0);
+
+        $this->assertCount(1, $calendar->getInvites());
+        $this->assertCount(1, $calendar->getUsers());
+        $this->assertNotSame($user0, $calendar->getUsers()->first());
+        $this->assertSame($user1, $calendar->getUsers()->first());
+
+        $calendar->removeUser($user1);
+
+        $this->assertCount(0, $calendar->getInvites());
+        $this->assertCount(0, $calendar->getUsers());
+    }
+}

src/Bundle/ChillCalendarBundle/Tests/Form/CalendarTypeTest.php

@@ -0,0 +1,203 @@
+<?php
+
+/**
+ * Chill is a software for social workers
+ *
+ * For the full copyright and license information, please view
+ * the LICENSE file that was distributed with this source code.
+ */
+
+declare(strict_types=1);
+
+namespace Chill\CalendarBundle\Tests\Form;
+
+use Chill\CalendarBundle\Entity\Calendar;
+use Chill\CalendarBundle\Entity\CalendarRange;
+use Chill\CalendarBundle\Form\CalendarType;
+use Chill\CalendarBundle\Form\DataTransformer\IdToCalendarRangeDataTransformer;
+use Chill\MainBundle\Entity\Location;
+use Chill\MainBundle\Entity\User;
+use Chill\MainBundle\Form\DataTransformer\IdToLocationDataTransformer;
+use Chill\MainBundle\Form\DataTransformer\IdToUserDataTransformer;
+use Chill\MainBundle\Form\DataTransformer\IdToUsersDataTransformer;
+use Chill\MainBundle\Form\Type\CommentType;
+use Chill\PersonBundle\Entity\Person;
+use Chill\PersonBundle\Form\DataTransformer\PersonsToIdDataTransformer;
+use Chill\ThirdPartyBundle\Entity\ThirdParty;
+use Chill\ThirdPartyBundle\Form\DataTransformer\ThirdPartiesToIdDataTransformer;
+use DateTimeImmutable;
+use Doctrine\Common\Collections\Collection;
+use Prophecy\Argument;
+use Prophecy\PhpUnit\ProphecyTrait;
+use ReflectionProperty;
+use Symfony\Component\Form\PreloadedExtension;
+use Symfony\Component\Form\Test\TypeTestCase;
+use Symfony\Component\Security\Core\Authentication\Token\Storage\TokenStorageInterface;
+use Symfony\Component\Security\Core\Authentication\Token\TokenInterface;
+
+/**
+ * @internal
+ * @coversNothing
+ */
+final class CalendarTypeTest extends TypeTestCase
+{
+    use ProphecyTrait;
+
+    private IdToCalendarRangeDataTransformer $calendarRangeDataTransformer;
+
+    private IdToLocationDataTransformer $idToLocationDataTransformer;
+
+    private IdToUserDataTransformer $idToUserDataTransformer;
+
+    private IdToUsersDataTransformer $idToUsersDataTransformer;
+
+    private ThirdPartiesToIdDataTransformer $partiesToIdDataTransformer;
+
+    private PersonsToIdDataTransformer $personsToIdDataTransformer;
+
+    private TokenStorageInterface $tokenStorage;
+
+    protected function setUp(): void
+    {
+        $this->personsToIdDataTransformer = $this->buildMultiToIdDataTransformer(PersonsToIdDataTransformer::class, Person::class);
+        $this->idToUserDataTransformer = $this->buildSingleToIdDataTransformer(IdToUserDataTransformer::class, User::class);
+        $this->idToUsersDataTransformer = $this->buildMultiToIdDataTransformer(IdToUsersDataTransformer::class, User::class);
+        $this->idToLocationDataTransformer = $this->buildSingleToIdDataTransformer(IdToLocationDataTransformer::class, Location::class);
+        $this->partiesToIdDataTransformer = $this->buildMultiToIdDataTransformer(ThirdPartiesToIdDataTransformer::class, ThirdParty::class);
+        $this->calendarRangeDataTransformer = $this->buildSingleToIdDataTransformer(IdToCalendarRangeDataTransformer::class, CalendarRange::class);
+        $tokenStorage = $this->prophesize(TokenStorageInterface::class);
+        $token = $this->prophesize(TokenInterface::class);
+        $token->getUser()->willReturn(new User());
+        $tokenStorage->getToken()->willReturn($token->reveal());
+        $this->tokenStorage = $tokenStorage->reveal();
+
+        parent::setUp();
+    }
+
+    public function testSubmitValidData()
+    {
+        $formData = [
+            'mainUser' => '1',
+            'users' => '2,3',
+            'professionnals' => '4,5',
+            'startDate' => '2022-05-05 14:00:00',
+            'endDate' => '2022-05-05 14:30:00',
+            'persons' => '7',
+            'calendarRange' => '8',
+            'location' => '9',
+            'sendSMS' => '1',
+        ];
+
+        $calendar = new Calendar();
+        $calendar->setMainUser(new class() extends User {
+            public function getId()
+            {
+                return '1';
+            }
+        });
+
+        $form = $this->factory->create(CalendarType::class, $calendar);
+
+        $form->submit($formData);
+
+        $this->assertTrue($form->isSynchronized());
+        $this->assertEquals(DateTimeImmutable::createFromFormat('Y-m-d H:i:s', '2022-05-05 14:00:00'), $calendar->getStartDate());
+        $this->assertEquals(DateTimeImmutable::createFromFormat('Y-m-d H:i:s', '2022-05-05 14:30:00'), $calendar->getEndDate());
+        $this->assertEquals(7, $calendar->getPersons()->first()->getId());
+        $this->assertEquals(8, $calendar->getCalendarRange()->getId());
+        $this->assertEquals(9, $calendar->getLocation()->getId());
+        $this->assertEquals(true, $calendar->getSendSMS());
+        $this->assertContains(2, $calendar->getUsers()->map(static function (User $u) { return $u->getId(); }));
+        $this->assertContains(3, $calendar->getUsers()->map(static function (User $u) { return $u->getId(); }));
+    }
+
+    protected function getExtensions()
+    {
+        $parents = parent::getExtensions();
+
+        $calendarType = new CalendarType(
+            $this->personsToIdDataTransformer,
+            $this->idToUserDataTransformer,
+            $this->idToUsersDataTransformer,
+            $this->idToLocationDataTransformer,
+            $this->partiesToIdDataTransformer,
+            $this->calendarRangeDataTransformer
+        );
+        $commentType = new CommentType($this->tokenStorage);
+
+        return array_merge(
+            parent::getExtensions(),
+            [new PreloadedExtension([$calendarType, $commentType], [])]
+        );
+    }
+
+    private function buildMultiToIdDataTransformer(
+        string $classTransformer,
+        string $objClass
+    ) {
+        $transformer = $this->prophesize($classTransformer);
+        $transformer->transform(Argument::type('array'))
+            ->will(static function ($args) {
+                return implode(
+                    ',',
+                    array_map(static function ($p) { return $p->getId(); }, $args[0])
+                );
+            });
+        $transformer->transform(Argument::exact(null))
+            ->willReturn([]);
+        $transformer->transform(Argument::type(Collection::class))
+            ->will(static function ($args) {
+                return implode(
+                    ',',
+                    array_map(static function ($p) { return $p->getId(); }, $args[0]->toArray())
+                );
+            });
+        $transformer->reverseTransform(Argument::type('string'))
+            ->will(static function ($args) use ($objClass) {
+                if (null === $args[0]) {
+                    return [];
+                }
+
+                return array_map(
+                    static function ($id) use ($objClass) {
+                        $obj = new $objClass();
+                        $reflectionProperty = new ReflectionProperty($objClass, 'id');
+                        $reflectionProperty->setAccessible(true);
+                        $reflectionProperty->setValue($obj, (int) $id);
+
+                        return $obj;
+                    },
+                    explode(',', $args[0])
+                );
+            });
+
+        return $transformer->reveal();
+    }
+
+    private function buildSingleToIdDataTransformer(
+        string $classTransformer,
+        string $class
+    ) {
+        $transformer = $this->prophesize($classTransformer);
+        $transformer->transform(Argument::type('object'))
+            ->will(static function ($args) {
+                return (string) $args[0]->getId();
+            });
+        $transformer->transform(Argument::exact(null))
+            ->willReturn('');
+        $transformer->reverseTransform(Argument::type('string'))
+            ->will(static function ($args) use ($class) {
+                if (null === $args[0]) {
+                    return null;
+                }
+                $obj = new $class();
+                $reflectionProperty = new ReflectionProperty($class, 'id');
+                $reflectionProperty->setAccessible(true);
+                $reflectionProperty->setValue($obj, (int) $args[0]);
+
+                return $obj;
+            });
+
+        return $transformer->reveal();
+    }
+}

src/Bundle/ChillCalendarBundle/Tests/RemoteCalendar/Connector/MSGraph/CalendarRangeSyncerTest.php

@@ -0,0 +1,248 @@
+<?php
+
+/**
+ * Chill is a software for social workers
+ *
+ * For the full copyright and license information, please view
+ * the LICENSE file that was distributed with this source code.
+ */
+
+declare(strict_types=1);
+
+namespace Chill\CalendarBundle\Tests\RemoteCalendar\Connector\MSGraph;
+
+use Chill\CalendarBundle\Entity\Calendar;
+use Chill\CalendarBundle\Entity\CalendarRange;
+use Chill\CalendarBundle\RemoteCalendar\Connector\MSGraph\RemoteToLocalSync\CalendarRangeSyncer;
+use Chill\MainBundle\Entity\User;
+use DateTimeImmutable;
+use Doctrine\ORM\EntityManagerInterface;
+use PHPUnit\Framework\TestCase;
+use Prophecy\Argument;
+use Prophecy\PhpUnit\ProphecyTrait;
+use Psr\Log\NullLogger;
+use Symfony\Component\HttpClient\MockHttpClient;
+use Symfony\Component\HttpClient\Response\MockResponse;
+
+/**
+ * @internal
+ * @coversNothing
+ */
+final class CalendarRangeSyncerTest extends TestCase
+{
+    use ProphecyTrait;
+
+    private const NOTIF_DELETE = <<<'JSON'
+        {
+            "value": [
+                {
+                    "subscriptionId": "077e8d19-68b3-4d8e-9b1e-8b4ba6733799",
+                    "subscriptionExpirationDateTime": "2022-06-09T06:22:02-07:00",
+                    "changeType": "deleted",
+                    "resource": "Users/4feb0ae3-7ffb-48dd-891e-c86b2cdeefd4/Events/AAMkADM1MTdlMGIzLTZhZWUtNDQ0ZC05Y2M4LWViMjhmOWJlMDhhMQBGAAAAAAA5e3965gkBSLcU1p00sMSyBwAHduaxajFfTpv0kchk_m1FAAAAAAENAAAHduaxajFfTpv0kchk_m1FAAAl1BupAAA=",
+                    "resourceData": {
+                        "@odata.type": "#Microsoft.Graph.Event",
+                        "@odata.id": "Users/4feb0ae3-7ffb-48dd-891e-c86b2cdeefd4/Events/AAMkADM1MTdlMGIzLTZhZWUtNDQ0ZC05Y2M4LWViMjhmOWJlMDhhMQBGAAAAAAA5e3965gkBSLcU1p00sMSyBwAHduaxajFfTpv0kchk_m1FAAAAAAENAAAHduaxajFfTpv0kchk_m1FAAAl1BupAAA=",
+                        "@odata.etag": "W/\"CQAAAA==\"",
+                        "id": "AAMkADM1MTdlMGIzLTZhZWUtNDQ0ZC05Y2M4LWViMjhmOWJlMDhhMQBGAAAAAAA5e3965gkBSLcU1p00sMSyBwAHduaxajFfTpv0kchk_m1FAAAAAAENAAAHduaxajFfTpv0kchk_m1FAAAl1BupAAA="
+                    },
+                    "clientState": "uds18apRCByqWIodFCHKeM0kJqhfr+qXL/rJWYn7xmtdQ4t03W2OHEOdGJ0Ceo52NAzOYVDpbfRM3TdrZDUiE09OxZkPX/vkpdcnipoiVnPPMFBQn05p8KhklOM=",
+                    "tenantId": "421bf216-3f48-47bd-a7cf-8b1995cb24bd"
+                }
+            ]
+        }
+        JSON;
+
+    private const NOTIF_UPDATE = <<<'JSON'
+        {
+            "value": [
+                {
+                    "subscriptionId": "739703eb-80c4-4c03-b15a-ca370f19624b",
+                    "subscriptionExpirationDateTime": "2022-06-09T02:40:28-07:00",
+                    "changeType": "updated",
+                    "resource": "Users/4feb0ae3-7ffb-48dd-891e-c86b2cdeefd4/Events/AAMkADM1MTdlMGIzLTZhZWUtNDQ0ZC05Y2M4LWViMjhmOWJlMDhhMQBGAAAAAAA5e3965gkBSLcU1p00sMSyBwAHduaxajFfTpv0kchk_m1FAAAAAAENAAAHduaxajFfTpv0kchk_m1FAAAl1BupAAA=",
+                    "resourceData": {
+                        "@odata.type": "#Microsoft.Graph.Event",
+                        "@odata.id": "Users/4feb0ae3-7ffb-48dd-891e-c86b2cdeefd4/Events/AAMkADM1MTdlMGIzLTZhZWUtNDQ0ZC05Y2M4LWViMjhmOWJlMDhhMQBGAAAAAAA5e3965gkBSLcU1p00sMSyBwAHduaxajFfTpv0kchk_m1FAAAAAAENAAAHduaxajFfTpv0kchk_m1FAAAl1BupAAA=",
+                        "@odata.etag": "W/\"DwAAABYAAAAHduaxajFfTpv0kchk+m1FAAAlyzAU\"",
+                        "id": "AAMkADM1MTdlMGIzLTZhZWUtNDQ0ZC05Y2M4LWViMjhmOWJlMDhhMQBGAAAAAAA5e3965gkBSLcU1p00sMSyBwAHduaxajFfTpv0kchk_m1FAAAAAAENAAAHduaxajFfTpv0kchk_m1FAAAl1BupAAA="
+                    },
+                    "clientState": "2k05qlr3ds2KzvUP3Ps4A+642fYaI8ThxHGIGbNr2p0MnNkmzxLTNEMxpMc/UEuDkBHfID7OYWj4DQc94vlEkPBdsh9sGTTkHxIE68hqkKkDKhwvfvdj6lS6Dus=",
+                    "tenantId": "421bf216-3f48-47bd-a7cf-8b1995cb24bd"
+                }
+            ]
+        }
+        JSON;
+
+    private const REMOTE_CALENDAR_RANGE = <<<'JSON'
+        {
+            "@odata.context": "https://graph.microsoft.com/v1.0/$metadata#users('4feb0ae3-7ffb-48dd-891e-c86b2cdeefd4')/events/$entity",
+            "@odata.etag": "W/\"B3bmsWoxX06b9JHIZPptRQAAJcswFA==\"",
+            "id": "AAMkADM1MTdlMGIzLTZhZWUtNDQ0ZC05Y2M4LWViMjhmOWJlMDhhMQBGAAAAAAA5e3965gkBSLcU1p00sMSyBwAHduaxajFfTpv0kchk_m1FAAAAAAENAAAHduaxajFfTpv0kchk_m1FAAAl1BupAAA=",
+            "createdDateTime": "2022-06-08T15:22:24.0096697Z",
+            "lastModifiedDateTime": "2022-06-09T09:27:09.9223729Z",
+            "changeKey": "B3bmsWoxX06b9JHIZPptRQAAJcswFA==",
+            "categories": [],
+            "transactionId": "90c23105-a6b1-b594-1811-e4ffa612092a",
+            "originalStartTimeZone": "Romance Standard Time",
+            "originalEndTimeZone": "Romance Standard Time",
+            "iCalUId": "040000008200E00074C5B7101A82E00800000000A971DA8D4B7BD801000000000000000010000000BE3F4A21C9008E4FB35A4DE1F80E0118",
+            "reminderMinutesBeforeStart": 15,
+            "isReminderOn": true,
+            "hasAttachments": false,
+            "subject": "test notif",
+            "bodyPreview": "",
+            "importance": "normal",
+            "sensitivity": "normal",
+            "isAllDay": false,
+            "isCancelled": false,
+            "isOrganizer": true,
+            "responseRequested": true,
+            "seriesMasterId": null,
+            "showAs": "busy",
+            "type": "singleInstance",
+            "webLink": "https://outlook.office365.com/owa/?itemid=AAMkADM1MTdlMGIzLTZhZWUtNDQ0ZC05Y2M4LWViMjhmOWJlMDhhMQBGAAAAAAA5e3965gkBSLcU1p00sMSyBwAHduaxajFfTpv0kchk%2Bm1FAAAAAAENAAAHduaxajFfTpv0kchk%2Bm1FAAAl1BupAAA%3D&exvsurl=1&path=/calendar/item",
+            "onlineMeetingUrl": null,
+            "isOnlineMeeting": false,
+            "onlineMeetingProvider": "unknown",
+            "allowNewTimeProposals": true,
+            "occurrenceId": null,
+            "isDraft": false,
+            "hideAttendees": false,
+            "responseStatus": {
+                "response": "organizer",
+                "time": "0001-01-01T00:00:00Z"
+            },
+            "body": {
+                "contentType": "html",
+                "content": ""
+            },
+            "start": {
+                "dateTime": "2022-06-10T13:30:00.0000000",
+                "timeZone": "UTC"
+            },
+            "end": {
+                "dateTime": "2022-06-10T15:30:00.0000000",
+                "timeZone": "UTC"
+            },
+            "location": {
+                "displayName": "",
+                "locationType": "default",
+                "uniqueIdType": "unknown",
+                "address": {},
+                "coordinates": {}
+            },
+            "locations": [],
+            "recurrence": null,
+            "attendees": [],
+            "organizer": {
+                "emailAddress": {
+                    "name": "Diego Siciliani",
+                    "address": "DiegoS@2zy74l.onmicrosoft.com"
+                }
+            },
+            "onlineMeeting": null,
+            "calendar@odata.associationLink": "https://graph.microsoft.com/v1.0/Users('4feb0ae3-7ffb-48dd-891e-c86b2cdeefd4')/calendar/$ref",
+            "calendar@odata.navigationLink": "https://graph.microsoft.com/v1.0/Users('4feb0ae3-7ffb-48dd-891e-c86b2cdeefd4')/calendar"
+        }
+        JSON;
+
+    public function testDeleteCalendarRangeWithAssociation(): void
+    {
+        $em = $this->prophesize(EntityManagerInterface::class);
+        $em->remove(Argument::type(CalendarRange::class))->shouldNotBeCalled();
+
+        $machineHttpClient = new MockHttpClient([
+            new MockResponse(self::REMOTE_CALENDAR_RANGE, ['http_code' => 200]),
+        ]);
+
+        $calendarRangeSyncer = new CalendarRangeSyncer(
+            $em->reveal(),
+            new NullLogger(),
+            $machineHttpClient
+        );
+
+        $calendarRange = new CalendarRange();
+        $calendarRange
+            ->setUser($user = new User());
+        $calendar = new Calendar();
+        $calendar->setCalendarRange($calendarRange);
+
+        $notification = json_decode(self::NOTIF_DELETE, true);
+
+        $calendarRangeSyncer->handleCalendarRangeSync(
+            $calendarRange,
+            $notification['value'][0],
+            $user
+        );
+    }
+
+    public function testDeleteCalendarRangeWithoutAssociation(): void
+    {
+        $em = $this->prophesize(EntityManagerInterface::class);
+        $em->remove(Argument::type(CalendarRange::class))->shouldBeCalled();
+
+        $machineHttpClient = new MockHttpClient([
+            new MockResponse(self::REMOTE_CALENDAR_RANGE, ['http_code' => 200]),
+        ]);
+
+        $calendarRangeSyncer = new CalendarRangeSyncer(
+            $em->reveal(),
+            new NullLogger(),
+            $machineHttpClient
+        );
+
+        $calendarRange = new CalendarRange();
+        $calendarRange
+            ->setUser($user = new User());
+        $notification = json_decode(self::NOTIF_DELETE, true);
+
+        $calendarRangeSyncer->handleCalendarRangeSync(
+            $calendarRange,
+            $notification['value'][0],
+            $user
+        );
+        $this->assertTrue($calendarRange->preventEnqueueChanges);
+    }
+
+    public function testUpdateCalendarRange(): void
+    {
+        $em = $this->prophesize(EntityManagerInterface::class);
+        $machineHttpClient = new MockHttpClient([
+            new MockResponse(self::REMOTE_CALENDAR_RANGE, ['http_code' => 200]),
+        ]);
+
+        $calendarRangeSyncer = new CalendarRangeSyncer(
+            $em->reveal(),
+            new NullLogger(),
+            $machineHttpClient
+        );
+
+        $calendarRange = new CalendarRange();
+        $calendarRange
+            ->setUser($user = new User())
+            ->setStartDate(new DateTimeImmutable('2020-01-01 15:00:00'))
+            ->setEndDate(new DateTimeImmutable('2020-01-01 15:30:00'))
+            ->addRemoteAttributes([
+                'lastModifiedDateTime' => 0,
+                'changeKey' => 'abc',
+            ]);
+        $notification = json_decode(self::NOTIF_UPDATE, true);
+
+        $calendarRangeSyncer->handleCalendarRangeSync(
+            $calendarRange,
+            $notification['value'][0],
+            $user
+        );
+
+        $this->assertStringContainsString(
+            '2022-06-10T15:30:00',
+            $calendarRange->getStartDate()->format(DateTimeImmutable::ATOM)
+        );
+        $this->assertStringContainsString(
+            '2022-06-10T17:30:00',
+            $calendarRange->getEndDate()->format(DateTimeImmutable::ATOM)
+        );
+        $this->assertTrue($calendarRange->preventEnqueueChanges);
+    }
+}