chill-bundles/src/Bundle/ChillPersonBundle/Controller/AccompanyingCourseController.php

<?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\PersonBundle\Controller;

use Chill\ActivityBundle\Entity\Activity;
use Chill\PersonBundle\Entity\AccompanyingPeriod;
use Chill\PersonBundle\Entity\Household\Household;
use Chill\PersonBundle\Entity\Person;
use Chill\PersonBundle\Form\AccompanyingCourseType;
use Chill\PersonBundle\Repository\AccompanyingPeriod\AccompanyingPeriodWorkRepository;
use Chill\PersonBundle\Security\Authorization\AccompanyingPeriodVoter;
use Sensio\Bundle\FrameworkExtraBundle\Configuration\ParamConverter;
use Symfony\Bundle\FrameworkBundle\Controller\Controller;
use Symfony\Component\Form\Extension\Core\Type\SubmitType;
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 Symfony\Component\Validator\ConstraintViolationInterface;
use Symfony\Component\Validator\ConstraintViolationListInterface;
use Symfony\Component\Validator\Validator\ValidatorInterface;
use Symfony\Component\Workflow\Registry;
use Symfony\Contracts\EventDispatcher\EventDispatcherInterface;
use Symfony\Contracts\Translation\TranslatorInterface;

use function array_slice;
use function is_array;

/**
 * Class AccompanyingCourseController.
 */
class AccompanyingCourseController extends Controller
{
    protected EventDispatcherInterface $dispatcher;

    protected SerializerInterface $serializer;

    protected ValidatorInterface $validator;

    private Registry $registry;

    private TranslatorInterface $translator;

    private AccompanyingPeriodWorkRepository $workRepository;

    public function __construct(
        SerializerInterface $serializer,
        EventDispatcherInterface $dispatcher,
        ValidatorInterface $validator,
        AccompanyingPeriodWorkRepository $workRepository,
        Registry $registry,
        TranslatorInterface $translator
    ) {
        $this->serializer = $serializer;
        $this->dispatcher = $dispatcher;
        $this->validator = $validator;
        $this->workRepository = $workRepository;
        $this->registry = $registry;
        $this->translator = $translator;
    }

    /**
     * @Route("/{_locale}/parcours/{accompanying_period_id}/close", name="chill_person_accompanying_course_close")
     * @ParamConverter("accompanyingCourse", options={"id": "accompanying_period_id"})
     */
    public function closeAction(AccompanyingPeriod $accompanyingCourse, Request $request): Response
    {
        $this->denyAccessUnlessGranted(AccompanyingPeriodVoter::EDIT, $accompanyingCourse);

        $form = $this->createForm(AccompanyingCourseType::class, $accompanyingCourse, [
            'validation_groups' => [AccompanyingPeriod::STEP_CLOSED],
        ]);

        $form->handleRequest($request);

        if ($form->isSubmitted() && $form->isValid()) {
            $em = $this->getDoctrine()->getManager();

            $workflow = $this->registry->get($accompanyingCourse);

            if ($workflow->can($accompanyingCourse, 'close')) {
                $workflow->apply($accompanyingCourse, 'close');

                $em->flush();

                return $this->redirectToRoute('chill_person_accompanying_course_index', [
                    'accompanying_period_id' => $accompanyingCourse->getId(),
                ]);
            }
            /** @var ConstraintViolationListInterface $errors */
            $errors = $this->validator->validate($accompanyingCourse, null, [$accompanyingCourse::STEP_CLOSED]);
            $this->addFlash('error', $this->translator->trans('It is not possible to close this course'));

            foreach ($errors as $e) {
                /** @var ConstraintViolationInterface $e */
                $this->addFlash('error', $e->getMessage());
            }
        }

        return $this->render('@ChillPerson/AccompanyingCourse/close.html.twig', [
            'form' => $form->createView(),
            'accompanyingCourse' => $accompanyingCourse,
        ]);
    }

