src/Security/Voter/UserRequest/UserMayPostToStatus.php line 15

Open in your IDE?
  1. <?php
  3. namespace App\Security\Voter\UserRequest;
  5. use App\DTO\UserRequest\StatusPostDTO;
  6. use App\Entity\User;
  7. use App\Manager\UserRightsManagerInterface;
  8. use App\Security\Voter\UserRequest\UserOwnsRequestVoter;
  9. use Psr\Log\LoggerInterface;
  10. use Symfony\Component\Security\Core\Authentication\Token\TokenInterface;
  11. use Symfony\Component\Security\Core\Authorization\AuthorizationCheckerInterface;
  12. use Symfony\Component\Security\Core\Authorization\Voter\Voter;
  13. use WebServiceCollectionBundle\Model\AtlasPce\UserRequestRequestModel;
  15. class UserMayPostToStatus extends Voter
  16. {
  17.     public const POST_STATUS_ATTR   = 'POST_STATUS';
  18.     public const ROLES_REQUIREMENTS = [
  19.         'to_qualify'      => [
  20.             UserRightsManagerInterface::ROLE_CLIENT,
  21.             UserRightsManagerInterface::ROLE_SUEZ
  22.         ],
  23.         'to_specify'      => [ UserRightsManagerInterface::ROLE_SUEZ ],
  24.         'to_plan'         => [ UserRightsManagerInterface::ROLE_SUEZ ],
  25.         'planned'         => [ UserRightsManagerInterface::ROLE_SUEZ ],
  26.         'ongoing'         => [ UserRightsManagerInterface::ROLE_SUEZ ],
  27.         'done'            => [ UserRightsManagerInterface::ROLE_SUEZ ],
  28.         'closed_rejected' => [ UserRightsManagerInterface::ROLE_ADMIN ],
  29.         'closed'          => [ UserRightsManagerInterface::ROLE_ADMIN ],
  30.     ];
  32.     /**
  33.      * @var AuthorizationCheckerInterface
  34.      */
  35.     protected $authChecker;
  37.     /**
  38.      * @var LoggerInterface
  39.      */
  40.     protected $logger;
  42.     /**
  43.      * @param AuthorizationCheckerInterface $authChecker
  44.      * @param LoggerInterface               $logger
  45.      */
  46.     public function __construct(
  47.         AuthorizationCheckerInterface $authChecker,
  48.         LoggerInterface $logger
  49.     ) {
  50.         $this->authChecker       = $authChecker;
  51.         $this->logger            = $logger;
  52.     }
  54.     /**
  55.      * {@inheritdoc}
  56.      */
  57.     public function supports($attribute, $subject)
  58.     {
  59.         $isPostStatus           = static::POST_STATUS_ATTR === $attribute;
  60.         $subjectIsStatusPostDTO = $subject instanceof StatusPostDTO;
  62.         return $isPostStatus && $subjectIsStatusPostDTO;
  63.     }
  65.     /**
  66.      * {@inheritdoc}
  67.      */
  68.     public function voteOnAttribute($attribute, $subject, TokenInterface $token)
  69.     {
  70.         $user = $token->getUser();
  72.         switch ($attribute) {
  73.             case static::POST_STATUS_ATTR:
  74.                 return $this->mayPost($subject, $user);
  75.         }
  77.         throw new \LogicException('This code should not be reached!');
  78.     }
  80.     /**
  81.      * Test if a user is allowed to view a request.
  82.      *
  83.      * @param  StatusPostDTO  $dto
  84.      * @param  User           $tokenAttributes
  85.      *
  86.      * @return bool
  87.      */
  88.     protected function mayPost(StatusPostDTO $dto, User $user): bool
  89.     {
  90.         $status  = $dto->getTargetStatus();
  92.         if (!array_key_exists($status, static::ROLES_REQUIREMENTS)) {
  93.             $this->logger->warning('[UserMayPostToStatus] Unknown status requirements: {status}.', [
  94.                 'status' => $status,
  95.             ]);
  97.             return false;
  98.         }
  100.         $requiredRoles = static::ROLES_REQUIREMENTS[$status];
  101.         $roles        = $user->getRoles();
  102.         $hasRole      = (bool) count(array_intersect($requiredRoles, $roles));
  104.         if (!$hasRole) {
  105.             $this->logger->info('[UserMayPostToStatus] User cannot modify status to {status}, because one of the following roles is required {roles}', [
  106.                 'status' => $status,
  107.                 'roles'  => json_encode($requiredRoles),
  108.             ]);
  110.             return false;
  111.         }
  113.         /*
  114.             Things get tricky here. There are two use cases:
  115.             1. the user is Suez, and then only the role check is needed. Suez user can act on every request just on a role-based checked.
  116.             2. the user is client, we need to check both the role, but also if the client is the creator or an admin to avoid one client posting status of another client.
  117.          */
  119.         if (in_array(UserRightsManagerInterface::ROLE_SUEZ, $roles)) {
  120.             $this->logger->info('[UserMayPostToStatus] User can modify status to {status}, since only it only requires a Suez role to do so. Required roles: {roles}', [
  121.                 'status' => $status,
  122.                 'roles'  => json_encode($requiredRoles),
  123.             ]);
  125.             // Suez role is needed here, so we just need to check if the user has the role. 
  127.             return true;
  128.         }
  130.         // Below this point, we must check both the role and the creator id.
  131.         $request            = $dto->getRequest();
  132.         $userIsOwnerOrAdmin = $this->authChecker->isGranted(UserOwnsRequestVoter::USER_OWNS_REQUEST, $request);
  134.         if ($userIsOwnerOrAdmin) {
  135.             $this->logger->info('[UserMayPostToStatus] User can modify status to {status}, since user is either creator or admin.', [
  136.                 'status' => $status,
  137.                 'roles'  => json_encode($requiredRoles),
  138.             ]);
  140.             return true;
  141.         }
  143.         // No need to log anything more in this voter, UserOwnsRequestVoter will already have logged everything relevant.
  145.         return false;
  146.     }
  147. }