Symfony Profiler

<?php
//------------------------------------------------------------------------------
// src/Security/ArticleCommentVoter.php
//------------------------------------------------------------------------------
namespace App\Security;
use Symfony\Component\Security\Core\Authentication\Token\TokenInterface;
use Symfony\Component\Security\Core\Authorization\Voter\Voter;
use Doctrine\Persistence\ManagerRegistry;
use App\Entity\Access;
use App\Entity\APIRest\AccessAPI;
use App\Entity\Config\Config;
use App\Entity\Config\Module;
use App\Entity\HR\AccessFunction;
use App\Entity\Media\Comment;
use App\Entity\Security\Acl;
use App\Entity\Security\AclArticle;
use App\Entity\Security\AclPermission;
use App\Services\Config\ModuleTools;
class ArticleCommentVoter extends Voter
{
//--------------------------------------------------------------------------------
// is_granted constants
const APPROVE = "approve_comment";
const DELETE = "delete_comment";
const MODERATION = "comment_moderation";
const IS_GRANTED_CONSTANTS = array(
self::APPROVE,
self::DELETE,
self::MODERATION,
);
//--------------------------------------------------------------------------------
// acl constants
const ACL_PERM_APPROVE = "article_comment_approve";
const ACL_PERM_APPROVE_OWN_ARTICLE = "article_comment_approve_own_article";
const ACL_PERM_DELETE = "article_comment_delete";
const ACL_PERM_DELETE_OWN_ARTICLE = "article_comment_delete_own_article";
const ACL_PERM_DELETE_OWN = "article_comment_delete_own";
//--------------------------------------------------------------------------------
public function __construct(ManagerRegistry $doctrine, ModuleTools $moduleTools)
{
$this->em = $doctrine->getManager();
$this->moduleTools = $moduleTools;
$this->aclRepository = $this->em->getRepository(Acl::class);
$this->aclPermissionRepository = $this->em->getRepository(AclPermission::class);
}
// Plan.io Task #4453 [See AccessVoter for details]
public function supportsAttribute(string $attribute): bool
{
return in_array($attribute, self::IS_GRANTED_CONSTANTS, true);
}
protected function supports(string $attribute, $subject): bool
{
// if the attribute isn't one we support, return false
if (!in_array($attribute, self::IS_GRANTED_CONSTANTS))
{
return false;
}
// only vote on Comment objects inside this voter
if ($subject !== null && !$subject instanceof Comment)
{
return false;
}
return true;
}
protected function voteOnAttribute(string $attribute, $subject, TokenInterface $token): bool
{
$user = $token->getUser();
// Plan.io Task #3707
if ($user instanceof AccessAPI)
{
if ($user->getAccess() === null)
{
return false;
}
$user = $user->getAccess();
}
// Plan.io Task #3707
// At this point $user is an object of Access type
// even if the $token->getUser() is AccessAPI
if (!$user instanceof Access)
{
// the user must be logged in; if not, deny access
return false;
}
// The user must have a function; if not deny access
$function = $user->getFunction();
if ($function === null) return false;
// Plan.io Task #3710 : Get current group
$currentGroup = $user->getSocietyGroup();
if ($currentGroup === null)
return false;
// Module activated ?
if ($this->moduleTools->isInactiveByCode($currentGroup, Module::MODULE_ARTICLE))
{
return false;
}
// you know $subject is a Comment object, thanks to supports
/** @var Comment $comment */
$comment = $subject;
// Check current group affectation
if ($subject !== null && $subject->getArticle() !== null)
{
$subjectGroup = $subject->getArticle()->getSocietyGroup();
if ($subjectGroup === null)
return false;
if (!$currentGroup->equals($subjectGroup))
return false;
}
switch ($attribute)
{
case self::DELETE:
return $this->canDelete($comment, $user, $function);
case self::APPROVE:
return $this->canApprove($comment, $user, $function);
case self::MODERATION:
return $this->canModerate($user, $function);
}
throw new \LogicException('This code should not be reached!');
}
// $access is the user trying to load the resource
// $comment is the resource being loaded
private function checkAuthor(Comment $comment, Access $access)
{
$author = $comment->getAuthor();
if ($author === null)
return false;
if ($author->getId() == $access->getId())
return true;
return false;
}
// $access is the user trying to load the resource
// $comment is the resource being loaded
private function checkArticleAuthor(Comment $comment, Access $access)
{
$article = $comment->getArticle();
if ($article === null)
return false;
$author = $article->getAuthor();
if ($author === null)
return false;
if ($author->getId() == $access->getId())
return true;
return false;
}
private function canModerate(Access $user, AccessFunction $function)
{
// Get AclPermissions
$aclPerm = $this->aclPermissionRepository->findOneByName(self::ACL_PERM_APPROVE);
$aclPermOwnArticle = $this->aclPermissionRepository->findOneByName(self::ACL_PERM_APPROVE_OWN_ARTICLE);
// If all are null, exit
if ($aclPerm === null && $aclPermOwnArticle)
return false;
// Get First one
if ($aclPerm !== null)
{
$acl = $this->aclRepository->findOneBy(array(
'function' => $function,
'permission' => $aclPerm
));
if ($acl !== null)
{
if ($acl->getValue())
{
// A single positive answer is enough
return true;
}
}
}
// If we are here it means that nothing good has been found
// Load second permission
if ($aclPermOwnArticle !== null)
{
$acl = $this->aclRepository->findOneBy(array(
'function' => $function,
'permission' => $aclPermOwnArticle
));
if ($acl !== null)
{
if ($acl->getValue())
{
/// A single positive answer is enough
return true;
}
}
}
// If we are here, all hope is lost
return false;
}
private function canApprove(Comment $comment, Access $user, AccessFunction $function)
{
// Get AclPermissions
$aclPerm = $this->aclPermissionRepository->findOneByName(self::ACL_PERM_APPROVE);
$aclPermOwnArticle = $this->aclPermissionRepository->findOneByName(self::ACL_PERM_APPROVE_OWN_ARTICLE);
// If all are null, exit
if ($aclPerm === null && $aclPermOwnArticle)
return false;
// Get First one
if ($aclPerm !== null)
{
$acl = $this->aclRepository->findOneBy(array(
'function' => $function,
'permission' => $aclPerm
));
if ($acl !== null)
{
if ($acl->getValue())
{
// A single positive answer is enough
return true;
}
}
}
// If we are here it means that nothing good has been found
// Load second permission
if ($aclPermOwnArticle !== null)
{
$acl = $this->aclRepository->findOneBy(array(
'function' => $function,
'permission' => $aclPermOwnArticle
));
if ($acl !== null)
{
if ($acl->getValue())
{
// A single positive answer is enough
// In this case the good answer will be provided by the checkSociety
return $this->checkArticleAuthor($comment, $user);
}
}
}
// If we are here, all hope is lost
return false;
}
private function canDelete(Comment $comment, Access $user, AccessFunction $function)
{
// Always allow deleting own's comments
if ($this->checkAuthor($comment, $user))
return true;
// Get AclPermissions
$aclPerm = $this->aclPermissionRepository->findOneByName(self::ACL_PERM_DELETE);
$aclPermOwnArticle = $this->aclPermissionRepository->findOneByName(self::ACL_PERM_DELETE_OWN_ARTICLE);
// If all are null, exit
if ($aclPerm === null && $aclPermOwnArticle === null)
return false;
// Get First one
if ($aclPerm !== null)
{
$acl = $this->aclRepository->findOneBy(array(
'function' => $function,
'permission' => $aclPerm
));
if ($acl !== null)
{
if ($acl->getValue())
{
// A single positive answer is enough
return true;
}
}
}
// If we are here it means that nothing good has been found
// Load second permission
if ($aclPermOwnArticle !== null)
{
$acl = $this->aclRepository->findOneBy(array(
'function' => $function,
'permission' => $aclPermOwnArticle
));
if ($acl !== null)
{
if ($acl->getValue())
{
// A single positive answer is enough
// In this case the good answer will be provided by the checkSociety
return $this->checkArticleAuthor($comment, $user);
}
}
}
// If we are here, all hope is lost
return false;
}
}

src/Security/ArticleCommentVoter.php line 22