    /**
     * Delete page of Accompanying Course section.
     *
     * @Route("/{_locale}/parcours/{accompanying_period_id}/delete", name="chill_person_accompanying_course_delete")
     * @ParamConverter("accompanyingCourse", options={"id": "accompanying_period_id"})
     */
    public function deleteAction(Request $request, AccompanyingPeriod $accompanyingCourse)
    {
        $em = $this->getDoctrine()->getManager();

        $person_id = $request->query->get('person_id');

        $form = $this->createFormBuilder()
            ->setAction($this->generateUrl('chill_person_accompanying_course_delete', [
                'accompanying_period_id' => $accompanyingCourse->getId(),
                'person_id' => $person_id,
            ]))
            ->setMethod('DELETE')
            ->add('submit', SubmitType::class, ['label' => 'Delete'])
            ->getForm();

        if ($request->getMethod() === Request::METHOD_DELETE) {
            $form->handleRequest($request);

            if ($form->isValid()) {
                $em->remove($accompanyingCourse);
                $em->flush();

                $this->addFlash('success', $this->get('translator')
                    ->trans('The accompanying course has been successfully removed.'));

                if (null !== $person_id) {
                    return $this->redirectToRoute('chill_person_accompanying_period_list', [
                        'person_id' => $person_id,
                    ]);
                }

                return $this->redirectToRoute('chill_main_homepage');
            }
        }

        if (null !== $person_id) {
            $view = '@ChillPerson/AccompanyingCourse/confirm_delete_person.html.twig';
        } else {
            $view = '@ChillPerson/AccompanyingCourse/confirm_delete_accompanying_course.html.twig';
        }

        return $this->render($view, [
            'accompanyingCourse' => $accompanyingCourse,
            'person_id' => $person_id,
            'delete_form' => $form->createView(),
        ]);
    }

    /**
     * Edit page of Accompanying Course section.
     *
     * the page edit all blocks managed by vuejs component
     *
     * @Route("/{_locale}/parcours/{accompanying_period_id}/edit", name="chill_person_accompanying_course_edit")
     * @ParamConverter("accompanyingCourse", options={"id": "accompanying_period_id"})
     */
    public function editAction(AccompanyingPeriod $accompanyingCourse): Response
    {
        $this->denyAccessUnlessGranted(AccompanyingPeriodVoter::SEE, $accompanyingCourse);

        return $this->render('@ChillPerson/AccompanyingCourse/edit.html.twig', [
            'accompanyingCourse' => $accompanyingCourse,
        ]);
    }

    /**
     * History page of Accompanying Course section.
     *
     * the page show anti chronologic history with all actions, title of page is 'Accompanying Course History'
     *
     * @Route("/{_locale}/parcours/{accompanying_period_id}/history", name="chill_person_accompanying_course_history")
     * @ParamConverter("accompanyingCourse", options={"id": "accompanying_period_id"})
     */
    public function historyAction(AccompanyingPeriod $accompanyingCourse): Response
    {
        $this->denyAccessUnlessGranted(AccompanyingPeriodVoter::SEE, $accompanyingCourse);

        return $this->render('@ChillPerson/AccompanyingCourse/history.html.twig', [
            'accompanyingCourse' => $accompanyingCourse,
        ]);
    }

    /**
     * Homepage of Accompanying Course section.
     *
     * @Route("/{_locale}/parcours/{accompanying_period_id}", name="chill_person_accompanying_course_index")
     * @ParamConverter("accompanyingCourse", options={"id": "accompanying_period_id"})
     */
    public function indexAction(AccompanyingPeriod $accompanyingCourse): Response
    {
        $this->denyAccessUnlessGranted(AccompanyingPeriodVoter::SEE, $accompanyingCourse);

        // compute some warnings
        // get persons without household
        $withoutHousehold = [];

        foreach ($accompanyingCourse->getParticipations() as $p) {
            if (false === $p->getPerson()->isSharingHousehold()) {
                $withoutHousehold[] = $p->getPerson();
            }
        }

        $activities = $this->getDoctrine()->getManager()->getRepository(Activity::class)->findBy(
            ['accompanyingPeriod' => $accompanyingCourse],
            ['date' => 'DESC', 'id' => 'DESC'],
        );

        $activities = array_slice($activities, 0, 3);

        $works = $this->workRepository->findByAccompanyingPeriod(
            $accompanyingCourse,
            ['startDate' => 'DESC', 'endDate' => 'DESC'],
            3
        );

        return $this->render('@ChillPerson/AccompanyingCourse/index.html.twig', [
            'accompanyingCourse' => $accompanyingCourse,
            'withoutHousehold' => $withoutHousehold,
            'participationsByHousehold' => $accompanyingCourse->actualParticipationsByHousehold(),
            'works' => $works,
            'activities' => $activities,
        ]);
    }

