src/CoreBundle/Controller/Traits/BaseController.php line 69

Open in your IDE?
  1. <?php
  3. namespace Core\Controller\Traits;
  5. use App\Entity\PageGeneral;
  6. use Core\Entity\Configuration;
  7. use Core\Entity\CookieConfiguration;
  8. use Core\Entity\Design;
  9. use Core\Entity\DesignThemeType;
  10. use Core\Entity\HistoryMessageType;
  11. use Core\Entity\Image;
  12. use Core\Entity\Language;
  13. use Core\Entity\Page;
  14. use Core\Entity\Redirection;
  15. use Core\Entity\RedirectionType;
  16. use Core\Entity\Text;
  17. use Core\Service\History\HistoryMessage;
  18. use Core\Service\Session\Session;
  19. use ReflectionClass;
  20. use Shopping\Entity\Product;
  21. use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
  22. use Symfony\Component\HttpFoundation\Request;
  23. use Symfony\Component\HttpFoundation\Response;
  24. use Symfony\Component\HttpKernel\Exception\NotFoundHttpException;
  25. use Symfony\Component\Validator\Constraints\DateTime;
  26. use User\Entity\AuthorizationGroup;
  27. use User\Entity\AuthorizationType;
  28. use User\Entity\User;
  29. use User\Entity\UserGroup;
  30. use User\Service\UserManager;
  32. trait BaseController
  33. {
  34.     /**
  35.      * @var array - Tableau de variables utilisé pours les templates
  36.      */
  37.     protected $vars = [];
  39.     /**
  40.      * @var Session - Gère l'enregistrement en Session (Session - Database - File) des données
  41.      */
  42.     protected $session;
  44.     /**
  45.      * @var User - Utilisation courant
  46.      */
  47.     protected $user;
  49.     /**
  50.      * @var array UserAuthorization - Authorization de l'utilisateur courant
  51.      */
  52.     protected $user_authorizations;
  54.     /**
  55.      * Constructeur
  56.      */
  57.     public function __construct(Session $session)
  58.     {
  59.         $this->session = $session;
  60.     }
  62.     /**
  63.      * Initialisation du controller
  64.      */
  65.     public function initializeController(Request $request)
  66.     {
  67.         // Désactivation des logs de Doctrine
  68.         if ($_ENV['APP_LOG_DOCTRINE'] == 0) {
  69.             $this->getDoctrine()->getEntityManager()->getConnection()->getConfiguration()->setSQLLogger(null);
  70.         }
  72.         // Configuration générale de l'application
  73.         $this->vars['configuration'] = $this->getDoctrine()->getRepository(Configuration::class)->find(1);
  75.         // Attributions des différentes langues de l'application
  76.         $request = $this->setLanguages($request);
  78.         // Initialisation de la configuration utilisateur
  79.         $this->setUserSettings($request);
  81.         // Définitions du controller à utiliser
  82.         $this->vars['controller'] = $this->findRoute($request);
  84.         return $request;
  85.     }
  87.     /**
  88.      * Initialisation des variables de controller
  89.      */
  90.     public function initializeVariableController(Request $request)
  91.     {
  92.         $this->vars = $request->attributes->get('vars');
  93.     }
  95.     public function resetPageController(Request $request)
  96.     {
  97.         if ($request->attributes->get('vars') != null)
  98.             $this->vars['pages'] = $request->attributes->get('vars')['pages'];
  99.     }
  101.     /**
  102.      * Initialisation des paramètres de langues
  103.      */
  104.     public function setLanguages(Request $request)
  105.     {
  106.         $use_language = 'fr'; // Langue à utiliser par défault
  107.         $locale = 'fr'; // locale à utiliser per défault
  109.         // On récupère les différentes langues actives
  110.         $this->vars['languages']['list'] = $this->getDoctrine()->getRepository(Language::class)->findBy([
  111.             'is_enabled' => 1
  112.         ]);
  114.         // Définition des URLs
  115.         $this->vars['uri']['host'] = $host = $request->headers->get('host');
  116.         $this->vars['uri']['protocol'] = 'http://';
  118.         if ($_ENV['APP_SSL'] == 1) {
  119.             $this->vars['uri']['protocol'] = 'https://';
  120.         }
  122.         $this->vars['uri']['relative'] = $uri = $request->attributes->get('controller');
  123.         $this->vars['uri']['full'] = $this->vars['uri']['protocol'] . $host . $request->getRequestUri();
  125.         // Gestion des paramètres
  126.         $parameters = explode('?', $request->getRequestUri());
  127.         $parametersArray = [];
  129.         if (count($parameters) > 1) {
  130.             $results = explode('&', $parameters[1]);
  132.             foreach ($results as $result) {
  133.                 $object = explode('=', $result);
  135.                 if (count($object) > 1) {
  136.                     $parametersArray[$object[0]] = trim(urldecode($object[1]));
  137.                 }
  138.             }
  139.         }
  141.         $this->vars['uri']['parameters'] = $parametersArray;
  143.         // Définition de la langue via le navigateur || langue par default
  144.         if (isset($_SERVER['HTTP_ACCEPT_LANGUAGE'])) {
  145.             $use_language = substr($_SERVER['HTTP_ACCEPT_LANGUAGE'], 0, 2);
  146.         }
  148.         // Surcharge - Langue via la session
  149.         if ($this->session->has('_locale')) {
  150.             $use_language = $this->session->get('_locale');
  151.         }
  153.         // Surcharge - Langue via l'URL
  154.         if (preg_match('#^/[a-z]{2}/#', '/' . $uri, $matches) || preg_match('#^/[a-z]{2}$#', '/' . $uri, $matches)) {
  155.             $use_language = trim($matches[0], '/');
  156.         }
  158.         // Langues disponibles via le code ISO
  159.         foreach ($this->vars['languages']['list'] as $language) {
  160.             if ($language->getIsoCode() == $use_language) {
  161.                 $locale = $use_language;
  162.                 break;
  163.             }
  164.         }
  166.         // Sauvegarde des variables de langues
  167.         $this->session->set('_locale', $locale); // Sauvegarde en session
  168.         $request->setLocale($locale); // Sauvegarde en request
  169.         $this->vars['languages']['locale'] = $request->getLocale();  // Sauvegarde en variable
  171.         return $request;
  172.     }
  174.     /**
  175.      * Gestion de la configuration utilisateur
  176.      */
  177.     public function setUserSettings(Request $request)
  178.     {
  179.         // Manager d'utilisateur
  180.         $entity = new UserManager($this->getDoctrine());
  182.         // Création d'un utilisateur guest
  183.         $this->user = new User();
  185.         // Récupération de l'utilisateur en session
  186.         $session_content = $this->session->get('user');
  188.         // Session en mémoire
  189.         if ($session_content != null) {
  191.             // Format du contenu
  192.             $this->user->unserialize($session_content);
  194.             // Vérification en base de donnée de l'existance de l'utilisateur
  195.             $this->user = $this->getDoctrine()->getRepository(User::class)->findByUser($this->user);
  197.         }
  199.         // Sinon création d'un visiteur si echec de récupération de l'utilisateur
  200.         if ($session_content == null || $this->user == null || !$entity->checkUser($this->user)) {
  201.             $this->user = $entity->createUser();
  202.         }
  204.         // Autorisations de l'utilisateurs par groupe
  205.         foreach ($this->user->getUserGroups()->toArray() as $group) {
  207.             // On récupère les authorizations du groupe
  208.             $authorizations = $this->getDoctrine()->getRepository(AuthorizationGroup::class)->findBy([
  209.                 'team' => $group->getId()
  210.             ]);
  212.             // Attribution des authorisations par clés
  213.             foreach ($authorizations as $authorization) {
  214.                 $this->user_authorizations[$authorization->getAuthorization()->getDevKey()][] = $authorization;
  215.             }
  217.             if ($this->checkAuthorization($request, [
  218.                 'authorization' => 'administration',
  219.                 'type' => 0
  220.             ])) {
  221.                 $this->vars['account']['admin'] = true;
  222.             }
  223.         }
  226.         // Définitions de la variable utilisateur
  227.         $this->vars['account']['user'] = $this->user;
  228.     }
  230.     /**
  231.      * Vérification de l'autorisation de connexion à l'application
  232.      */
  233.     public function checkAuthorization(Request $request, $params = null)
  234.     {
  236.         // Connexion autorisé par compte
  237.         if ($params != null && array_key_exists('authorization', $params) && array_key_exists('type', $params)) {
  240.             // Abscence de la clé d'authorization des authorizations
  241.             if (!is_array($this->user_authorizations) || !array_key_exists($params['authorization'], $this->user_authorizations)) {
  243.                 // TODO Supprimer cette condition pour accroite la sécurité lors de la création de groupe
  245.                 // Vérification absente - Accès authorisé
  246.                 return false;
  247.             }
  249.             // On récupère la clé d'authorization à vérifier
  250.             $groups = $this->user_authorizations[$params['authorization']];
  253.             // Vérification des authorization pour cette clé
  254.             foreach ($groups as $group) {
  255.                 if (($params['type'] == AuthorizationType::VIEW && $group->getEnableView()) ||
  256.                     ($params['type'] == AuthorizationType::EDIT && $group->getEnableEdit()) ||
  257.                     ($params['type'] == AuthorizationType::NEW && $group->getEnableAdd()) ||
  258.                     ($params['type'] == AuthorizationType::FORM && ($group->getEnableAdd() || $group->getEnableEdit())) ||
  259.                     ($params['type'] == AuthorizationType::REMOVE && $group->getEnableDelete())) {
  261.                     // Vérification réussie - Accès authorisé
  262.                     return true;
  263.                 }
  264.             }
  265.         }
  267.         // Accès refusé
  268.         return false;
  269.     }
  271.     /**
  272.      * Redirige vers le controller adéquate
  273.      */
  274.     public function findRoute(Request $request)
  275.     {
  276.         $this->vars['redirection']['isRedirection'] = false;
  278.         // Redirection s'il y a un '/' en fin d'URL et ce n'est pas la page d'accueil
  279.         if (strlen($this->vars['uri']['relative']) > 4 && substr($this->vars['uri']['relative'], -1) == '/') {
  281.             $this->vars['redirection']['url'] = $this->vars['uri']['protocol'] . $this->vars['uri']['host'] . '/' . $this->vars['languages']['locale'] . '/' . rtrim($this->vars['uri']['relative'], '/');
  282.             $this->vars['redirection']['status'] = 301;
  283.             $this->vars['redirection']['isRedirection'] = true;
  285.             return false;
  286.         }
  288.         // Redirection s'il y a pas de  '/' en fin d'URL et c'est la page d'accueil avec une langue
  289.         if (count($this->vars['languages']['list']) > 1 && strlen($this->vars['uri']['relative']) == 2) {
  291.             $this->vars['redirection']['url'] = $this->vars['uri']['protocol'] . $this->vars['uri']['host'] . '/' . $this->vars['languages']['locale'] . '/';
  292.             $this->vars['redirection']['status'] = 301;
  293.             $this->vars['redirection']['isRedirection'] = true;
  295.             return false;
  296.         }
  298.         // URL de redirection depuis l'administration
  299.         $redirection = $this->findRedirection();
  300.         if ($redirection['find']) {
  302.             $this->vars['redirection']['url'] = $redirection['uri'];
  303.             $this->vars['redirection']['status'] = $redirection['code'];
  304.             $this->vars['redirection']['isRedirection'] = true;
  306.             return false;
  307.         }
  309.         // Redirection s'il manque la langue dans l'URL et que plusieurs langues sont disponibles
  310.         if (count($this->vars['languages']['list']) > 1) {
  311.             if (!preg_match('#^/[a-z]{2}/#', '/' . $this->vars['uri']['relative'], $matches) && !preg_match('#^/[a-z]{2}$#', '/' . $this->vars['uri']['relative'], $matches)) {
  313.                 $this->vars['redirection']['url'] = $this->vars['uri']['protocol'] . $this->vars['uri']['host'] . '/' . $this->vars['languages']['locale'] . '/' . $this->vars['uri']['relative'];
  314.                 $this->vars['redirection']['status'] = 301;
  315.                 $this->vars['redirection']['isRedirection'] = true;
  317.                 return false;
  319.             }
  320.         }
  323.         // Récupération de la liste des pages
  324.         $object = $this->setPages();
  326.         // Attribution de l'URL spécifique à chaque page avec la langue utilisée
  327.         $router = [];
  328.         foreach ($object['pages'] as $key => $page) {
  329.             if ($page['page'] != null) {
  330.                 $element = [
  331.                     'core_page' => $page['core_page'],
  332.                     'page' => $page['page'],
  333.                     'controller_uri' => $page['page']->translate($this->vars['languages']['locale'])->getUri(),
  334.                     'controller_module' => $object['pages_list'][$key]->getControllerModule(),
  335.                     'controller_entity' => $object['pages_list'][$key]->getControllerEntity(),
  336.                     'controller_action' => $object['pages_list'][$key]->getControllerPage(),
  337.                     'controller' => $object['pages_list'][$key]->getController(),
  338.                 ];
  340.                 $element['controller_namespace'] = $element['controller_module'] . '\Controller\\' . $element['controller'];
  342.                 if ($element['controller_namespace'] == 'PageDefault') {
  343.                     $element['controller_namespace'] = 'App\Controller\\' . $element['controller'];
  344.                 }
  346.                 $router[] = $element;
  347.             } else {
  348.                 throw new \Exception('La configuration de la page ' . $object['pages_list'][$key]->getControllerEntity() . ' n\'a pas été générée');
  349.             }
  350.         }
  351. // dump('allo');
  352. // dump($router);
  353. // die;
  354.         // Parcours des différentes routes pour trouver une correspondance
  355.         foreach ($router as $key => $route) {
  357.             // Retourne la chaine sans les parametres '?parameter=value
  358.             $controller_uri = strstr($route['controller_uri'], '?', true);
  360.             if (!$controller_uri) {
  361.                 $controller_uri = $route['controller_uri'];
  362.             }
  364.             // Sauvegarde du controller à utiliser si la route match avec la langue
  365.             if (preg_match('#^\/[a-z]{2}' . $controller_uri . '$#', '/' . $this->vars['uri']['relative'])) {
  366.                 $this->vars['pages']['active'] = $route['page']; // Mémorisation de la page active
  367.                 return $route;
  368.             }
  370.             // Sauvegarde du controller à utiliser si la route match sans la langue
  371.             if (preg_match('#^' . $controller_uri . '$#', '/' . $this->vars['uri']['relative'])) {
  372.                 $this->vars['pages']['active'] = $route['page']; // Mémorisation de la page active
  373.                 return $route;
  374.             }
  376.         }
  378.         // Recherche d'une URL personnalisée
  379.         return null;
  380.     }
  382.     /**
  383.      * Recherche d'une URL de redirection depuis la table "Redirection"
  384.      */
  385.     private function findRedirection()
  386.     {
  387.         $redirection_find = false;
  388.         $redirection_code = -1;
  389.         $redirection_uri = '';
  391.         // Recherche d'une correspondance dans le tableau des redirections
  392.         $this->vars['uri']['redirection'] = $redirection = $this->getDoctrine()->getRepository(Redirection::class)->findOneBy([
  393.             'uri_from' => '/' . $this->vars['uri']['relative']
  394.         ]);
  396.         if ($redirection != null) {
  398.             // Redirection détectée
  399.             $redirection_find = true;
  401.             // URL de redirection
  402.             $redirection_uri = $this->vars['redirection']->getUriTo();
  404.             // Attribution du type de redirection
  405.             switch ($redirection->getType()) {
  406.                 case RedirectionType::TEMPORARY_REDIRECT:
  407.                     $redirection_code = 302;
  408.                     break;
  410.                 case RedirectionType::PERMANENT_REDIRECT:
  411.                     $redirection_code = 301;
  412.                     break;
  414.                 case RedirectionType::NO_REDIRECTION:
  415.                 default:
  416.                     $redirection_code = 404;
  417.                     $redirection_uri = $this->vars['pages']['error404']->translate($this->vars['locale']);
  418.                     break;
  419.             }
  421.         }
  423.         return [
  424.             'find' => $redirection_find,
  425.             'code' => $redirection_code,
  426.             'uri' => $redirection_uri
  427.         ];
  428.     }
  430.     /**
  431.      * Attribution de la liste des pages disponibles
  432.      */
  433.     public function setPages()
  434.     {
  435.         // On récupère la liste des pages actives accessibles
  436.         $pages_list = $this->getDoctrine()->getRepository(Page::class)->findBy([
  437.             'is_enabled' => 1
  438.         ]);
  440.         // On récupère la configuration spécifique de chaque page
  441.         $pages = [];
  442.         foreach ($pages_list as $page) {
  443.             $class = $page->getControllerModule() . '\Entity\\' . $page->getControllerEntity();
  445.             if ($page->getControllerEntity() == 'PageDefault') {
  446.                 $class = 'App\Entity\\' . $page->getControllerEntity();
  447.             }
  449.             $pages[] = [
  450.                 'core_page' => $page,
  451.                 'page' => $this->getDoctrine()->getRepository($class)->find($page->getControllerId())
  452.             ];
  453.         }
  455.         // Passage des pages à la vue
  456.         foreach ($pages as $key => $page) {
  457.             $this->vars['pages']['list'][$pages_list[$key]->getControllerPage()] = $page['page'];
  458.             $this->vars['pages']['core'][$pages_list[$key]->getControllerPage()] = $page['core_page'];
  459.         }
  461.         return [
  462.             'pages_list' => $pages_list, // Liste de toutes les pages actives 'Core/Pages'
  463.             'pages' => $pages // Liste de toutes les pages actives 'App/PageHome, App/PageContact, ..'
  464.         ];
  465.     }
  467.     /**
  468.      * Gestion de la configuration de la page active
  469.      */
  470.     public function setPageSettings(Request $request, $page_name)
  471.     {
  472.         $page = $this->vars['pages']['active'];
  473.         $general = $this->vars['pages']['list']['general'];
  475.         // Liste des URL par langue
  476.         $uris = [];
  477.         foreach ($this->vars['languages']['list'] as $language) {
  478.             $uris = array_merge($uris, [
  479.                 $language->getIsoCode() => '/' . $language->getIsoCode() . $page->translate($language->getIsoCode())->getUri()
  480.             ]);
  481.         }
  482.         $this->vars['uri']['alternate'] = $uris;
  484.         // Paramètre spécifique à la page
  485.         $seo_title = $page->getSeoTitle();
  486.         $seo_description = $page->getSeoDescription();
  487.         $seo_keywords = $page->getSeoKeywords();
  488.         $sn_title = $page->getSnTitle();
  489.         $sn_description = $page->getSnDescription();
  490.         $sn_image_twitter = $page->getTwitter();
  491.         $sn_image_social_networks = $page->getFacebook();
  493.         // Recoupement avec les paramètres par defaut de l'application
  494.         if ($seo_title == null) $seo_title = $general->getSeoTitle();
  495.         if ($seo_description == null) $seo_description = $general->getSeoDescription();
  496.         if ($seo_keywords == null) $seo_keywords = $general->getSeoKeywords();
  497.         if ($sn_title == null) $sn_title = $general->getSnTitle();
  498.         if ($sn_description == null) $sn_description = $general->getSnDescription();
  499.         if ($sn_image_twitter == null) $sn_image_twitter = $general->getTwitter();
  500.         if ($sn_image_social_networks == null) $sn_image_social_networks = $general->getFacebook();
  502.         // Restitution des paramètres à la vue
  503.         $this->vars['seo']['title'] = $seo_title;
  504.         $this->vars['seo']['description'] = $seo_description;
  505.         $this->vars['seo']['keywords'] = $seo_keywords;
  507.         $this->vars['sn']['title'] = $sn_title;
  508.         $this->vars['sn']['description'] = $sn_description;
  509.         $this->vars['sn']['image_twitter'] = $sn_image_twitter;
  510.         $this->vars['sn']['image_social_networks'] = $sn_image_social_networks;
  512.         $this->vars['website']['domain'] = $this->vars['configuration']->getDomain();
  513.         $this->vars['website']['name'] = $this->vars['configuration']->getSitename();
  515.     }
  517.     /**
  518.      *  Retourne le template adequate
  519.      */
  520.     public function generateTemplate($path, $vars = [], $json = false)
  521.     {
  522.         // Ajoute l'extension si elle n'existe pas
  523.         if (!strpos($path, '.html.twig')) {
  524.             $path = $path . '.html.twig';
  525.         }
  527.         if (!$json) {
  529.             // On récupère le chemin complet du potentielle template
  530.             $file = $this->getParameter('file_templates') . str_replace('@', '', $path);
  532.             // Si le fichier de redéfinition n'existe pas "list" / "form" / "view" utilise le fichier par default (Ex: entity_list.html.twig)
  533.             if (!file_exists($file)) {
  535.                 $theme = '@core/admin';
  536.                 if (preg_match("#(.)+_list.html.twig#", $path)) {
  537.                     $path = $theme . '/entity_list.html.twig';
  538.                 } else if (preg_match("#(.)+_form.html.twig#", $path)) {
  539.                     $path = $theme . '/entity_form.html.twig';
  540.                 } else if (preg_match("#(.)+_view.html.twig#", $path)) {
  541.                     $path = $theme . '/entity_view.html.twig';
  542.                 }
  544.             }
  546.             // Retourne le template généré
  547.             return $this->render($path, array_merge($this->vars, $vars));
  549.         } else {
  551.             // Retourne le template pouvant être rendu en json
  552.             return $this->renderView($path, array_merge($this->vars, $vars));
  553.         }
  554.     }
  556.     /**
  557.      * Page d'exception - Erreur 404 - Ressource introuvable
  558.      */
  559.     public function redirectNotFoundException($request)
  560.     {
  561.         // Définition de la page active
  562.         $this->vars['pages']['active'] = $this->vars['pages']['list']['page_default_5fc8fb6f41b02'];
  564.         // Configuration de la page
  565.         $this->setPageSettings($request, 'page_default_5fc8fb6f41b02');
  566.         $template = $this->vars['pages']['core']['page_default_5fc8fb6f41b02']->getTemplate();
  568.         $response = $this->generateTemplate('@' . $template->getModule() . '/' . $template->getName());
  569.         $response->setStatusCode(Response::HTTP_NOT_FOUND);
  570.         return $response;
  571.     }
  573.     /**
  574.      * Page d'exception - Erreur 403 - Accès refusé
  575.      */
  576.     public function redirectConnexionRequiredException($request)
  577.     {
  578.         // Définition de la page active
  579.         $this->vars['pages']['active'] = $this->vars['pages']['list']['page_default_5fc8fcc13ab1b'];
  581.         // Configuration de la page
  582.         $this->setPageSettings($request, 'page_default_5fc8fcc13ab1b');
  583.         $template = $this->vars['pages']['core']['page_default_5fc8fcc13ab1b']->getTemplate();
  585.         $response = $this->generateTemplate('@' . $template->getModule() . '/' . $template->getName());
  586.         $response->setStatusCode(Response::HTTP_FORBIDDEN);
  587.         return $response;
  588.     }
  590.     /**
  591.      * Page d'exception - Erreur quelconque
  592.      */
  593.     public function redirectUnknownException($request)
  594.     {
  595.         // Définition de la page active
  596.         $this->vars['pages']['active'] = $this->vars['pages']['list']['page_default_5fc8fda129a38'];
  598.         // Configuration de la page
  599.         $this->setPageSettings($request, 'page_default_5fc8fda129a38');
  600.         $template = $this->vars['pages']['core']['page_default_5fc8fda129a38']->getTemplate();
  602.         $response = $this->generateTemplate('@' . $template->getModule() . '/' . $template->getName());
  603.         $response->setStatusCode(Response::HTTP_NOT_FOUND);
  604.         return $response;
  605.     }
  607.     /**
  608.      * Permet de recupérer des morceaux de l'URL de la $request
  609.      */
  610.     public function getCurrentPageSlug($request, $position = 1)
  611.     {
  612.         // Récupération du slug
  613.         $slug = trim($request->getRequestUri(), '/');
  615.         if (preg_match('#^(.){2}/(.)+$#', $slug, $matches)) {
  616.             $slug = substr($slug, 3);
  617.         }
  619.         $slug = explode('/', $slug)[$position];
  621.         $result = strstr($slug, '?', true);
  622.         if ($result != false) {
  623.             $slug = $result;
  624.         }
  626.         return $slug;
  627.     }
  629.     /**
  630.      * Retourne null ou un object de la $class ayant pour URL le $slug
  631.      */
  632.     public function getEntityBySlug($slug, $class)
  633.     {
  634.         preg_match('/^([0-9]+)-(.)+/', $slug, $matches, PREG_OFFSET_CAPTURE);
  636.         if (count($matches) < 1) {
  637.             return null;
  638.         }
  640.         $object = $this->getDoctrine()->getRepository($class)->find($matches[1][0]);
  642.         if ($object == null) {
  643.             return null;
  644.         }
  646.         if ($object->getSlug() != '/' . $slug) {
  647.             return null;
  648.         }
  650.         return $object;
  651.     }
  653.     public function getEntitiesRandom($class, $limit = 8)
  654.     {
  656.         $items = $this->getDoctrine()->getRepository($class)
  657.             ->findEntityActive();
  659.         shuffle($items);
  661.         $results = [];
  663.         for ($i = 0; $i < $limit; $i++) {
  664.             if(array_key_exists($i, $items)) {
  665.                 $results[] = $this->getDoctrine()->getRepository($class)
  666.                     ->find($items[$i]['id']);
  667.             }
  668.         }
  670.         if ($class == Product::class) {
  671.             $list = [];
  672.             foreach ($results as $object) {
  674.                 $item = new \Shopping\Service\Product\Product($this->getDoctrine(), $this->vars['account']['user']);
  675.                 $item->createProduct($object->getId());
  677.                 $list[] = $item;
  678.             }
  680.             $results = $list;
  681.         }
  683.         return $results;
  684.     }
  686.     public function getEntitiesPerPagination($class, $pagination = 1, $filters = [], $productPaginationNumber = 50, $useProductService = true, $constraintes = [])
  687.     {
  688.         $results = [];
  690.         // Recherche des produits de la catégorie trouvée
  691.         $results['pagination']['product_per_page'] = $productPaginationNumber;
  692.         $results['pagination']['current_page'] = $pagination;
  694.         $reflection = new $class();
  695.         $reflects = (new ReflectionClass($reflection))->getProperties();
  696.         $properties = [];
  697.         foreach ($reflects as $item){
  698.             $properties[] = (string)$item->getName();
  699.         }
  701.         $results['list'] = $this->getDoctrine()->getRepository($class)
  702.             ->findEntityPerPagination($pagination, $productPaginationNumber, $filters, $constraintes, $properties);
  704.         $results['count'] = $this->getDoctrine()->getRepository($class)
  705.             ->countEntityPerPagination($constraintes, $properties);
  707.         $results['pagination']['count'] = ceil($results['count'] / $productPaginationNumber);
  709.         $start = $pagination * $productPaginationNumber - $productPaginationNumber;
  710.         if ($start <= 0) {
  711.             $start = 0;
  712.         }
  714.         $end = $start + $productPaginationNumber;
  716.         if ($end > $results['count']) {
  717.             $end = $results['count'];
  718.         }
  720.         $results['pagination']['start'] = $start + 1;
  721.         $results['pagination']['end'] = $end;
  722.         $results['pagination']['total'] = $results['count'];
  724.         if ($class == Product::class && $useProductService) {
  725.             $list = [];
  726.             foreach ($results['list'] as $object) {
  728.                 $item = new \Shopping\Service\Product\Product($this->getDoctrine(), $this->vars['account']['user']);
  729.                 $item->createProduct($object->getId());
  731.                 $list[] = $item;
  732.             }
  734.             $results['list'] = $list;
  735.         }
  737.         return $results;
  738.     }
  740.     public function getProductsListPagination($categories_list, $pagination, $filters, $products_per_pagination, $contraintes)
  741.     {
  742.         $results = [];
  744.         $products = $this->getDoctrine()->getRepository(Product::class)->findProductsChildrenPerPagination($filters, [
  745.             'is_enabled' => true,
  746.             'categories' => $categories_list,
  747.         ]);
  749.         foreach ($products as $product) {
  750.             if (!in_array($product->getParent()->getId(), $results)) {
  751.                 $results[] = $product->getParent()->getId();
  752.             }
  753.         }
  755.         $products = $this->getDoctrine()->getRepository(Product::class)->findProductsParentPerPagination($filters, [
  756.             'is_enabled' => true,
  757.             'categories' => $categories_list,
  758.         ]);
  761.         foreach ($products as $product) {
  762.             if (!in_array($product->getId(), $results)) {
  763.                 $results[] = $product->getId();
  764.             }
  765.         }
  767.         $start = $pagination * $products_per_pagination - $products_per_pagination;
  768.         $end = $pagination * $products_per_pagination;
  769.         $product_per_page = $products_per_pagination;
  770.         $current_page = $pagination;
  772.         if (count($results) > 0) {
  773.             $count = ceil(count($results) / $products_per_pagination);
  774.         } else {
  775.             $count = 1;
  776.         }
  778.         if ($end > $count * $products_per_pagination) {
  779.             $end = $count;
  780.         }
  782.         $list = [];
  784.         foreach ($results as $key => $object) {
  785.             if ($start <= $key && $key < $end) {
  786.                 $product = $this->getDoctrine()->getRepository(Product::class)->find($object);
  787.                 $item = new \Shopping\Service\Product\Product($this->getDoctrine(), $this->vars['account']['user']);
  788.                 $item->createProduct($product->getId());
  790.                 $list[] = $item;
  791.             }
  792.         }
  794.         $results['list'] = $list;
  796.         $results['pagination']['current_page'] = $current_page;
  797.         $results['pagination']['product_per_page'] = $product_per_page;
  798.         $results['pagination']['start'] = $start;
  799.         $results['pagination']['end'] = $end;
  800.         $results['pagination']['count'] = $count;
  801.         $results['pagination']['total'] = count($results);
  804.         $this->vars['products'] = $results;
  806.         return $results;
  807.     }
  808. }