vendor/theatre/core/src/Repository/PlaylistsRepository.php line 899

Open in your IDE?
  1. <?php
  3. namespace TheatreCore\Repository;
  5. use TheatreCore\Entity\Classifications;
  6. use TheatreCore\Entity\Multimedias;
  7. use TheatreCore\Entity\Playlists;
  8. use TheatreCore\Traits\TheatreTrait;
  9. use Doctrine\Bundle\DoctrineBundle\Repository\ServiceEntityRepository;
  10. use Doctrine\Persistence\ManagerRegistry;
  12. /**
  13.  * PlaylistsRepository
  14.  *
  15.  * This class was generated by the Doctrine ORM. Add your own custom
  16.  * repository methods below.
  17.  */
  18. class PlaylistsRepository extends ServiceEntityRepository
  19. {
  21.     public $array_types = array('idperson', 'idspectacle', 'idcontact', 'idtext', 'playlist_multimedia', 'playlistClassification');
  23.     use TheatreTrait {
  24.         getRelationsArray as protected getRelationsArrayTrait;
  25.         getItemsList as protected getItemsListTrait;
  26.     }
  28.     private $em;
  29.     public $__table;
  30.     public $__table_object;
  31.     public $__idtable;
  33.     public function __construct(ManagerRegistry $registry)
  34.     {
  35.         parent::__construct($registry, Playlists::class);
  36.         $this->__table = $this->getClassMetadata()->getTableName();
  37.         $this->__table_object = $this->getClassMetadata()->name;
  39.         $this->__idtable = $this->getClassMetadata()->getSingleIdentifierFieldName();
  40. //        $this->__table = 'persons';
  41. //        $this->__table_object = '\\App\\Entity\\Persons';
  42.     }
  44.     //  {{{ findData()
  46.     /** Recherche des playlists
  47.      *
  48.      * Permet de rechercher des playlists en fonction de certains critères :
  49.      * la première lettre, un bout du nom, le type de multimedia, si il est en ligne ou pas
  50.      *
  51.      * @access  public
  52.      * @see     Theatre::find()
  53.      */
  54.     public function findData($publish = null, $keywords = null, $idobject = null, $object = null)
  55.     {
  57.         // requete perso
  58.         $query = $this->createQueryBuilder('e');
  60.         if ($this->getCount()) {
  61.             $query->select('COUNT(e.idplaylist)');
  63.             $this->setCount(false);
  65.             return $query;
  66.         }
  68.         // parametre
  69.         if (isset($_REQUEST['idplaylist']) && !empty($_REQUEST['idplaylist'])) {
  70.             $idplaylist = $_REQUEST['idplaylist'];
  71.         }
  73.         if (isset($_REQUEST['keywords']) && $_REQUEST['keywords'] != 'nom' && !empty($_REQUEST['keywords'])) {
  74.             $keywords = $_REQUEST['keywords'];
  75.         }
  77.         if (isset($_REQUEST['publish']) && !empty($_REQUEST['publish'])) {
  78.             $publish = $_REQUEST['publish'];
  79.         }
  81.         if (isset($_REQUEST['idclassification']) && !empty($_REQUEST['idclassification'])) {
  82.             $idclassification = (int)$_REQUEST['idclassification'];
  83.         }
  85.         //recherche stricte par id
  86.         if (!empty($idplaylist)) {
  87. //            $this->whereAdd($this->__table.'.'.$this->__idtable.'='.((int)$idplaylist));
  88.             $query->andWhere('e.idplaylist = :idplaylist')->setParameter(':idplaylist', $idplaylist);
  89.         }
  91.         // mots cles
  92.         if (!empty($keywords)) {
  93. //            $this->whereAdd($this->__table.'.title LIKE \'%'.$this->escape($keywords).'%\'');
  94.             $query->andWhere('e.title LIKE \'%:title%\'')->setParameter(':title', $keywords);
  95.         }
  97.         // selectionne les fiches hors ligne
  98.         if (!empty($publish) && $publish == 'no') {
  99.             $this->whereAdd($this->__table . '.publish=0');
  100.             $query->andWhere('e.publish=0');
  101.         }
  103.         // selectionne les playlists auteur par lui même
  104.         if (!empty($idclassification)) {
  105.             dump('à refaire la recherche par classification');
  106. //            $this->whereAdd($this->__table.'.idplaylist IN (SELECT idplaylist FROM playlist_classification WHERE idclassification='.$idclassification.')');
  107.         }
  109.         // on lance la recherche
  110.         return $query->getQuery();
  112.     }
  114.     // }}}
  116.     //  {{{ setToArray()
  118.     /** Liste des multimedias dans un tableau associatif
  119.      *
  120.      * Tableau associatif notament utilisé pour lister les informations sur les multimedias
  121.      * Utile pour générer les tableaux HTML de listes de multimedias
  122.      *
  123.      * @access  public
  124.      * @return  array
  125.      * @see     findData()
  126.      */
  127.     public function setToArray($spec = true)
  128.     {
  130.         if ($spec == true) {
  131.             $this->findData();
  132.         }
  134.         $values = array();
  135.         $color = null;
  136.         $nb = 0;
  138.         while ($this->fetch()) {
  140.             // valeurs de l'enregistrement
  141.             $values[$nb] = $this->getInfosPlaylist();
  143.             // couleur de ligne alternative
  144.             $color = $this->colorAlternate($color);
  145.             $values[$nb]['colorline'] = $color;
  146.             $values[$nb]['id'] = $this->idplaylist;
  148.             $nb++;
  149.         }
  151.         return $values;
  152.     }
  154.     // }}}
  156.     //  {{{ orderByDefaut()
  158.     /** Classement par défaut
  159.      *
  160.      * Défini le tri par défaut pour les requêtes de type SELECT
  161.      *
  162.      * @access public
  163.      * @return string
  164.      */
  165.     public function orderByDefaut($order = null)
  166.     {
  168.         // tri par défaut
  169.         if (empty($order)) {
  170.             $order = 'idplaylist';
  171.         }
  173.         return $order;
  175.     }
  177.     // }}}
  179.     //  {{{ getInfosPlaylist()
  181.     /** Informations sur un playlist
  182.      *
  183.      * @access public
  184.      * @param int $idplaylist numero de la fiche playlist
  185.      * @return array  les infos sous forme de tableau
  186.      */
  187.     public function getInfosPlaylist($idplaylist = null, $params_data = array(), $params_display = array())
  188.     {
  190.         $infos = array();
  192.         $con = $this->getEntityManager();
  194.         ////////////// infos de la table
  195.         if (!isset($this->idplaylist) || empty($this->idplaylist) || $this->idplaylist != $idplaylist) {
  196.             if (!empty($idplaylist)) {
  197. //                $x;
  198. //                if(!$this->get($idplaylist)) {
  199. //                    return array();
  200. //                } else {
  201. //                    $infos = $this->objToArray();
  202. //                }
  204.                 $query = $con->getRepository(Playlists::class)
  205.                     ->createQueryBuilder('e')
  206.                     ->select('e')
  207.                     ->andWhere('e.idplaylist = :idplaylist')
  208.                     ->setParameter('idplaylist', $idplaylist)
  209.                     ->getQuery();
  211.                 $infos = $this->objToArray($query);
  212.                 $this->loadResult($infos);
  214.                 if (empty($infos)) {
  215.                     return [];
  216.                 }
  218.             }
  219.         } else {
  220.             $idplaylist = $this->idplaylist;
  222. //            $x->setParameter('$idplaylist', $idplaylist);
  223.             $query = $con->getRepository(Playlists::class)
  224.                 ->createQueryBuilder('e')
  225.                 ->select('e')
  226.                 ->andWhere('e.idplaylist = :idplaylist')
  227.                 ->setParameter('idplaylist', $idplaylist)
  228.                 ->getQuery();
  230.             $infos = $this->objToArray($query);
  231.             $this->loadResult($infos);
  233.             if (empty($infos)) {
  234.                 return [];
  235.             }
  236.         }
  238.         $format_vignette = array();
  239.         if (!empty($params_data['format_vignette'])) {
  240.             $format_vignette = $params_data['format_vignette'];
  241.         }
  243.         $params_display = array_merge(array('alldata' => true), $params_display);
  246.         $infos['nameview'] = $this->title ?? null;
  248.         if (!empty($params_data['all'])) {
  250.             // les relations
  251.             foreach ($this->array_types as $t) {
  252.                 $x = $this->getRelationsArray($t);
  253.                 $infos[$t] = $this->noPunct($this->getLinkedObject($this->getRelationsArray($t), $idplaylist, $t, 'playlists'));
  254.             }
  256.             // récupèrer le détail des éléments multimedias associés
  257.             if (!empty($params_data['multimedias']) && !empty($infos['playlist_multimedia'])) {
  258.                 $multimedias = $con->getRepository(Multimedias::class);
  259.                 foreach ($infos['playlist_multimedia'] as $m) {
  260.                     $ids_multimedia[] = $m['idmultimedia'];
  261.                 }
  263.                 $params_multimedias = array(
  264.                     'where' => array(array('multimedias', 'idmultimedia', $ids_multimedia)),
  265.                     'order' => array(array('multimedias', 'idmultimedia', $ids_multimedia)), // classement par le IN via FIELD
  266.                     'dbg' => array('rech', 'Vidéos liées au playlist'),
  267.                 );
  269.                 if (!empty($params_display['limitmultimedias'])) {
  270.                     $params_multimedias['limit'] = $params_display['limitmultimedias'];
  271.                 }
  273.                 $infos['multimedias'] = $multimedias->getListMultimedias($params_multimedias, $format_vignette, $params_display);
  275.                 // compter
  276.                 $infos['nb_multimedias'] = count($ids_multimedia);
  277.                 // prendre la première vignette
  278.                 foreach ($infos['multimedias'] as $k => $v) {
  279.                     $infos['vignette'] = $v['vignette'];
  280.                     $infos['vignette_flou'] = $v['vignette_flou'];
  281.                 }
  282.             }
  284.             // récupèrer les classifications
  285.             $infos['classifications'] = $con->getRepository(Classifications::class)->getObjectClassification('playlists', $idplaylist, $this->getRelationsArray('playlist_classification'));
  287.         }
  289.         if (!empty($infos['description'])) {
  290.             $infos['description_html'] = $this->wikiTransform($infos['description']);
  291.         }
  293.         return $infos;
  294.     }
  296.     // }}}
  298.     //  {{{ getItemsList()
  300.     /** Liste des items pour les champs relationnels
  301.      *
  302.      * Retourne un tableau associatif contenant la liste des items d'une relation
  303.      *
  304.      * @access  public
  305.      * @param string $type Ce qu'on recherche
  306.      * @param string $idtext L'id de l'objet
  307.      * @return  array
  308.      */
  309.     public function getItemsList($idplaylist, $type)
  310.     {
  312.         if (in_array($type, $this->array_types)) {
  313.             return $this->getLinkedObject($this->getRelationsArray($type), $idplaylist, $type, 'playlists');
  314.         } else {
  315.             return 'Aucune fonction de recherche pour le type <strong>' . $type . '</strong> dans la méthode !';
  316.         }
  318.     }
  320.     // }}}
  322.     //  {{{ getRelationsArray()
  324.     /** Tableau des relations
  325.      *
  326.      * @access  public
  327.      * @param string|int $type le type de champ
  328.      */
  329.     public function getRelationsArray($type = null)
  330.     {
  332.         // récupérer les relations communes
  333.         $array_types = $this->getRelationsArrayTrait('all');
  335.         $array_types += array(
  336.             'idspectacle' => array(
  337.                 'type_join' => 'simple',
  338.                 'dest_table' => 'spectacles',
  339.                 'join_field_src' => 'idspectacle',
  340.                 'dest_table_field' => 'idspectacle',
  341.                 'fields' => array('idspectacle', 'title', 'url_clean'),
  342.                 'hide_relation' => true,
  343.                 'silent_delete_relation' => true,
  344.                 'description' => 'Spectacle associé à cette playlist',
  345.             ),
  346.             'idperson' => array(
  347.                 'type_join' => 'simple',
  348.                 'dest_table' => 'persons',
  349.                 'join_field_src' => 'idperson',
  350.                 'dest_table_field' => 'idperson',
  351.                 'fields' => array('idperson', 'lastname', 'firstname', 'url_clean'),
  352.                 'silent_delete_relation' => true,
  353.                 'description' => 'Personne associée à cette playlist',
  354.             ),
  355.             'idcontact' => array(
  356.                 'type_join' => 'simple',
  357.                 'dest_table' => 'contacts',
  358.                 'join_field_src' => 'idcontact',
  359.                 'dest_table_field' => 'idcontact',
  360.                 'fields' => array('idcontact', 'organisation', 'url_clean'),
  361.                 'silent_delete_relation' => true,
  362.                 'description' => 'Contact associé à cette playlist',
  363.             ),
  364.             'idtext' => array(
  365.                 'type_join' => 'simple',
  366.                 'dest_table' => 'texts',
  367.                 'join_field_src' => 'idtext',
  368.                 'dest_table_field' => 'idtext',
  369.                 'fields' => array('idtext', 'title', 'url_clean'),
  370.                 'silent_delete_relation' => true,
  371.                 'description' => 'Texte associé à cette playlist',
  372.             ),
  373.             'playlist_multimedia' => array(
  374.                 'type_join' => 'multiple',
  375.                 'dest_table' => 'multimedias',
  376.                 'fields' => array('idmultimedia', 'sujet_titre', 'url_clean', 'status', 'price'),
  377.                 'join_table' => 'playlist_multimedia',
  378.                 'hide_relation' => true,
  379.                 'silent_delete_relation' => true,
  380.                 'sql_more' => ' ORDER BY j2.`orderplaylist` ',
  381.                 'description' => 'Multimédia(s) associé(s) à cette playlist',
  382.             ),
  383.             'playlist_classification' => array(
  384.                 'type_join' => 'multiple',
  385.                 'dest_table' => 'classifications',
  386.                 'fields' => array('idclassification', 'classification', 'type', 'idgroupclassification'),
  387.                 'join_table' => 'playlist_classification',
  388.                 'hide_relation' => true,
  389.                 'silent_delete_relation' => true,
  390.                 'description' => 'Classification(s) associée(s) à cette playlist',
  391.             ),
  393.         );
  395.         if (!empty($array_types[$type])) {
  396.             $array_types[$type]['type'] = $type;
  397.             return $array_types[$type];
  398.         } else {
  399.             return $array_types;
  401.         }
  403.     }
  405.     // }}}
  407.     //  {{{ getSQLPlaylists()
  409.     /** Générer la requete standard pour des playlists
  410.      *
  411.      *
  412.      * @access   public
  413.      * @param array $params Les paramètres pour la requete
  414.      * @param array $special Les paramètres supplémentaires
  415.      * @param bool $debug afficher la requête TODO
  416.      * @return   string
  417.      */
  418.     public function getSQLPlaylists($query = array(), $debug = false)
  419.     {
  421.         // on prepare les tableaux
  422.         foreach (array('select', 'from', 'where', 'order', 'group', 'limit') as $t) {
  423.             if (!empty($query[$t])) {
  424.                 if (!is_array($query[$t])) {
  425.                     $query[$t][] = $query[$t];
  426.                 } else {
  427.                     $query[$t] = $query[$t];
  428.                 }
  429.             } else {
  430.                 $query[$t] = array();
  431.             }
  432.         }
  434.         // champs par défaut
  435.         $this->addSQLParams('select', $query, array(
  436.             array('playlists' => '*')
  437.         ));
  439.         // publié ou pas
  440.         if (empty($query['publish']) && $_ENV['CHECK_IF_ONLINE']) {
  441.             $this->addSQLParams('where', $query, array(
  442.                 array('playlists', 'publish', 1)
  443.             ));
  444.         } elseif (!empty($query['publish'])) {
  445.             $this->addSQLParams('where', $query, array(
  446.                 array('playlists', 'publish', $query['publish'])
  447.             ));
  448.         }
  450.         // recherche par liaison via playlist_multimedia
  451.         if (!empty($query['special']['idmultimedias'])) {
  452.             $this->addSQLParams('from', $query, array(
  453.                 'playlist_multimedia',
  454.             ));
  455.             // jointure entre les 3 tables
  456.             $this->addSQLParams('join', $query, array(
  457.                 'playlists.`idplaylist`' => 'playlist_multimedia.`idplaylist`',
  458.             ));
  459.             $this->addSQLParams('where', $query, array(
  460.                 array('playlist_multimedia', 'idmultimedia', $query['special']['idmultimedias']),
  461.             ));
  462.             $this->addSQLParams('order', $query, array(
  463.                 array('playlist_multimedia', 'orderplaylist'),
  464.             ));
  466.         }
  468.         // recherche par liaison via playlist_person
  469.         if (!empty($query['special']['idpersons'])) {
  470.             $this->addSQLParams('where', $query, array(
  471.                 array('playlists', 'idperson', $query['special']['idpersons']),
  472.             ));
  473.             $this->addSQLParams('order', $query, array(
  474.                 array('playlists', 'idperson', $query['special']['idpersons']),
  475.             ));
  476.         }
  478.         // jointure avec persons
  479.         if (!empty($query['special']['persons'])) {
  480.             $this->addSQLParams('from', $query, array(
  481.                 'persons',
  482.             ));
  483.             $this->addSQLParams('join', $query, array(
  484.                 'playlists.`idperson`' => 'persons.`idperson`',
  485.             ));
  486.             $this->addSQLParams('order', $query, array('persons.`lastname`'));
  487.             $this->addSQLParams('direction', $query, 'ASC');
  488.             if (!empty($query['special']['persons']['group'])) {
  489.                 $this->addSQLParams('group', $query, $query['special']['persons']['group']);
  490.             }
  491.             if (!empty($query['special']['persons']['idperson'])) {
  492.                 $this->addSQLParams('where', $query, array(
  493.                     array('persons', 'idperson', $query['special']['persons']['idperson']),
  494.                 ));
  495.             }
  496.         }
  498.         // recherche par liaison via playlist_text
  499.         if (!empty($query['special']['idtext'])) {
  500.             $this->addSQLParams('where', $query, array(
  501.                 array('playlists', 'idtext', $query['special']['idtext']),
  502.             ));
  503.         }
  505.         // jointure avec text_aide et aide
  506.         if (!empty($query['special']['aides'])) {
  507.             $this->addSQLParams('from', $query, array(
  508.                 'aides',
  509.             ));
  510.             if (!empty($query['special']['aides']['text_aide'])) {
  511.                 $this->addSQLParams('from', $query, array(
  512.                     'text_aide',
  513.                 ));
  514.                 $this->addSQLParams('join', $query, array(
  515.                     'playlists.`idtext`' => 'text_aide.`idtext`',
  516.                 ));
  517.                 $this->addSQLParams('join', $query, array(
  518.                     'text_aide.`idaide`' => 'aides.`idaide`',
  519.                 ));
  520.             }
  521.             if (!empty($query['special']['aides']['idaidecontact'])) {
  522.                 $this->addSQLParams('where', $query, array(
  523.                     array('aides', 'idaidecontact', $query['special']['aides']['idaidecontact']),
  524.                 ));
  525.             }
  526.         }
  529.         // recherche par classification
  530.         if (!empty($query['special']['idclassifications'])) {
  531.             $this->addSQLParams('from', $query, array(
  532.                 'playlist_classification',
  533.             ));
  534.             // jointure entre les 3 tables
  535.             $this->addSQLParams('join', $query, array(
  536.                 'playlists.`idplaylist`' => 'playlist_classification.`idplaylist`',
  537.             ));
  538.             $this->addSQLParams('where', $query, array(
  539.                 array('playlist_classification', 'idclassification', $query['special']['idclassifications']),
  540.             ));
  541.         }
  543.         return $this->getSQLObject($query);
  545.     }
  547.     // }}}
  549.     //  {{{ countListPlaylists()
  551.     /** Compter la liste des playlists
  552.      *
  553.      * @access   public
  554.      * @param array $params_sql paramètre pour la requete SQL
  555.      * @param bool $debug mode débugage
  556.      * @return   int
  557.      */
  558.     public function countListPlaylists($params_sql = null, $debug = false)
  559.     {
  561.         // si pas de tableau
  562.         if (!isset($params_sql['special'])) {
  563.             $params_sql['special'] = array();
  564.         }
  565.         if (!isset($params_sql['params'])) {
  566.             $params_sql['params'] = array();
  567.         }
  569.         // si pas de limite => tout
  570.         if (empty($params_sql['params']['limit'])) {
  571.             $params_sql['limit'] = array('all');
  572.         }
  574.         $params_sql['count_only'] = true;
  576.         // construction de la requête avec le passage de paramètres
  577.         return $this->queryOne($this->getSQLPlaylists($params_sql, $debug));
  579.     }
  581.     // }}}
  583.     //  {{{ getListPlaylists()
  585.     /** Retourne des listes de playlists
  586.      *
  587.      * Retourne des listes de playlist au format "standard""
  588.      *
  589.      * @access   public
  590.      * @param array $params_sql paramètre pour la requete SQL
  591.      * @param array $format_vignette de la vignette si pas standard
  592.      * @param array $params_display paramètre pour l'affichage
  593.      * @return   array
  594.      */
  595.     public function getListPlaylists($params_sql = null, $format_vignette = array(), $params_display = array())
  596.     {
  598.         // si pas de tableau
  599.         if (!isset($params_sql['special'])) {
  600.             $params_sql['special'] = array();
  601.         }
  602.         if (!isset($params_sql['params'])) {
  603.             $params_sql['params'] = array();
  604.         }
  606.         // construction de la requête avec le passage de paramètres
  607.         $sql = $this->getSQLPlaylists($params_sql);
  609.         // paramètre de debug
  610.         $dbg = (empty($params_sql['dbg'])) ? array() : $dbg = $params_sql['dbg'];
  612.         // executer la requete
  613.         $this->query($sql, $dbg);
  615.         $videos = array();
  617.         // donnée entières ?
  618.         if (empty($params_display['alldata'])) {
  619.             $params_display['alldata'] = false;
  620.         }
  622.         // debug
  623.         $start_boucle = microtime(true);
  625.         $playlists = array();
  627.         $datas = $this->query($sql);
  629.         // on boucle
  630.         foreach ($datas as $data) {
  631.             $this->loadResult($data);
  633.             if (!empty($params_sql['count_only'])) {
  634.                 return $this->total;
  635.             }
  636.             $idplaylist = $this->idplaylist;
  637.             if (!empty($params_sql['fields'])) {
  638.                 foreach ($params_sql['fields'] as $f) {
  639.                     $playlists[$idplaylist][$f] = $this->$f;
  640.                 }
  641.             } else {
  642.                 $playlists[$idplaylist] = $this->getInfosPlaylist($idplaylist, array('all' => true, 'multimedias' => true), array('vignette_format' => $format_vignette));
  643.             }
  644.         }
  646.         if (!empty($params_display['other_url_clean'])) {
  647.             if (!empty($playlists)) {
  648.                 foreach ($playlists as $k => $v) {
  649.                     // le lien vers le contenu directement
  650.                     if (!empty($v['idtext'])) {
  651.                         foreach ($v['idtext'] as $t) {
  652.                             $playlists[$k]['other_url_clean'] = '/textes/' . $t['url_clean'] . '/playlist/id/' . $v['urlClean'];
  653.                         }
  654.                     }
  655.                 }
  656.             }
  657.         }
  659.         // debug de la boucle
  660.         if ($this->isTraceMode('list_object')) {
  661.             $this->setTraceInfos(array(
  662.                 'execution_time_boucle' => microtime(true) - $start_boucle,
  663.                 'nb_occurence' => count($playlists),
  664.                 'dbg' => $dbg,
  665.             ));
  666.         }
  668.         $this->free();
  670.         return $playlists;
  672.     }
  674.     // }}}
  676.     //  {{{ getObjectTitle()
  678.     /** Infos de l'item recherché
  679.      *
  680.      * Affichage standard du titre de l'objet
  681.      *
  682.      * @access public
  683.      * @param int $idobject Identifiant de l'item
  684.      * @param array $infos_object Informations pour construire le titre
  685.      * @param array $params Paramétres supplémentaires
  686.      * @return string
  687.      */
  688.     public function getObjectTitle($idobject = null, $infos_object = array(), $params = array())
  689.     {
  690.         $title = '';
  692.         if (!$idobject) {
  693.             $idobject = $this->idplaylist;
  694.         }
  696.         // champs
  697.         $fields = array('idplaylist', 'title', 'url_clean');
  699.         if (!empty($infos_object)) {
  701.             foreach ($fields as $k => $v) {
  702.                 if (array_key_exists($v, $infos_object)) {
  703.                     $$v = $infos_object[$v];
  704.                 }
  705.             }
  707.         } else {
  709.             //charger les infos que si necessaire
  710.             if (empty($this->title)) {
  711.                 $this->selectAdd();
  712.                 $this->selectAdd(implode(',', $fields));
  713.                 $this->get($idobject);
  714.             }
  716.             foreach ($fields as $k => $v) {
  717.                 if (isset($this->$v) && $this->$v != '') {
  718.                     $$v = trim($this->$v);
  719.                 }
  720.             }
  722.         }
  724.         return $title;
  726.     }
  728.     // }}}
  730.     //  {{{ getListSearch()
  732.     /** Liste des playlists
  733.      *
  734.      * Pour les champs Ajax de relations et les recherches diverses
  735.      *
  736.      * @access  public
  737.      * @param string $lettres Pour la recherche alphabetique
  738.      * @param string $type Pour le type recherche (editeurs, revues...)
  739.      * @param string $keywords Recherche par mots cles
  740.      * @return  array
  741.      */
  742.     public function getListSearch($lettre, $type = null, $keywords = null)
  743.     {
  744.         $sql = 'SELECT ' . $this->__idtable . ', title
  745.                  FROM ' . $this->__table . '
  746.                  WHERE 1 ';
  748.         // selection par ordre alpha
  749.         if (!empty($lettre) && $lettre != 'tous') {
  750.             $sql_where[] = array('LOWER(LEFT(LTRIM(title),1))=\'' . $this->escape($lettre) . '\'');
  751.         }
  753.         // recherche avec un mot cle
  754.         $list = $this->splitKeywords($keywords);
  756.         if ($list) {
  757.             if (!empty($list[$this->IDSTR])) {
  758.                 // mots clés
  759.                 foreach ($list[$this->IDSTR] as $s) {
  760.                     $sql_more_name[] = 'title LIKE \'%' . $s . '%\'';
  761.                 }
  762.                 $sql_where[] = array('(' . join(' OR ', $sql_more_name) . ')');
  763.             }
  764.             if (!empty($list[$this->IDNUM])) {
  765.                 // recherche par numéro d'id pour les mots clés numériques
  766.                 $sql_where[] = array('idplaylist IN (' . implode(',', $list[$this->IDNUM]) . ')', 'OR');
  767.             }
  768.         }
  770.         foreach ($sql_where as $k => $v) {
  771.             if (!empty($v[1])) {
  772.                 $sql .= ' ' . $v[1] . ' ' . $v[0];
  773.             } else {
  774.                 $sql .= ' AND ' . $v[0];
  775.             }
  776.         }
  778.         $sql .= ' ORDER BY title';
  780.         $this->query($sql);
  782.         $r = array();
  784.         while ($this->fetch()) {
  785.             $r[$this->idplaylist] = $this->title;
  786.             // si trouvé par id, on l'affiche en fin de titre
  787.             if (!empty($list[$this->IDNUM]) && in_array($this->idplaylist, $list[$this->IDNUM])) {
  788.                 $r[$this->idplaylist] .= ' - n°' . $this->idplaylist;
  789.             }
  790.         }
  791.         $this->free();
  793.         return $r;
  794.     }
  796.     // }}}
  798.     //  {{{ countPlaylists()
  800.     /** Nombre de Playlist
  801.      *
  802.      * Compter le nb de playlists
  803.      *
  804.      * @access  public
  805.      * @return  int
  806.      */
  807.     public function countPlaylists($object = null, $idobject = null, $classification = null)
  808.     {
  810.         if (!empty($object) && !empty($idobject)) {
  811.             $object = substr($object, 0, -1);
  812.             $sql_count = '
  813.                 SELECT COUNT(DISTINCT(p.`' . $this->__idtable . '`)) as total
  814.                 FROM ' . $this->__table . ' p
  815.                     LEFT JOIN playlist_classification pc ON pc.`idplaylist`=p.`idplaylist`
  816.                     LEFT JOIN classifications c ON pc.`idclassification`=c.`idclassification`
  817.                 WHERE p.`publish`=1
  818.                 AND p.`id' . $object . '` IN (' . $this->arrayToIn($idobject) . ') ';
  819.         } else {
  820.             $sql_count = '
  821.                 SELECT COUNT(DISTINCT(p.`' . $this->__idtable . '`)) as total
  822.                 FROM ' . $this->__table . ' p
  823.                     LEFT JOIN playlist_classification pc ON pc.`idplaylist`=p.`idplaylist`
  824.                     LEFT JOIN classifications c ON pc.`idclassification`=c.`idclassification`
  825.                 WHERE p.`publish`=1';
  826.         }
  828.         if (!empty($classification)) {
  829.             if ($this->my_is_int($classification)) {
  830.                 $sql_count .= ' AND c.`idclassification`=' . (int)$classification;
  831.             } else {
  832.                 if (is_array($classification)) {
  833.                     $sql_count .= ' AND c.`classification` IN (\'' . implode('\',\'', $classification) . '\')';
  834.                 } else {
  835.                     $sql_count .= ' AND c.`classification`=\'' . $this->escape($classification) . '\'';
  836.                 }
  837.             }
  838.         }
  840.         $total = $this->queryOne($sql_count);
  842.         if ($total) {
  843.             return $total;
  844.         } else {
  845.             return null;
  846.         }
  848.     }
  850.     // }}}
  852.     //  {{{ getByClassification()
  854.     /** Nombre de Playlist
  855.      *
  856.      * Compter le nb de playlists
  857.      *
  858.      * @access  public
  859.      * @return  int
  860.      */
  861.     public function getByClassification($object, $idobject, $classification = null)
  862.     {
  864.         if (!empty($object) && !empty($idobject)) {
  865.             $object = substr($object, 0, -1);
  866.             $sql_count = '
  867.                 SELECT p.`idplaylist`
  868.                 FROM ' . $this->__table . ' p
  869.                     LEFT JOIN playlist_classification pc ON pc.`idplaylist`=p.`idplaylist`
  870.                     LEFT JOIN classifications c ON pc.`idclassification`=c.`idclassification`
  871.                 WHERE p.`publish`=1
  872.                 AND p.`id' . $object . '`=' . (int)$idobject;
  873.         } else {
  874.             $sql_count = '
  875.                 SELECT p.`idplaylist`
  876.                 FROM ' . $this->__table . ' p
  877.                     LEFT JOIN playlist_classification pc ON pc.`idplaylist`=p.`idplaylist`
  878.                     LEFT JOIN classifications c ON pc.`idclassification`=c.`idclassification`
  879.                 WHERE p.`publish`=1';
  880.         }
  882.         if (!empty($classification)) {
  883.             if ($this->my_is_int($classification)) {
  884.                 $sql_count .= ' AND c.`idclassification`=' . (int)$classification;
  885.             } else {
  886.                 if (is_array($classification)) {
  887.                     $sql_count .= ' AND c.`classification` IN (\'' . implode('\',\'', $classification) . '\')';
  888.                 } else {
  889.                     $sql_count .= ' AND c.`classification`=\'' . $this->escape($classification) . '\'';
  890.                 }
  891.             }
  893.         }
  894.         $sql_count .= ' LIMIT 0,1';
  896.         $idplaylist = $this->queryOne($sql_count);
  898.         if ($idplaylist) {
  899.             return $this->getInfosPlaylist($idplaylist, array('all' => true));
  900.         } else {
  901.             return null;
  902.         }
  904.     }
  906.     // }}}
  908.     //  {{{ getSpectaclesAnneesSaisons()
  910.     /** Récupèrer les années saisons où il y a des spectacles
  911.      *
  912.      * Récupérer les années et saisons où il y a des spectacles à l'affiche associés ipar le texte à une playlist avec une classification
  913.      *
  914.      * @access  public
  915.      * @return  array
  916.      */
  917.     public function getSpectaclesAnneesSaisons($idclassifications = array())
  918.     {
  920.         $sql_annees = 'SELECT sc.`date`, YEAR(sc.`date`) as annee
  921.                         FROM `schedules` sc
  922.                         JOIN `spectacles` s ON sc.`idspectacle`=s.`idspectacle`
  923.                         JOIN `text_spectacle` ts ON ts.`idspectacle`=s.`idspectacle`
  924.                         JOIN `playlists` p ON p.`idtext`=ts.`idtext`
  925.                         JOIN `playlist_classification` pc ON pc.`idplaylist`=p.`idplaylist`
  926.                         WHERE 1
  927.                         AND s.`textfictif`=0 AND s.`publish`=1 AND s.`valid`=1
  928.                         AND p.`publish`=1
  929.                         AND pc.`idclassification` IN (' . $this->arrayToIn($idclassifications) . ')
  930.                         AND sc.`date` > \'1999-12-31\'
  931.                         ORDER BY sc.`date` ';
  933.         $listdates = $this->queryAll($sql_annees);
  935.         return $listdates;
  938.     }
  940.     // }}}
  942.     //  {{{ getAutors()
  944.     /** Récupèrer les auteurs qui ont un texte par l'auteur
  945.      *
  946.      * @access  public
  947.      * @return  array
  948.      */
  949.     public function getAuthors()
  950.     {
  952.         $fields = array(
  953.             'idperson',
  954.             'lastname',
  955.             'firstname',
  956.             'url_clean',
  957.         );
  959.         foreach ($fields as $k => $v) {
  960.             $select[] = '`persons`.`' . $v . '`';
  961.         }
  963.         $sql_persons = 'SELECT ' . implode(', ', $select) . '
  964.                         FROM `persons` , `playlist_classification` , `playlists`
  965.                         WHERE 1 AND playlists.`publish`=1
  966.                         AND playlist_classification.`idclassification` IN (144) AND playlists.`idperson`=persons.`idperson`
  967.                         AND playlists.`idplaylist`=playlist_classification.`idplaylist`
  968.                         GROUP BY `persons`.`idperson`
  969.                         ORDER BY `persons`.`lastname` ';
  971.         $listpersons = $this->queryAll($sql_persons);
  973.         if (!empty($listpersons)) {
  974.             foreach ($listpersons as $k => $v) {
  975.                 $listpersons[$k]['lastname'] = mb_strtoupper($v['lastname'], 'UTF8');
  976.             }
  977.         }
  979.         return $listpersons;
  981.     }
  983.     // }}}
  984. }