    /**
     * @Route("/{_locale}/person/parcours/new", name="chill_person_accompanying_course_new")
     */
    public function newAction(Request $request): Response
    {
        $period = new AccompanyingPeriod();
        $em = $this->getDoctrine()->getManager();

        if ($request->query->has('person_id')) {
            $personIds = $request->query->get('person_id');

            if (false === is_array($personIds)) {
                throw new BadRequestHttpException('person_id parameter should be an array');
            }

            foreach ($personIds as $personId) {
                $person = $em->getRepository(Person::class)->find($personId);

                if (null !== $person) {
                    $period->addPerson($person);
                }
            }
        }

        $userLocation = $this->getUser()->getCurrentLocation();
        $period->setAdministrativeLocation($userLocation);

        $this->denyAccessUnlessGranted(AccompanyingPeriodVoter::CREATE, $period);

        $em->persist($period);
        $em->flush();

        return $this->redirectToRoute('chill_person_accompanying_course_edit', [
            'accompanying_period_id' => $period->getId(),
        ]);
    }

    /**
     * @Route("/{_locale}/person/household/parcours/new", name="chill_household_accompanying_course_new")
     */
    public function newHouseholdParcoursAction(Request $request): Response
    {
        $period = new AccompanyingPeriod();
        $em = $this->getDoctrine()->getManager();

        if ($request->query->has('household_id')) {
            $householdId = $request->query->get('household_id');

            $household = $em->getRepository(Household::class)->find($householdId);
            $members = $household->getCurrentMembers();

            if (null !== $members) {
                foreach ($members as $m) {
                    $period->addPerson($m->getPerson());
                }
            }
        }

        $userLocation = $this->getUser()->getCurrentLocation();
        $period->setAdministrativeLocation($userLocation);

        $this->denyAccessUnlessGranted(AccompanyingPeriodVoter::CREATE, $period);

        $em->persist($period);
        $em->flush();

        return $this->redirectToRoute('chill_person_accompanying_course_edit', [
            'accompanying_period_id' => $period->getId(),
        ]);
    }

    /**
     * @Route("/{_locale}/parcours/{accompanying_period_id}/open", name="chill_person_accompanying_course_reopen")
     * @ParamConverter("accompanyingCourse", options={"id": "accompanying_period_id"})
     */
    public function reOpenAction(AccompanyingPeriod $accompanyingCourse, Request $request): Response
    {
        $this->denyAccessUnlessGranted(AccompanyingPeriodVoter::SEE, $accompanyingCourse);

        if (null === $accompanyingCourse) {
            throw $this->createNotFoundException('period not found');
        }

        $form = $this->createFormBuilder([])->getForm();
        $form->handleRequest($request);

        if ($form->isSubmitted() && $form->isValid()) {
            $accompanyingCourse->reOpen();
            $this->getDoctrine()->getManager()->flush();

            return $this->redirectToRoute('chill_person_accompanying_course_index', [
                'accompanying_period_id' => $accompanyingCourse->getId(),
            ]);
        }

        return $this->render('@ChillPerson/AccompanyingCourse/re_open.html.twig', [
            'form' => $form->createView(),
            'accompanyingCourse' => $accompanyingCourse,
        ]);
    }
}