vendor/theatre/core/src/Repository/DvdsRepository.php line 746

Open in your IDE?
  1. <?php
  3. namespace TheatreCore\Repository;
  5. use TheatreCore\Classes\Images\Images;
  6. use TheatreCore\Entity\Dvdformats;
  7. use TheatreCore\Entity\Dvds;
  8. use TheatreCore\Entity\Dvdtechnos;
  9. use TheatreCore\Entity\Dvdzones;
  10. use TheatreCore\Entity\Multimedias;
  11. use TheatreCore\Traits\TheatreTrait;
  12. use Doctrine\Bundle\DoctrineBundle\Repository\ServiceEntityRepository;
  13. use Doctrine\Persistence\ManagerRegistry;
  14. use Doctrine\ORM\Query;
  16. /**
  17.  * DvdsRepository
  18.  *
  19.  * This class was generated by the Doctrine ORM. Add your own custom
  20.  * repository methods below.
  21.  */
  22. class DvdsRepository extends ServiceEntityRepository
  23. {
  25.     use TheatreTrait {
  26.         getRelationsArray as protected getRelationsArrayTrait;
  27.         getLinkedObject as protected getLinkedObjectTrait;
  28.     }
  30.     // les relations
  31.     public $array_types = array('moviedirector', 'author', 'director', 'intervenant', 'comedien', 'tournage', 'spectacle', 'multimedia', 'production', 'editeur');
  33.     private $em;
  34.     public $__table;
  35.     public $__table_object;
  36.     public $__idtable;
  38.     public function __construct(ManagerRegistry $registry, Images $images)
  39.     {
  40.         parent::__construct($registry, Dvds::class);
  41.         $this->__table = $this->getClassMetadata()->getTableName();
  42.         $this->__table_object = $this->getClassMetadata()->name;
  44.         $this->images = $images;
  46.         $this->__idtable = $this->getClassMetadata()->getSingleIdentifierFieldName();
  47. //        $this->__table = 'persons';
  48. //        $this->__table_object = '\\App\\Entity\\Persons';
  49.     }
  51.     //  {{{ findData()
  53.     /** Recherche des dvds
  54.      *
  55.      * Permet de rechercher des dvds en fonction de certains critères :
  56.      * la première lettre, un bout du nom, le type de multimedia, si il est en ligne ou pas
  57.      *
  58.      * @access  public
  59.      * @see     Theatre::find()
  60.      */
  61.     public function findData($publish = null, $keywords = null, $idobject = null, $object = null)
  62.     {
  63.         // requete perso
  64.         $query = null;
  66.         $con = $this->getEntityManager();
  67.         $query = $con->getRepository(Dvds::class)->createQueryBuilder('e');
  69.         if ($this->getCount()) {
  70.             $query->select('COUNT(e.iddvd)');
  72.             $this->setCount(false);
  74.             return $query;
  75.         }
  77.         // parametre
  78. //        if(isset($_REQUEST['iddvd']) && !empty($_REQUEST['iddvd'])) {
  79. //            $iddvd = $_REQUEST['iddvd'];
  80. //        }
  81. //
  82. //        if(isset($_REQUEST['keywords']) && $_REQUEST['keywords']!='nom' && !empty($_REQUEST['keywords'])) {
  83. //            $keywords = $_REQUEST['keywords'];
  84. //        }
  85. //
  86. //        if(isset($_REQUEST['publish']) && !empty($_REQUEST['publish'])) {
  87. //            $publish = $_REQUEST['publish'];
  88. //        }
  89. //
  90. //        //recherche stricte par id
  91. //        if(!empty($iddvd)) {
  92. //            $this->whereAdd($this->__table.'.'.$this->__idtable.'='.((int)$iddvd));
  93. //        }
  94. //
  95. //        // mots cles
  96. //        if (!empty($keywords)) {
  97. //            $this->whereAdd($this->__table.'.title LIKE \'%'.$this->escape($keywords).'%\'');
  98. //        }
  99. //
  100. //        // selectionne les fiches hors ligne
  101. //        if (!empty($publish) && $publish=='no') {
  102. //            $this->whereAdd($this->__table.'.publish=0');
  103. //        }
  105.         // on lance la recherche
  106.         $this->specialQuery($query);
  108.     }
  110.     // }}}
  112.     //  {{{ setToArray()
  114.     /** Liste des multimedias dans un tableau associatif
  115.      *
  116.      * Tableau associatif notament utilisé pour lister les informations sur les multimedias
  117.      * Utile pour générer les tableaux HTML de listes de multimedias
  118.      *
  119.      * @access  public
  120.      * @return  array
  121.      * @see     findData()
  122.      */
  123.     public function setToArray($spec = true)
  124.     {
  126.         if ($spec == true) {
  127.             $this->findData();
  128.         }
  130.         $values = array();
  131.         $color = null;
  132.         $nb = 0;
  134.         while ($this->fetch()) {
  136.             // valeurs de l'enregistrement
  137.             $values[$nb] = $this->getInfosDvd();
  139.             // couleur de ligne alternative
  140.             $color = $this->colorAlternate($color);
  141.             $values[$nb]['colorline'] = $color;
  142.             $values[$nb]['id'] = $this->iddvd;
  144.             $nb++;
  145.         }
  147.         return $values;
  148.     }
  150.     // }}}
  152.     //  {{{ orderByDefaut()
  154.     /** Classement par défaut
  155.      *
  156.      * Défini le tri par défaut pour les requêtes de type SELECT
  157.      *
  158.      * @access public
  159.      * @return string
  160.      */
  161.     public function orderByDefaut($order = null)
  162.     {
  164.         // tri par défaut
  165.         if (empty($order)) {
  166.             $order = 'iddvd';
  167.         }
  169.         return $order;
  171.     }
  173.     // }}}
  175.     //  {{{ getInfosDvd()
  177.     /** Informations sur un dvd
  178.      *
  179.      * @access public
  180.      * @param int $iddvd numero de la fiche DVD
  181.      * @return array  les infos sous forme de tableau
  182.      */
  183.     public function getInfosDvd($iddvd = null, $params_data = array(), $params_display = array())
  184.     {
  185.         $conn = $this->getEntityManager();
  187.         $infos = array();
  189.         ////////////// infos de la table
  190.         if (!isset($this->iddvd) || empty($this->iddvd)) {
  191.             if (!empty($iddvd)) {
  192.                 if (!$infos = $this->get($iddvd)) {
  193.                     return array();
  194.                 }
  195.             }
  196.         } else {
  197.             $infos = $this->createQueryBuilder('e')
  198.                 ->select('e')
  199.                 ->andWhere('e.iddvd = :iddvd')
  200.                 ->setParameter('iddvd', $iddvd)
  201.                 ->getQuery()
  202.                 ->getSingleResult(Query::HYDRATE_ARRAY);
  204.             /*$infos = array(
  205.                 'iddvd' => $this->iddvd,
  206.                 'title' => $this->title,
  207.                 'time_movie' => $this->time_movie,
  208.             );*/
  209.         }
  211.         // retourne toutes les infos liées
  212.         if (!empty($params_data['all'])) {
  213.             $recordedDvd = $this->createQueryBuilder('e')
  214.                 ->where('e.iddvd = :iddvd')
  215.                 ->setParameter('iddvd', $iddvd)
  216.                 ->getQuery()
  217.                 ->getSingleResult();
  218.             $recordedIdDvdzone = $recordedDvd->getIddvdzone()->getIddvdzone();
  219.             $recordedIdDvdformat = $recordedDvd->getIddvdformat()->getIddvdformat();
  220.             $recordedIdDvdtechno = $recordedDvd->getIddvdtechno()->getIddvdtechno();
  221.             // les infos zone, techno, format...
  222.             foreach (array('zone', 'techno', 'format') as $t) {
  223.                 if (!empty(${'recordedIdDvd' . $t})) {
  224.                     $infos['iddvd' . $t] = ${'recordedIdDvd' . $t};
  225.                 }
  226.                 if (!empty($infos['iddvd' . $t])) {
  227.                     //$f = getDvd.$t;
  228.                     $infos[$t] = $conn->getRepository('TheatreCore\Entity\Dvd' . $t . 's')->{'getDvd' . $t}($infos['iddvd' . $t]);
  229.                 }
  230.             }
  231.             // les ralations
  232.             foreach ($this->array_types as $t) {
  233.                 $infos['dvd_' . $t] = $this->noPunct($this->getLinkedObjectTrait($this->getRelationsArray('dvd_' . $t), $iddvd, 'dvd_' . $t, 'dvds'));
  234.             }
  236.             // voir si VOD
  237.             if (!empty($infos['dvd_multimedia'])) {
  238.                 foreach ($infos['dvd_multimedia'] as $km => $vm) {
  239.                     if (!empty($vm['price'])) {
  240.                         $infos['vod'] = $vm;
  241.                         break;
  242.                     }
  243.                 }
  244.             }
  246.             if (!empty($params_display['vignette_format'])) {
  247.                 $infos['vignette'] = $this->getVignetteDvd($iddvd, $params_display['vignette_format']);
  248.             } else {
  249.                 $infos['vignette'] = $this->getVignetteDvd($iddvd);
  250.             }
  251.         }
  253.         // récupèrer le détail des éléments multimedias associés
  254.         if (!empty($params_data['multimedias']) && !empty($infos['dvd_multimedia'])) {
  255.             $multimedias = $conn->getRepository(Multimedias::class);
  256.             foreach ($infos['dvd_multimedia'] as $m) {
  257.                 $ids_multimedia[] = $m['idmultimedia'];
  258.                 $infos['multimedias'][$m['idmultimedia']] = $multimedias->getInfosMultimedia($m['idmultimedia']);
  259.             }
  261.             $infos['multimedias'] = $multimedias->getListMultimedias(array(
  262.                 'where' => array(array('multimedias', 'idmultimedia', $ids_multimedia)),
  263.                 'dbg' => array('rech', 'Vidéos liées au DVD'),
  264.             ));
  265.         }
  267.         if (!empty($infos['comments'])) {
  268.             $infos['description'] = $this->wikiTransform($infos['comments']);
  269.         }
  271.         if (!empty($infos['date_shooting']) && $infos['date_shooting'] != '0000-00-00 00:00:00') {
  272.             $infos['date_shooting_str'] = $this->getFormeDate($infos['date_shooting'], "%B %Y", true);
  273.         }
  275.         if (!empty($infos['place_shooting']) || !empty($infos['dvd_tournage'])) {
  276.             $infos['place_shooting_exist'] = true;
  277.         }
  279.         return $infos;
  280.     }
  282.     // }}}
  284.     //  {{{ getItemsList()
  286.     /** Liste des items pour les champs relationnels
  287.      *
  288.      * Retourne un tableau associatif contenant la liste des items d'une relation
  289.      *
  290.      * @access  public
  291.      * @param string $type Ce qu'on recherche
  292.      * @param string $idtext L'id de l'objet
  293.      * @return  array
  294.      */
  295.     public function getItemsList($iddvd, $type)
  296.     {
  298.         // fausse relation
  299.         if ($type == 'add_from_spectacle') {
  300.             return array();
  301.         }
  303.         $type_search = str_replace('dvd_', '', $type);
  305.         if (in_array($type_search, $this->array_types)) {
  306.             return $this->getLinkedObject($this->getRelationsArray($type), $iddvd, $type, 'dvds');
  307.         } else {
  308.             return 'Aucune fonction de recherche pour le type <strong>' . $type . '</strong> dans la méthode !';
  309.         }
  311.     }
  313.     // }}}
  315.     //  {{{ getRelationsArray()
  317.     /** Tableau des relations
  318.      *
  319.      * @access  public
  320.      * @param string|int $type le type de champ
  321.      */
  322.     public function getRelationsArray($type = null)
  323.     {
  325.         // récupérer les relations communes
  326.         $array_types = $this->getRelationsArrayTrait('all');
  328.         $persons = array(
  329.             26 => array('moviedirector', 'Réalisateur(s)'),
  330.             21 => array('author', 'Auteur(s)'),
  331.             1 => array('director', 'Metteur(s) en scène'),
  332.             5 => array('comedien', 'Acteur(s)'),
  333.             25 => array('intervenant', 'Intervenant(s)'),
  334.         );
  336.         $array_types = array(
  337.             'dvd_spectacle' => array(
  338.                 'type_join' => 'multiple',
  339.                 'dest_table' => 'spectacles',
  340.                 'fields' => array('idspectacle', 'title', 'url_clean'),
  341.                 'join_table' => 'dvd_spectacle',
  342.                 'hide_relation' => true,
  343.                 'silent_delete_relation' => true,
  344.                 'description' => 'Spectacle(s) associé(s) à ce DVD',
  345.             ),
  346.             'dvd_multimedia' => array(
  347.                 'type_join' => 'multiple',
  348.                 'dest_table' => 'multimedias',
  349.                 'fields' => array('idmultimedia', 'sujet_titre', 'url_clean', 'status', 'price'),
  350.                 'join_table' => 'dvd_multimedia',
  351.                 'hide_relation' => true,
  352.                 'silent_delete_relation' => true,
  353.                 'description' => 'Multimédia(s) associé(s) à ce DVD',
  354.             ),
  355.             'dvd_tournage' => array(
  356.                 'type_join' => 'multiple',
  357.                 'dest_table' => 'contacts',
  358.                 'fields' => array('idcontact', 'organisation', 'firstname', 'lastname', 'url_clean'),
  359.                 'join_table' => 'dvd_contact',
  360.                 'where' => ' AND j2.idrole=27', // idrole sur la table dvd_contact
  361.                 'hide_relation' => true,
  362.                 'silent_delete_relation' => true,
  363.                 'description' => 'Lieu(x) de tournage associé(s) à ce DVD',
  364.             ),
  365.             'dvd_editeur' => array(
  366.                 'type_join' => 'multiple',
  367.                 'dest_table' => 'contacts',
  368.                 'fields' => array('idcontact', 'organisation', 'firstname', 'lastname', 'url_clean'),
  369.                 'join_table' => 'dvd_contact',
  370.                 'where' => ' AND j2.idrole=28', // idrole sur la table dvd_contact
  371.                 'hide_relation' => true,
  372.                 'silent_delete_relation' => true,
  373.                 'description' => 'Editeur(x) associé(s) à ce DVD',
  374.             ),
  375.             'dvd_production' => array(
  376.                 'type_join' => 'multiple',
  377.                 'dest_table' => 'contacts',
  378.                 'fields' => array('idcontact', 'organisation', 'firstname', 'lastname', 'url_clean'),
  379.                 'join_table' => 'dvd_contact',
  380.                 'where' => ' AND j2.idrole=17', // idrole sur la table dvd_contact
  381.                 'hide_relation' => true,
  382.                 'silent_delete_relation' => true,
  383.                 'description' => 'Production',
  384.             )
  385.         );
  387.         foreach ($persons as $k => $v) {
  388.             $array_types['dvd_' . $v[0]] = array(
  389.                 'type_join' => 'multiple',
  390.                 'dest_table' => 'persons',
  391.                 'fields' => array('idperson', 'lastname', 'firstname', 'url_clean', 'valid'),
  392.                 'where' => ' AND j2.idrole=' . $k, // idrole sur la table dvd_person
  393.                 'join_table' => 'dvd_person',
  394.                 'hide_relation' => true,
  395.                 'silent_delete_relation' => true,
  396.                 'description' => $v[1] . ' associé(s) à ce DVD',
  397.             );
  398.         }
  400.         if (!empty($array_types[$type])) {
  401.             $array_types[$type]['type'] = $type;
  402.             return $array_types[$type];
  403.         } else {
  404.             return $array_types;
  406.         }
  408.     }
  410.     // }}}
  412.     //  {{{ getDvdformats()
  414.     /** Récupérer les formats DVD
  415.      *
  416.      * @access public
  417.      * @return array  les infos sous forme de tableau
  418.      */
  419.     public function getDvdformats()
  420.     {
  421.         return $this->getEntityManager()->getRepository(Dvdformats::class)->getDvdformats();
  422.     }
  424.     // }}}
  426.     //  {{{ getDvdzones()
  428.     /** Récupérer les zones
  429.      *
  430.      * @access public
  431.      * @return array  les infos sous forme de tableau
  432.      */
  433.     public function getDvdzones($select_list = true)
  434.     {
  435.         return $this->getEntityManager()->getRepository(Dvdzones::class)->getDvdzones($select_list);
  436.     }
  438.     // }}}
  440.     //  {{{ getDvdtechnos()
  442.     /** Récupérer les technos DVD
  443.      *
  444.      * @access public
  445.      * @return array  les infos sous forme de tableau
  446.      */
  447.     public function getDvdtechnos($select_list = true)
  448.     {
  449.         return $this->getEntityManager()->getRepository(Dvdtechnos::class)->getDvdtechnos($select_list);
  450.     }
  452.     // }}}
  454.     //  {{{ getVignetteDvd()
  456.     /** Récupére la vignette d'un DVD ou la crée si besoin
  457.      *
  458.      * @access   public
  459.      * param     int iddvd identifiant du dvd
  460.      * @return   string
  461.      */
  462.     public function getVignetteDvd($iddvd = null, $format = array())
  463.     {
  465.         if (empty($iddvd)) {
  466.             $iddvd = $this->iddvd;
  467.         }
  469.         // par default : image normal 70px x 70px qualite 75
  470.         if (!empty($format)) {
  471.             $set_format = $format;
  472.         } else {
  473.             $set_format = array('width' => $_ENV['VIGN_DVD_WIDTH'], 'height' => $_ENV['VIGN_DVD_HEIGHT'], 'direction' => 'thumb');
  474.         }
  476.         // generation par la classe Images
  477.         if (!isset($this->images)) {
  478.             $this->images = new Images();
  479.         }
  480.         $this->images->setVignetteFormat($set_format);
  481.         return $this->images->getVignetteObject($iddvd, 'dvds', 'class_pochette_dvd');
  483.     }
  485.     // }}}
  487.     //  {{{ getDvdsFromMultimedia()
  489.     /** Récupére les DVDs à partir d'un document multimedia
  490.      *
  491.      * @access   public
  492.      * @param int $idmultimedia Identifiant de la vidéo
  493.      * @param int $count_only compter seulement le nb de vidéo liées
  494.      * @return   array|int
  495.      */
  496.     public function getDvdsFromMultimedia($idmultimedia, $count_only = false)
  497.     {
  499.         $sql = 'SELECT';
  501.         if ($count_only) {
  502.             $sql = ' COUNT(*) ';
  503.         } else {
  504.             $sql .= ' * ';
  505.         }
  507.         $sql .= '
  508.             FROM dvd_multimedia dm, dvds d
  509.             WHERE dm.`iddvd`=d.`iddvd`
  510.             AND dm.`idmultimedia`=' . (int)$idmultimedia . '
  511.             AND d.`publish`=1';
  513.         $list_dvds = $this->db->queryAll($sql);
  515.         return $list_dvds;
  517.     }
  519.     // }}}
  521.     //  {{{ getSQLDvds()
  523.     /** Générer la requete standard pour des dvds
  524.      *
  525.      * $params = array(
  526.      *  'select' => champs en plus pour le select,
  527.      *  'from' => champs en plus pour le from,
  528.      *  'where' => paramètres en plus le where,
  529.      *  'order' => classement des résultats,
  530.      *  'limit' => limiter le nb de résultats array(debut,fin), (all pour pas de limit)
  531.      * )
  532.      * $special = array(
  533.      *  'select_by_text_or_adaptation' => text et adaptation,
  534.      *  'prochains' => true = date dans le future, un entier = fait un between
  535.      *  'anciens' =>
  536.      *  'join' => jointure gauche sur contacts et schedules
  537.      * )
  538.      *
  539.      *
  540.      * @access   public
  541.      * @param array $params Les paramètres pour la requete
  542.      * @param array $special Les paramètres supplémentaires
  543.      * @param bool $debug afficher la requête TODO
  544.      * @return   string
  545.      */
  546.     public function getSQLDvds($query = array(), $debug = false)
  547.     {
  549.         // on prepare les tableaux
  550.         foreach (array('select', 'from', 'where', 'order', 'group', 'limit') as $t) {
  551.             if (!empty($query[$t])) {
  552.                 if (!is_array($query[$t])) {
  553.                     $query[$t][] = $query[$t];
  554.                 } else {
  555.                     $query[$t] = $query[$t];
  556.                 }
  557.             } else {
  558.                 $query[$t] = array();
  559.             }
  560.         }
  562.         // champs par défaut
  563.         if (empty($query['count_only'])) {
  564.             $this->addSQLParams('select', $query, array(
  565.                 array('dvds' => '*')
  566.             ));
  567.         } else {
  568.             $this->addSQLParams('from', $query, array(
  569.                 'dvds',
  570.             ));
  571.         }
  573.         // publié ou pas
  574.         if (empty($query['publish']) && $_ENV['CHECK_IF_ONLINE']) {
  575.             $this->addSQLParams('where', $query, array(
  576.                 array('dvds', 'publish', 1)
  577.             ));
  578.         } elseif (!empty($query['publish'])) {
  579.             $this->addSQLParams('where', $query, array(
  580.                 array('dvds', 'publish', $query['publish'])
  581.             ));
  582.         }
  584.         // recherche par liaison via dvd_multimedia
  585.         if (!empty($query['special']['idmultimedias'])) {
  586.             $this->addSQLParams('from', $query, array(
  587.                 'dvd_multimedia',
  588.             ));
  589.             // jointure entre les 3 tables
  590.             $this->addSQLParams('join', $query, array(
  591.                 'dvds.`iddvd`' => 'dvd_multimedia.`iddvd`',
  592.             ));
  593.             $this->addSQLParams('where', $query, array(
  594.                 array('dvd_multimedia', 'idmultimedia', $query['special']['idmultimedias']),
  595.             ));
  596.         }
  598.         // recherche par VOD
  599.         if (!empty($query['special']['vods'])) {
  600.             $this->addSQLParams('from', $query, array(
  601.                 'dvd_multimedia',
  602.                 'dvd_spectacle',
  603.                 'multimedias',
  604.             ));
  605.             // jointure entre les 3 tables
  606.             $this->addSQLParams('join', $query, array(
  607.                 'dvds.`iddvd`' => 'dvd_multimedia.`iddvd`',
  608.                 'multimedias.`idmultimedia`' => 'dvd_multimedia.`idmultimedia`',
  609.             ));
  610.             // jointure entre les 3 tables
  611.             $this->addSQLParams('join', $query, array(
  612.                 'dvds.`iddvd`' => 'dvd_spectacle.`iddvd`',
  613.             ));
  614.             $this->addSQLParams('where', $query, array(
  615.                 array('multimedias', 'status', 5),
  616.                 array('multimedias', 'publish', 1),
  617.             ));
  618.         }
  620.         // recherche par liaison via dvd_person
  621.         if (!empty($query['special']['idpersons'])) {
  622.             $this->addSQLParams('from', $query, array(
  623.                 'dvd_person',
  624.             ));
  625.             // jointure entre les 3 tables
  626.             $this->addSQLParams('join', $query, array(
  627.                 'dvds.`iddvd`' => 'dvd_person.`iddvd`',
  628.             ));
  629.             $this->addSQLParams('where', $query, array(
  630.                 array('dvd_person', 'idperson', $query['special']['idpersons']),
  631.             ));
  632.             // ajouter le role
  633.             if (!empty($query['special']['idrole_person'])) {
  634.                 $this->addSQLParams('where', $query, array(
  635.                     array('dvd_person', 'idrole', $query['special']['idrole_person']),
  636.                 ));
  637.             }
  638.         }
  640.         // recherche par liaison via dvd_contact
  641.         if (!empty($query['special']['idcontacts'])) {
  642.             $this->addSQLParams('from', $query, array(
  643.                 'dvd_contact',
  644.             ));
  645.             // jointure entre les 3 tables
  646.             $this->addSQLParams('join', $query, array(
  647.                 'dvds.`iddvd`' => 'dvd_contact.`iddvd`',
  648.             ));
  649.             $this->addSQLParams('where', $query, array(
  650.                 array('dvd_contact', 'idcontact', $query['special']['idcontacts']),
  651.             ));
  652.             // ajouter le role
  653.             if (!empty($query['special']['idrole_contact'])) {
  654.                 $this->addSQLParams('where', $query, array(
  655.                     array('dvd_contact', 'idrole', $query['special']['idrole_contact']),
  656.                 ));
  657.             }
  658.         }
  660.         // recherche par liaison via dvd_spectacle
  661.         if (!empty($query['special']['idspectacles'])) {
  662.             $this->addSQLParams('from', $query, array(
  663.                 'dvd_spectacle',
  664.             ));
  665.             // jointure entre les 3 tables
  666.             $this->addSQLParams('join', $query, array(
  667.                 'dvds.`iddvd`' => 'dvd_spectacle.`iddvd`',
  668.             ));
  669.             $this->addSQLParams('where', $query, array(
  670.                 array('dvd_spectacle', 'idspectacle', $query['special']['idspectacles']),
  671.             ));
  672.         }
  674.         return $this->getSQLObject($query);
  676.     }
  678.     // }}}
  680.     //  {{{ getListDvds()
  682.     /** Retourne des listes de dvds
  683.      *
  684.      * Retourne des listes de dvd au format "standard""
  685.      *
  686.      * @access   public
  687.      * @param array $params_sql paramètre pour la requete SQL
  688.      * @param array $format_vignette de la vignette si pas standard
  689.      * @param array $params_display paramètre pour l'affichage
  690.      * @return   array
  691.      */
  692.     public function getListDvds($params_sql = null, $format_vignette = array(), $params_display = array())
  693.     {
  695.         // si pas de tableau
  696.         if (!isset($params_sql['special'])) {
  697.             $params_sql['special'] = array();
  698.         }
  699.         if (!isset($params_sql['params'])) {
  700.             $params_sql['params'] = array();
  701.         }
  703.         // construction de la requête avec le passage de paramètres
  704.         $sql = $this->getSQLDvds($params_sql);
  706.         // vignettes
  707.         if (empty($format_vignette['vignette_format'])) {
  708.             $format_vignette['vignette_format'] = array('width' => $_ENV['VIGN_DVD_WIDTH'], 'height' => $_ENV['VIGN_DVD_HEIGHT'], 'direction' => 'thumb');
  709.         }
  711.         // paramètre de debug
  712.         $dbg = (empty($params_sql['dbg'])) ? array() : $dbg = $params_sql['dbg'];
  714.         // executer la requete
  715.         $this->query($sql, $dbg);
  717.         $videos = array();
  719.         // donnée entières ?
  720.         if (empty($params_display['alldata'])) {
  721.             $params_display['alldata'] = false;
  722.         }
  724.         // debug
  725.         $start_boucle = microtime(true);
  727.         $dvds = array();
  729.         $datas = $this->query($sql);
  731.         // on boucle
  732.         foreach ($datas as $data) {
  734.             $this->loadResult($data);
  736.             // le total
  737.             if (!empty($params_sql['count_only'])) {
  738.                 return $this->total;
  739.             }
  740.             $iddvd = $this->iddvd;
  741.             if (!empty($params_sql['fields'])) {
  742.                 foreach ($params_sql['fields'] as $f) {
  743.                     $dvds[$iddvd][$f] = $this->$f;
  744.                 }
  745.             } else {
  746.                 $dvds[$iddvd] = $this->getInfosDvd($iddvd, array('all' => true), $format_vignette);
  747.                 if (empty($dvds[$iddvd]['comments'])) {
  748.                     $dvds[$iddvd]['description'] = $this->wikiTransform($this->comments);
  749.                 }
  750. //                $dvds[$iddvd]['description_courte'] = $this->cutSentence(strip_tags($dvds[$iddvd]['description']),45,true);
  751.                 $dvds[$iddvd]['dateinsert'] = $this->dateinsert;
  752.             }
  753.         }
  756.         // debug de la boucle
  757. //        if($this->isTraceMode('list_object')) {
  758. //            $this->setTraceInfos(array(
  759. //                'execution_time_boucle' => microtime(true) - $start_boucle,
  760. //                'nb_occurence' => count($dvds),
  761. //                'dbg' => $dbg,
  762. //            ));
  763. //        }
  765.         $this->free();
  767.         return $dvds;
  769.     }
  771.     // }}}
  773.     //  {{{ getObjectTitle()
  775.     /** Infos de l'item recherché
  776.      *
  777.      * Affichage standard du titre de l'objet
  778.      *
  779.      * @access public
  780.      * @param int $idobject Identifiant de l'item
  781.      * @param array $infos_object Informations pour construire le titre
  782.      * @param array $params Paramétres supplémentaires
  783.      * @return string
  784.      */
  785.     public function getObjectTitle($idobject = null, $infos_object = array(), $params = array())
  786.     {
  787.         $title = '';
  789.         if (!$idobject) {
  790.             $idobject = $this->iddvd;
  791.         }
  793.         // champs
  794.         $fields = array('iddvd', 'title', 'url_clean');
  796.         if (!empty($infos_object)) {
  798.             foreach ($fields as $k => $v) {
  799.                 if (array_key_exists($v, $infos_object)) {
  800.                     $$v = $infos_object[$v];
  801.                 }
  802.             }
  804.         } else {
  806.             //charger les infos que si necessaire
  807.             if (empty($this->title)) {
  808. //                $this->selectAdd();
  809. //                $this->selectAdd(join($fields, ','));
  810.                 $datas = $this->get($idobject);
  811.             }
  813.             $this->loadResult($datas);
  815. //            foreach($fields as $k=>$v) {
  816. //                if(isset($this->$v) && $this->$v!='') {
  817. //                    $$v = trim($this->$v);
  818. //                }
  819. //            }
  821.         }
  823.         return $title;
  825.     }
  827.     // }}}
  829.     //  {{{ getListSearch()
  831.     /** Liste des dvds
  832.      *
  833.      * Pour les champs Ajax de relations et les recherches diverses
  834.      *
  835.      * @access  public
  836.      * @param string $lettres Pour la recherche alphabetique
  837.      * @param string $type Pour le type recherche (editeurs, revues...)
  838.      * @param string $keywords Recherche par mots cles
  839.      * @return  array
  840.      */
  841.     public function getListSearch($lettre, $type = null, $keywords = null)
  842.     {
  843.         $sql = 'SELECT ' . $this->__idtable . ', title
  844.                  FROM ' . $this->__table . '
  845.                  WHERE 1 ';
  847.         // selection par ordre alpha
  848.         if (!empty($lettre) && $lettre != 'tous') {
  849.             $sql_where[] = array('LOWER(LEFT(LTRIM(title),1))=\'' . $this->escape($lettre) . '\'');
  850.         }
  852.         // recherche avec un mot cle
  853.         $list = $this->splitKeywords($keywords);
  855.         if ($list) {
  856.             if (!empty($list[$this->IDSTR])) {
  857.                 // mots clés
  858.                 foreach ($list[$this->IDSTR] as $s) {
  859.                     $sql_more_name[] = 'title LIKE \'%' . $s . '%\'';
  860.                 }
  861.                 $sql_where[] = array('(' . join(' OR ', $sql_more_name) . ')');
  862.             }
  863.             if (!empty($list[$this->IDNUM])) {
  864.                 // recherche par numéro d'id pour les mots clés numériques
  865.                 $sql_where[] = array('iddvd IN (' . implode(',', $list[$this->IDNUM]) . ')', 'OR');
  866.             }
  867.         }
  869.         foreach ($sql_where as $k => $v) {
  870.             if (!empty($v[1])) {
  871.                 $sql .= ' ' . $v[1] . ' ' . $v[0];
  872.             } else {
  873.                 $sql .= ' AND ' . $v[0];
  874.             }
  875.         }
  877.         $sql .= ' ORDER BY title';
  879.         $this->query($sql);
  881.         $r = array();
  883.         while ($this->fetch()) {
  884.             $r[$this->iddvd] = $this->title;
  885.             // si trouvé par id, on l'affiche en fin de titre
  886.             if (!empty($list[$this->IDNUM]) && in_array($this->iddvd, $list[$this->IDNUM])) {
  887.                 $r[$this->iddvd] .= ' - n°' . $this->iddvd;
  888.             }
  889.         }
  890.         $this->free();
  892.         return $r;
  893.     }
  895.     // }}}
  897.     //  {{{ countDvds()
  899.     /** Nombre de DVD
  900.      *
  901.      * Compter le nb de DVD
  902.      *
  903.      * @access  public
  904.      * @return  int
  905.      */
  906.     public function countDvds($object = null, $idobject = null)
  907.     {
  909.         if (!empty($object) && !empty($idobject)) {
  910.             $object = substr($object, 0, -1);
  911.             $sql_count = '
  912.                 SELECT COUNT(DISTINCT(d.`' . $this->__idtable . '`)) as total
  913.                 FROM ' . $this->__table . ' d, dvd_' . $object . ' do
  914.                 WHERE d.`publish`=1
  915.                 AND do.`iddvd`= d.`iddvd`
  916.                 AND do.`id' . $object . '`=' . (int)$idobject;
  917.         } else {
  918.             $sql_count = '
  919.                 SELECT COUNT(DISTINCT(' . $this->__idtable . ')) as total
  920.                 FROM ' . $this->__table . '
  921.                 WHERE publish=1';
  922.         }
  924.         $total = $this->queryOne($sql_count);
  926.         if ($total) {
  927.             return $total;
  928.         } else {
  929.             return null;
  930.         }
  932.     }
  934.     // }}}
  935. }