vendor/theatre/core/src/Repository/KeywordsRepository.php line 322

Open in your IDE?
  1. <?php
  3. namespace TheatreCore\Repository;
  5. use TheatreCore\Entity\Keywords;
  6. use TheatreCore\Traits\TheatreTrait;
  7. use Doctrine\Bundle\DoctrineBundle\Repository\ServiceEntityRepository;
  8. use Doctrine\Persistence\ManagerRegistry;
  10. /**
  11.  * KeywodsRepository
  12.  *
  13.  * This class was generated by the Doctrine ORM. Add your own custom
  14.  * repository methods below.
  15.  */
  16. class KeywordsRepository extends ServiceEntityRepository
  17. {
  19.     use TheatreTrait;
  21.     private $em;
  22.     public $__table;
  23.     public $__table_object;
  24.     public $__idtable;
  26.     public function __construct(ManagerRegistry $registry)
  27.     {
  28.         parent::__construct($registry, Keywords::class);
  29.         $this->__table = $this->getClassMetadata()->getTableName();
  30.         $this->__table_object = $this->getClassMetadata()->name;
  31.         $this->__idtable = $this->getClassMetadata()->getSingleIdentifierFieldName();
  32.     }
  34.     //  {{{ findData()
  36.     /** Recherche d'keyword
  37.      *
  38.      * Permet de rechercher des keywords selon différents critères
  39.      *
  40.      * @access  public
  41.      * @see     Theatre::find()
  42.      */
  43.     public function findData($idclassification = null)
  44.     {
  46.         // parametres
  47.         if (isset($_REQUEST['keywords']) && $_REQUEST['keywords'] != 'nom') {
  48.             $keywords = filter_var(trim($_REQUEST['keywords']));
  49.         }
  50.         if (isset($_REQUEST['idkeyword']) && my_is_int($_REQUEST['idkeyword'])) {
  51.             $idkeyword = (int)$_REQUEST['idkeyword'];
  52.         }
  54.         $query = $this->createQueryBuilder('e');
  56.         if ($this->getCount()) {
  57.             $query->select('COUNT(e.idkeyword)');
  59.             $this->setCount(false);
  61.             return $query;
  62.         }
  64.         // query perso
  65. //        $query = 'SELECT * FROM '.$this->__table.'
  66. //                    WHERE  1';
  67. //
  68. //        //recherche stricte par id
  69. //        if(!empty($idkeyword)) {
  70. //            $query .= ' AND cl.idkeyword='.(int)$idkeyword;
  71. //        } else {
  72. //            // mots cles
  73. //            if (!empty($keywords)) {
  74. //                $query .= ' AND title LIKE \'%'.$this->escape($keywords).'%\' ';
  75. //            }
  76. //        }
  78.         // on lance la recherche
  79.         return $query->getQuery();
  81.     }
  83.     // }}}
  85.     //  {{{ setToArray()
  87.     /** Liste des keywords dans un tableau associatif
  88.      *
  89.      * Tableau associatif notament utilisé pour lister les informations sur des keywords
  90.      * Utile pour générer les tableaux HTML de listes de keywords
  91.      *
  92.      * @access  public
  93.      * @return  array
  94.      * @see     findData()
  95.      */
  96.     public function setToArray($spec = true)
  97.     {
  98.         if ($spec == true) {
  99.             $this->findData();
  100.         }
  102.         $values = array();
  103.         $color = null;
  104.         $nb = 0;
  106.         while ($this->fetch()) {
  108.             $values[$nb] = $this->getInfosKeyword();
  109.             $values[$nb]['id'] = $this->idkeyword;
  111.             // couleur de ligne alternative
  112.             $color = $this->colorAlternate($color);
  113.             $values[$nb]['colorline'] = $color;
  115.             $nb++;
  116.         }
  118.         return $values;
  119.     }
  121.     // }}}
  123.     //  {{{ getInfosKeyword()
  125.     /** Informations sur une keyword
  126.      *
  127.      * @access public
  128.      * @param int $idkeyword Identifiant de l'keyword
  129.      * @return array
  130.      */
  131.     public function getInfosKeyword($idkeyword = null, $params = array())
  132.     {
  134.         $infos = array();
  136.         ////////////// infos de la table
  137.         if (empty($this->idkeyword)) {
  138.             $data = $this->get($idkeyword);
  139.             $this->loadResult($data);
  140.         }
  142.         $infos += array(
  143.             'idkeyword' => $this->idkeyword,
  144.             'title' => $this->title,
  145.             'url_clean' => $this->url_clean,
  146.             'dateupdate' => $this->dateupdate,
  147.             'dateinsert' => $this->dateinsert,
  148.             'publish' => $this->publish,
  149.         );
  151.         $infos['nameview'] = $this->title;
  153.         return $infos;
  155.     }
  157.     // }}}
  159.     //  {{{ getObjectTitle()
  161.     /** Infos de l'item recherché
  162.      *
  163.      *
  164.      * @access public
  165.      * @param int $idobject Identifiant de l'item
  166.      * @param array $infos_object Informations pour construire le titre
  167.      * @param array $params Paramétres supplémentaires
  168.      * @return string|array
  169.      */
  170.     public function getObjectTitle($idobject = null, $infos_object = array(), $params = array())
  171.     {
  173.         if (!$idobject && isset($this->idkeyword)) $idobject = $this->idkeyword;
  175.         // champs
  176.         $fields = array('idkeyword', 'title', 'url_clean');
  178.         if (!empty($infos_object)) {
  180.             foreach ($fields as $k => $v) {
  181.                 if (array_key_exists($v, $infos_object)) {
  182.                     $infos[$v] = $infos_object[$v];
  183.                 } else {
  184.                     $infos[$v] = '';
  185.                 }
  186.             }
  188.         } else {
  190.             //charger les infos que si necessaire
  191.             if (empty($this->title)) {
  193.                 $sql = 'SELECT ' . implode(',', $fields) . ' 
  194.                         FROM ' . $this->__table . ' 
  195.                         WHERE ' . $this->__idtable . '=' . $idobject;
  197.                 $infos = $this->queryRow($sql);
  199.             } else {
  200.                 foreach ($fields as $k => $v) {
  201.                     if (isset($this->$v) && $this->$v != '') {
  202.                         $infos[$v] = trim($this->$v);
  203.                     } else {
  204.                         $infos[$v] = '';
  205.                     }
  206.                 }
  207.             }
  209.         }
  211.         // renvoyer un array plutôt que le titre (utile si on veux l'url)
  212.         if (array_key_exists('return_array', $params)) {
  213.             return $infos;
  214.         }
  216.         return $infos['title'];
  218.     }
  220.     // }}}
  222.     //  {{{ getListSearch()
  224.     /** Liste des keywords
  225.      *
  226.      * Pour les champs Ajax de relations et les recherches diverses
  227.      *
  228.      * @access  public
  229.      * @param string $lettres Pour la recherche alphabetique
  230.      * @param string $type Pour le type recherche (editeurs, revues...)
  231.      * @param string $keywords Recherche par mots cles
  232.      * @return  array
  233.      */
  234.     public function getListSearch($lettre, $type = null, $keywords = null)
  235.     {
  236.         $sql = 'SELECT k.idkeyword, k.title
  237.                  FROM ' . $this->__table . ' k 
  238.                  WHERE 1 ';
  240.         // selection par ordre alpha
  241.         if (!empty($lettre) && $lettre != 'tous') {
  242.             $sql_where[] = array('LOWER(LEFT(LTRIM(title),1))=\'' . $this->escape($lettre) . '\'');
  243.         }
  245.         // recherche avec un mot cle
  246.         $list = $this->splitKeywords($keywords);
  248.         if ($list) {
  249.             if (!empty($list[$this->IDSTR])) {
  250.                 // mots clés
  251.                 foreach ($list[$this->IDSTR] as $s) {
  252.                     $sql_more_name[] = 'title LIKE \'%' . $s . '%\'';
  253.                 }
  254.                 $sql_where[] = array('(' . join(' OR ', $sql_more_name) . ')');
  255.             }
  256.             if (!empty($list[$this->IDNUM])) {
  257.                 // recherche par numéro d'id pour les mots clés numériques
  258.                 $sql_where[] = array('idkeyword IN (' . implode(',', $list[$this->IDNUM]) . ')', 'OR');
  259.             }
  260.         }
  262.         if (!empty($sql_where)) {
  263.             foreach ($sql_where as $k => $v) {
  264.                 if (!empty($v[1])) {
  265.                     $sql .= ' ' . $v[1] . ' ' . $v[0];
  266.                 } else {
  267.                     $sql .= ' AND ' . $v[0];
  268.                 }
  269.             }
  270.         }
  272.         $sql .= ' ORDER BY title';
  274.         $this->query($sql);
  276.         $r = array();
  278.         while ($this->fetch()) {
  279.             $r[$this->idkeyword] = $this->title;
  280.             // si trouvé par id, on l'affiche en fin de titre
  281.             if (!empty($list[$this->IDNUM]) && in_array($this->idkeyword, $list[$this->IDNUM])) {
  282.                 $r[$this->idkeyword] .= ' - n°' . $this->idkeyword;
  283.             }
  284.         }
  285.         $this->free();
  287.         return $r;
  288.     }
  290.     // }}}
  292.     //  {{{ getListKeywords()
  294.     /** Retourne des listes des keywords
  295.      *
  296.      * Retourne des listes de keywords au format "standard""
  297.      *
  298.      * @access   public
  299.      * @param array $params_sql paramètre pour la requete SQL
  300.      * @param array $format_vignette de la vignette si pas standard
  301.      * @param array $params_display paramètre pour l'affichage
  302.      * @return   array
  303.      */
  304.     public function getListKeywords($params_sql = null, $format_vignette = array(), $params_display = array())
  305.     {
  307.         // si pas de tableau
  308.         if (!isset($params_sql['special'])) {
  309.             $params_sql['special'] = array();
  310.         }
  311.         if (!isset($params_sql['params'])) {
  312.             $params_sql['params'] = array();
  313.         }
  315.         // construction de la requête avec le passage de paramètres
  316.         $sql = $this->getSQLKeywords($params_sql);
  318.         // paramètre de debug
  319.         $dbg = (empty($params_sql['dbg'])) ? array() : $dbg = $params_sql['dbg'];
  321.         // executer la requete
  322.         $this->query($sql, $dbg);
  323.         $videos = array();
  325.         // donnée entières ?
  326.         if (empty($params_display['alldata'])) {
  327.             $params_display['alldata'] = false;
  328.         }
  330.         // debug
  331.         $start_boucle = microtime(true);
  333.         $keywords = array();
  335.         // on boucle
  336.         while ($this->fetch()) {
  337.             $idkeyword = $this->idkeyword;
  338.             if (!empty($params_sql['fields'])) {
  339.                 foreach ($params_sql['fields'] as $f) {
  340.                     $keywords[$idkeyword][$f] = $this->$f;
  341.                 }
  342.             } else {
  343.                 $keywords[$idkeyword] = $this->getInfosKeyword($idkeyword);
  344.             }
  345.         }
  347.         // debug de la boucle
  348.         if ($this->isTraceMode('list_object')) {
  349.             $this->setTraceInfos(array(
  350.                 'execution_time_boucle' => microtime(true) - $start_boucle,
  351.                 'nb_occurence' => count($keywords),
  352.                 'dbg' => $dbg,
  353.             ));
  354.         }
  356.         $this->free();
  358.         return $keywords;
  360.     }
  362.     // }}}
  364.     //  {{{ countListKeywords()
  366.     /** Compter la liste des keywords
  367.      *
  368.      * @access   public
  369.      * @param array $params_sql paramètre pour la requete SQL
  370.      * @param bool $debug mode débugage
  371.      * @return   int
  372.      */
  373.     public function countListKeywords($params_sql = null, $debug = false)
  374.     {
  376.         // si pas de limite => tout
  377.         if (empty($params_sql['limit'])) {
  378.             $params_sql['limit'] = array('all');
  379.         }
  381.         $params_sql['special']['count_only'] = true;
  383.         // construction de la requête avec le passage de paramètres
  384.         return $this->queryOne($this->getSQLKeywords($params_sql, $debug));
  386.     }
  388.     // }}}
  390.     //  {{{ getSQLKeywords()
  392.     /** Générer la requete standard pour des keywords
  393.      *
  394.      * @access   public
  395.      * @param array $aueru Les paramètres pour la requete
  396.      * @param bool $debug afficher la requête
  397.      * @return   string
  398.      */
  399.     public function getSQLKeywords($query = array(), $debug = false)
  400.     {
  402.         // on prepare les tableaux
  403.         foreach (array('select', 'from', 'where', 'order', 'group', 'limit') as $t) {
  404.             if (!empty($query[$t])) {
  405.                 if (!is_array($query[$t])) {
  406.                     $query[$t][] = $query[$t];
  407.                 } else {
  408.                     $query[$t] = $query[$t];
  409.                 }
  410.             } else {
  411.                 $query[$t] = array();
  412.             }
  413.         }
  415.         // champs par défaut
  416.         $this->addSQLParams('select', $query, array(
  417.             array('keywords' => '*')
  418.         ));
  420.         // publié ou pas
  421.         if (empty($query['publish']) && $_ENV['CHECK_IF_ONLINE']) {
  422.             $this->addSQLParams('where', $query, array(
  423.                 array('keywords', 'publish', 1)
  424.             ));
  425.         } elseif (!empty($query['publish'])) {
  426.             $this->addSQLParams('where', $query, array(
  427.                 array('keywords', 'publish', $query['publish'])
  428.             ));
  429.         }
  431.         // liaison avec multimedia_keyword
  432.         if (!empty($query['special']['idmultimedia'])) {
  433.             $this->addSQLParams('from', $query, array(
  434.                 'multimedia_keyword',
  435.             ));
  436.             // jointure entre les 3 tables
  437.             $this->addSQLParams('join', $query, array(
  438.                 'keywords.`idkeyword`' => 'multimedia_keyword.`idkeyword`',
  439.             ));
  440.             $this->addSQLParams('where', $query, array(
  441.                 array('multimedia_keyword', 'idmultimedia', $query['special']['idmultimedia']),
  442.             ));
  443.         }
  445.         return $this->getSQLObject($query);
  447.     }
  449.     // }}}
  450. }