vendor/theatre/core/src/Repository/TextsRepository.php line 2068

Open in your IDE?
  1. <?php
  3. namespace TheatreCore\Repository;
  5. use TheatreCore\Classes\Images\Images;
  6. use TheatreCore\Entity\Aides;
  7. use TheatreCore\Entity\Contents;
  8. use TheatreCore\Entity\TextAide;
  9. use TheatreCore\Entity\Texts;
  10. use TheatreCore\Traits\TheatreTrait;
  11. use DateTime;
  12. use Doctrine\Bundle\DoctrineBundle\Repository\ServiceEntityRepository;
  13. use Doctrine\Persistence\ManagerRegistry;
  14. use Doctrine\ORM\Query;
  15. use Symfony\Contracts\Translation\TranslatorInterface;
  17. /**
  18.  * TextsRepository
  19.  *
  20.  * This class was generated by the Doctrine ORM. Add your own custom
  21.  * repository methods below.
  22.  */
  23. class TextsRepository extends ServiceEntityRepository
  24. {
  26.     use TheatreTrait {
  27.         getLinkedObject as protected getLinkedObjectTrait;
  28.     }
  30.     private $em;
  31.     public $__table;
  32.     public $__table_object;
  33.     public $__idtable;
  35.     public function __construct(ManagerRegistry $registry, TranslatorInterface $tr, Images $images)
  36.     {
  37.         parent::__construct($registry, Texts::class);
  38.         $this->__table = $this->getClassMetadata()->getTableName();
  39.         $this->__table_object = $this->getClassMetadata()->name;
  41.         $this->__idtable = $this->getClassMetadata()->getSingleIdentifierFieldName();
  43.         $this->translator = $tr;
  44.         $this->images = $images;
  45.     }
  47.     //  {{{ findData()
  49.     /** Recherche des texts
  50.      *
  51.      * Permet de rechercher des textes en fonction de certains critères :
  52.      * la première lettre, un bout du titre, le type de texte, si il est en ligne ou pas
  53.      *
  54.      * @access  public
  55.      * @see     Theatre::find()
  56.      */
  57.     public function findData($idtext = null, $idperson = null, $typetxt = null, $keywords = null, $lettre = null)
  58.     {
  59.         // query perso
  60.         $query = null;
  62.         $query = $this->createQueryBuilder('e');
  64.         // l'id du texte
  65.         if (isset($_REQUEST['idtext']) && (int)$_REQUEST['idtext']) {
  66.             $idtext = $_REQUEST['idtext'];
  67.         }
  68.         // l'id d'un auteur
  69.         if (isset($_REQUEST['idperson']) && (int)$_REQUEST['idperson']) {
  70.             $idperson = $_REQUEST['idperson'];
  71.         }
  72.         // premiere lettre du titre
  73.         if (isset($_REQUEST['lettre']) && !empty($_REQUEST['idperson'])) {
  74.             $lettre = $_REQUEST['lettre'];
  75.         }
  76.         // type de texte
  77.         if (isset($_REQUEST['typetxt']) && !empty($_REQUEST['typetxt'])) {
  78.             $typetxt = $_REQUEST['typetxt'];
  79.         }
  80. //        // mots cles
  81.         if (isset($_REQUEST['keywords']) && $_REQUEST['keywords'] != 'titre' && !empty($_REQUEST['keywords'])) {
  82.             $keywords = filter_var(trim($_REQUEST['keywords']), FILTER_SANITIZE_STRING, FILTER_FLAG_NO_ENCODE_QUOTES);
  83.             if ($this->my_is_int($keywords)) {
  84.                 $idtext = (int)$keywords;
  85.                 $keywords = null;
  86.             }
  87.         }
  88.         // liste des traductions
  89.         if (isset($_REQUEST['listtraductions']) && $_REQUEST['listtraductions'] == true) {
  90.             $listtraductions = true;
  91.         }
  92.         // publie ou pas
  93.         if (isset($_REQUEST['publish']) && !empty($_REQUEST['publish'])) {
  94.             $publish = $_REQUEST['publish'];
  95.         } else {
  96.             $publish = null;
  97.         }
  98.         // fictif ou pas
  99.         if (isset($_REQUEST['textfictif']) && !empty($_REQUEST['textfictif'])) {
  100.             $textfictif = (int)$_REQUEST['textfictif'];
  101.         } else {
  102.             $textfictif = 0;
  103.         }
  105.         // aides
  106.         if (isset($_REQUEST['idaide']) && $this->my_is_int($_REQUEST['idaide'])) {
  107.             $idaide = (int)$_REQUEST['idaide'];
  108.         }
  110.         $lng = 'fr'; //$GLOBALS['lng'];
  112.         $query_select = 'partial e.{title, date, type, idtext, publish, valid, statut, country, language, textfictif}';
  113.         $join_on = ',ct.' . $lng . ' as country_str,ln.' . $lng . ' as language_str';
  115. //        // on precise les champs pour le SELECT
  116.         if (empty($idperson)) {
  117. ////            $this->selectAdd();
  118. //            $this->selectAdd('title,date,type,idtext,publish,valid,country,language,textfictif');
  119.             $query->leftJoin('e.text_author', 'authors');
  120. //            $query->select('e, authors');
  121.             $query->select($query_select);
  122.         }
  123. //        // recherche par ID
  124.         if (!empty($idtext)) {
  125.             $query->andWhere('e.idtext=' . $idtext);
  126. //            $query .= ' AND t.idtext='.$idtext;
  127.         }
  128. //        // recherche par alphabet
  129.         if (!empty($lettre)) {
  130.             $query->andWhere('title REGEXP \'^' . $this->escape($lettre) . '\' ');
  131. ////            $query .= ' AND t.title REGEXP \'^'.$this->escape($lettre).'\' ';
  132.         }
  133. //        // recherche par mots cles
  134.         if (!empty($keywords)) {
  135. //            $this->whereAdd('title LIKE \'%'.$this->escape($keywords).'%\'');
  136. //            $query .= ' AND t.title LIKE \'%'.$this->escape($keywords).'%\'';
  137.         }
  138. //        // selectionne uniquement les textes originaux
  139.         if ($typetxt == 'original') {
  140. //            $this->whereAdd('type=0');
  141. //            $query .= ' AND t.type=0';
  142.         }
  143. //        // selectionne uniquement les traductions
  144.         if ($typetxt == 'translate') {
  145.             $query->andWhere('e.type = 1');
  146. //            $query .= ' AND t.type=1';
  147.         }
  148. //        // selectionne uniquement les adaptations
  149.         if ($typetxt == 'adaptation') {
  150.             $query->andWhere('e.type=2');
  151. //            $query .= ' AND t.type=2';
  152.         }
  153. //        // selectionne les textes/traductions/adaptations en cours de rédaction
  154.         if (!empty($publish)) {
  155.             $query->andWhere('e.publish=0');
  156. //            $query .= ' AND t.publish=0';
  157.         }
  158. //
  159. //        // selectionne les textes fictifs
  160. //        $this->whereAdd('textfictif='.$textfictif);
  161. //        $query .= ' AND t.textfictif='.$textfictif;
  162. //
  163. //        // selectionne uniquement les textes publies
  164.         if (!empty($this->isPublish) || (isset($GLOBALS['publish']) && $GLOBALS['publish'] == 1)) {
  165.             $query->andWhere('publish=1');
  166.             $query .= ' AND t.publish=1';
  167.         }
  168. //        // recherche par auteur ou traducteur
  169.         if (!empty($idperson)) {
  170. //            // jointure pour recherche par auteurs
  171.             if ($typetxt == 'original') {
  172.                 $ta = DB_DataObject::factory('textAuthor');
  173.                 $this->joinAdd($ta);
  174.                 $this->selectAs();
  175.                 $this->selectAs($ta, 'ta_%s');
  176.                 $this->whereAdd('text_author.idperson=' . $idperson);
  177.             }
  178.             // jointures pour recherche par traducteurs
  179.             if ($typetxt == 'translate') {
  180.                 $tt = DB_DataObject::factory('textTranslator');
  181.                 $this->joinAdd($tt);
  182.                 $this->selectAs($tt, 'tt_%s');
  183.                 $this->whereAdd('text_translator.idtext=' . $idperson);
  184.             }
  185.         }
  186. //
  187. //        $query = 'SELECT '.$query_select.' FROM texts t, countries ct, languages ln
  188. //                  WHERE 1
  189. //                  AND ct.id=t.country
  190. //                  AND ln.id=t.language '.$query;
  191. //
  192. //        $query = null;
  193. //
  194. //        // selectionne les traductions d'un texte
  195. //        if(!empty($idtext) && isset($listtraductions)) {
  196. //            $query = 'SELECT t.title,t.date,t.type,t.idtext,t.publish,t.valid,t.country,t.language,t.textfictif
  197. //                      FROM texts t, text_traduction tt
  198. //                      WHERE t.idtext=tt.idtexttraduction
  199. //                      AND tt.idtext='.$idtext;
  200. //        }
  201. //
  202. //        // les texts avec une aide
  203. //        if(!empty($idaide)) {
  204. //            $query = 'SELECT '.$query_select.',ta.*
  205. //                      FROM texts t, text_aide ta
  206. //                      WHERE t.idtext=ta.idtext
  207. //                      AND ta.idaide='.$idaide;
  208. //        }
  210.         if ($this->getCount()) {
  211.             $query->select('COUNT(e.idtext)');
  212.             $this->setCount(false);
  213.             return $query;
  214.         }
  216.         // on lance la recherche
  217.         return $query->getQuery();
  218.     }
  220.     // }}}
  222.     //  {{{ setToArray()
  224.     /** Listes des textes dans un tableau associatif
  225.      *
  226.      * Tableau associatif notament utilisé pour lister les informations sur des textes
  227.      * Utile pour gnérer les tableaux HTML de listes de textes
  228.      *
  229.      * @access  public
  230.      * @return  array
  231.      * @see     findData()
  232.      */
  233.     public function setToArray($spec = true)
  234.     {
  235.         if ($spec == true) {
  236.             $this->findData();
  237.         }
  239.         $values = array();
  240.         $color = null;
  241.         $nb = 0;
  243.         while ($this->fetch()) {
  245.             $this->getLinks();
  246.             $values[$nb] = $this->getInfosText();
  247.             $values[$nb]['id'] = $this->idtext;
  248.             $values[$nb]['valid'] = $this->valid;
  249.             $values[$nb]['statut'] = $this->statut;
  251.             // compter les traductions
  252.             if (isset($this->count_translations)) {
  253.                 $values[$nb]['translations_nb'] = $this->countTranslations($this->idtext);
  254.             }
  256.             // couleur de ligne alternative
  257.             $color = $this->colorAlternate($color);
  258.             $values[$nb]['colorline'] = $color;
  260.             $nb++;
  261.         }
  263.         return $values;
  264.     }
  266.     // }}}
  268.     //  {{{ getInfosText()
  270.     /** Infos sur un texte
  271.      *
  272.      * Retourne un tableau associatif avec les principales
  273.      * informations sur un texte
  274.      *
  275.      * @access  public
  276.      * @param int $idtext Identifiant de la fiche texte
  277.      * @return  array
  278.      * @see     findData()
  279.      */
  280.     public function getInfosText($idtext = null, $params_data = array())
  281.     {
  282.         $conn = $this->getEntityManager();
  284.         // infos de la table
  285.         if (!isset($this->idtext) || empty($this->idtext) || $this->idtext != $idtext) {
  286.             $this->idtext = $idtext;
  287.         }
  289.         $query = $this->createQueryBuilder('u')
  290.             ->select('u, idextranetuser, country, idcontact_publisher, idgenretext')
  291.             ->leftJoin('u.idextranetuser', 'idextranetuser')
  292.             ->leftJoin('u.idcontact_publisher', 'idcontact_publisher')
  293.             ->leftJoin('u.idgenretext', 'idgenretext')
  294.             ->leftJoin('u.idcontact_performing', 'idcontact_performing')
  295.             ->leftJoin('u.country', 'country')
  296.             ->where('u.idtext =:value')->setParameter('value', $this->idtext);
  298.         $this->datas = $infos = $query->getQuery()->getOneOrNullResult(Query::HYDRATE_ARRAY);
  300.         $infos['titleshort'] = $this->cutSentence($infos['title'], 40);
  301.         $infos['year'] = $infos['date'];
  302.         $infos['special_text'] = $infos['specialText'];
  304.         $infos['idgenretext_object'] = $infos['idgenretext'];
  305.         if (!empty($infos['idgenretext'])) {
  306.             $infos['idgenretext'] = $infos['idgenretext']['idgenretext'];
  307.         }
  309.         $infos['publisher_url_text'] = $infos['publisherUrlText'];
  311.         $infos['url_clean'] = $infos['urlClean'];
  312.         $infos['abstract_url'] = $infos['abstractUrl'];
  313.         $infos['abstract_author'] = $infos['abstractAuthor'];
  315.         if (isset($this->_country->fr)) {
  316.             $infos['country'] = $this->_country->fr;
  317.         } elseif (isset($this->country_str)) {
  318.             $infos['country'] = $this->country_str;
  319.         } else {
  320.             if (isset($infos['country']['id'])) {
  321.                 $infos['country'] = $infos['country']['id'];
  322.             }
  323.         }
  325.         $infos['country_src'] = $infos['language'];
  326.         $infos['language_src'] = $infos['language'];
  328.         $this->idtext = $idtext_original = $infos['idtext'];
  330.         switch ($infos['type']) {
  331.             /* Texte original */
  332.             case 0:
  333.                 $infos['typetxt'] = 'original';
  334.                 $infos['original'] = true;
  335.                 break;
  336.             /* Traduction */
  337.             case 1:
  338.                 $infos['typetxt'] = 'translate';
  339.                 $infos['translate'] = true;
  341.                 /* on veut l'auteur du texte original, pas de la traduction */
  342.                 $originalText = $this->getOriginalsTexts($this->idtext);
  344.                 // on renvoi l'id de l'original
  345.                 $idtext_original = key($originalText);
  346.                 $infos['idtextoriginal'] = $idtext_original;
  348.                 /* traducteurs */
  349.                 $infos['translators'] = $this->getTranslators($this->idtext);
  350.                 $infos['alltranslators'] = $this->noPunct($infos['translators']);
  352.                 // au dela de 1 traducteur, on dit que c'est un collectif
  353.                 $this->collectif($infos['translators'], 1);
  354.                 break;
  355.             /* Adaptation */
  356.             case 2:
  357.                 $infos['typetxt'] = 'adaptation';
  358.                 $infos['adaptation'] = true;
  360.                 // on recup les infos sur l'adaptation
  361.                 $infos['adaptation_infos'] = $this->getOriginalsTexts($this->idtext, 'text_adaptation', 'idtextadaptation');
  362.                 break;
  363.             default:
  364.                 error_log('Type de texte inconnu: ' . $infos['type']);
  365.                 break;
  366.         }
  368.         // auteurs
  369.         $infos['authors'] = $this->getPersons($idtext_original, 'text_author');
  371.         // tous les auteurs
  372.         $infos['allauthors'] = $this->noPunct($infos['authors']);
  374.         // au dela de 1 auteur, on dit que c'est un collectif
  375.         $this->collectif($infos['authors'], 2);
  377.         // voir si il y a des aides
  378.         if (!empty($params_data['get_aides'])) {
  379.             $infos['nb_aides'] = $conn->getRepository(TextAide::class)->countAides(null, $this->idtext);
  380.             if ($infos['nb_aides'] > 0) {
  381.                 $infos['aides'] = $conn->getRepository(TextAide::class)->getListTextAide(array(
  382.                     'idtext' => array($this->idtext),
  383.                     'get_texts_with_aides' => true,
  384.                     'dbg' => array('liste_aides', 'Liste des aides du texte')
  385.                 ));
  386.             }
  387.         }
  389.         // date de creation
  390.         $this->abstract_date = $infos['abstractDate'];
  391.         if (isset($this->abstract_date) && $this->abstract_date != '0000-00-00' && $this->abstract_date != null) {
  392.             $infos['abstract_date'] = $this->getFormeDate($this->abstract_date, $GLOBALS['format_date'][$GLOBALS['lng']]);
  393.             $infos['abstract_date_us'] = $this->abstract_date;
  394.         }
  396.         if ($infos['statut']) {
  397.             $infos['statut'] = $this->statut = $infos['statut'];
  398.             // incomplet ?
  399.             if ($infos['statut'] == 1) {
  400.                 $infos['validation_encours'] = true;
  401.             }
  402.             if ($infos['statut'] == 0) {
  403.                 $infos['incomplet'] = true;
  404.             }
  405.             if ($infos['statut'] > 1) {
  406.                 $infos['valide'] = true;
  407.             }
  408.         }
  410.         // utilisateur
  411.         if (isset($this->idextranetuser)) {
  412.             $infos['idextranetuser'] = $this->idextranetuser;
  413.         }
  415.         // récupèrer l'illustration
  416.         if (!empty($params_data['get_illustration'])) {
  417.             if (!empty($params_data['get_illustration']['format'])) {
  418.                 $illustrations = $conn->getRepository(Contents::class)->getIllustrations($infos['idtext'], 'texts', 'class_couv', $params_data['get_illustration']['format']);
  419.             } else {
  420.                 $illustrations = $conn->getRepository(Contents::class)->getIllustrations($infos['idtext'], 'texts', 'class_couv');
  421.             }
  423.             if (!empty($illustrations)) {
  424.                 // illustrations
  425.                 $infos['illustrations'] = $illustrations['illustrations'];
  427.                 // vignettes
  428.                 if (!empty($illustrations['vignette_object'])) {
  429.                     $infos['vignette_object'] = $illustrations['vignette_object'];
  430.                 }
  431.             }
  432.         }
  434.         $this->loadResult($infos);
  435.         return $infos;
  436.     }
  438.     // }}}
  440.     //  {{{ getInfosObject()
  442.     /** Alias de getInfosText
  443.      *
  444.      * @access  public
  445.      * @param int $idobject identifiant
  446.      * @return  array
  447.      * @see     getInfosText()
  448.      */
  449.     public function getInfosObject($idobject = null)
  450.     {
  451.         return $this->getInfosText($idobject);
  452.     }
  454.     // }}}
  456.     //  {{{ getTranslateTitle()
  458.     /** Recherche des titre traduit
  459.      *
  460.      * chercher le titre traduit du texte dans une langue donnée
  461.      *
  462.      * @access  public
  463.      * @param int $idtext Identifiant du texte
  464.      * @param string $lng Identifiant de la langue
  465.      * @param bool $all afficher toutes les infos
  466.      */
  467.     public function getTranslateTitle($idtext = null, $lng = null, $all = null)
  468.     {
  469.         try {
  470.             //requête qui va chercher le titre du texte dans une langue donnée
  471.             $sql = 'SELECT t.idtext, t.title, t.date, t.country, p.firstname, p.lastname
  472.                 FROM texts t, text_traduction tt, text_translator ttr, persons p
  473.                 WHERE t.idtext=tt.idtexttraduction
  474.                 AND t.idtext=ttr.idtext
  475.                 AND ttr.idperson=p.idperson
  476.                 AND t.language=\'' . $this->escape($lng) . '\' AND tt.idtext=' . ((int)$idtext) . ' AND t.publish=1';
  478.             $res = $this->query($sql);
  480.             if ($res->numRows() > 0) {
  481.                 while ($row = $res->fetchRow()) {
  482.                     if ($all == null) { // je veux tous le renseignements
  483.                         $result['idtext'] = $row['idtext'];
  484.                         $result['title'] = $row['title'];
  485.                         $result['date'] = $row['date'];
  486.                         $result['lastname'] = $row['lastname'];
  487.                         $result['firstname'] = $row['firstname'];
  488.                         $result['country'] = $row['country'];
  489.                     } else { // je prend juste le titre traduit
  490.                         $result = $row['title'];
  491.                     }
  492.                 }
  494.                 return $result;
  495.             } else { // aucune traduction pour ce texte
  496.                 if ($all == null) {
  497.                     return [];
  498.                 } else {
  499.                     return null;
  500.                 }
  501.             }
  502.         } catch (\Throwable $e) {
  503.             return null;
  504.         }
  505.     }
  507.     // }}}
  509.     //  {{{ getPersons()
  511.     /** Personnes associées à un texte
  512.      *
  513.      * Liste et les personnes associèes à un texte.
  514.      * On peux effectuer un tri par type (auteur, traducteur, éditeur...)
  515.      *
  516.      * @access  public
  517.      * @param int $idtext identifiant du texte
  518.      * @param string $type type recherché (auteur, traducteur...)
  519.      * @param string $type_contact non implémenté
  520.      * @return  array
  521.      */
  522.     public function getPersons($idtext = null, $type = 'text_author')
  523.     {
  524.         if (empty($idtext) && isset($this->idtext)) $idtext = $this->idtext;
  526.         $infos_link = $this->getRelationsArray($type);
  528.         if (!empty($infos_link)) {
  529.             return $this->getLinkedObject($infos_link, $idtext, $infos_link['type'], 'texts');
  530.         }
  531.     }
  533.     /// }}}
  535.     // {{{ getAuthors()
  537.     /** Auteurs d'un texte
  538.      *
  539.      * Liste les auteurs d'un texte (ou du texte orginal d'une traduction)
  540.      *
  541.      * @access  public
  542.      * @param int $idtext identifiant du texte
  543.      * @return  array
  544.      */
  545.     public function getAuthors($idtext = null, $type = null)
  546.     {
  547.         if (empty($idtext)) $idtext = $this->idtext;
  548.         if (!empty($this->type)) $type = $this->type;
  550.         // on recupere le type si besoin
  551.         // if (empty($this->type) && empty($type)) {
  553.             $queryBuilder = $this->createQueryBuilder('t');
  554.             $queryBuilder->select('t.type')
  555.                 ->andWhere('t.idtext = :idtext')
  556.                 ->setParameter('idtext', $idtext);
  557.             $query = $queryBuilder->getQuery();
  559.             $data = $query->getOneOrNullResult(Query::HYDRATE_ARRAY);
  561.             $type = $this->type = (int)$data['type'];
  563.             if (empty($this->idtext)) {
  564.                 $this->idtext = (int)$idtext;
  565.             }
  566.         // }
  568.         // si traduction, on récup l'id du texte original pour avoir l'auteur
  569.         if ($type == 1) {
  570.             $originalText = $this->getOriginalsTexts($idtext, 'text_traduction', 'idtexttraduction');
  571.             $idtext = key($originalText);
  572.         }
  574.         return $this->getPersons($idtext, 'text_author');
  575.     }
  577.     // }}}
  579.     //  {{{ getTranslators()
  581.     /** Traducteurs d'un texte
  582.      *
  583.      * Liste les traducteurs d'un texte
  584.      *
  585.      * @access  public
  586.      * @param int $idtext identifiant du texte
  587.      * @return  array
  588.      * @see getPersons()
  589.      */
  590.     public function getTranslators($idtext = null)
  591.     {
  592.         if (empty($idtext)) $idtext = $this->idtext;
  593.         return $this->getPersons($idtext, 'text_translator');
  594.     }
  596.     // }}}
  598.     //  {{{ getOriginalsTexts()
  600.     /** Sélection des textes originaux
  601.      *
  602.      * Textes originaux dont dépend une traduction ou une adaptation
  603.      *
  604.      * @access public
  605.      * @param string $idtextlie Identifiant de l'adaptation ou de la traduction
  606.      * @param string $table Nom de la table de liaison (text_traduction, text_adaptation...)
  607.      * @params string   $cle Nom de la clé de liaison
  608.      * @return array
  609.      */
  610.     public function getOriginalsTexts($idtextlie = null, $table = 'text_traduction', $cle = 'idtexttraduction', $params = array())
  611.     {
  612.         if (empty($idtextlie)) {
  613.             $idtextlie = $this->idtext;
  614.         }
  616.         $query = 'SELECT t.idtext, t.title, t.type, t.language, t.date, t.url_clean
  617.                   FROM texts t, ' . $table . ' tt
  618.                   WHERE t.idtext=tt.idtext
  619.                   AND tt.' . $cle . '=' . $idtextlie . '
  620.                   ORDER BY t.title';
  622.         $texts = $this->getEntityManager()->getConnection()->fetchAllAssociativeIndexed($query);
  624.         if (!empty($params['get_authors']) && !empty($texts)) {
  625.             foreach ($texts as $k => $v) {
  626.                 $texts[$k]['allauthors'] = $this->getAuthors($k, $v['type']);
  627.             }
  628.         }
  630.         return $texts;
  631.     }
  633.     // }}}
  635.     //  {{{ orderByDefaut()
  637.     /** Classement par défaut
  638.      *
  639.      * Défini le tri par défaut pour les requêtes de type SELECT
  640.      *
  641.      * @access public
  642.      * @return string
  643.      */
  644.     public function orderByDefaut($order = null)
  645.     {
  647.         // tri par défaut
  648.         if (empty($order)) {
  649.             $order = 'texts.idtext';
  650.         }
  652.         return $order;
  654.     }
  656.     // }}}
  658.     //  {{{ countSpectacles()
  660.     /** Compter le nombre de spectacle pour un texte et ses adaptations
  661.      *
  662.      *
  663.      * @access public
  664.      * @param int $idtext Identifiant du texte
  665.      * @return int
  666.      */
  667.     public function countSpectacles($idtext = null, $publish = false, $params = array())
  668.     {
  669.         $idtext = (int)$idtext;
  670.         if ($idtext <= 0) return 0;
  672.         // On prépare les résultats pour la condition de la requête
  673.         $list_idtextadaptation = $this->queryCol('SELECT DISTINCT(ta.idtextadaptation) FROM text_adaptation ta WHERE ta.idtext=' . $idtext);
  674.         $list_idtext = $this->queryCol('SELECT t.idtext FROM texts t WHERE t.idtext=' . $idtext);
  675.         $resutat_function_textes = array_merge_recursive($list_idtext, $list_idtextadaptation);
  677.         $sql = 'SELECT COUNT(DISTINCT(s.idspectacle)) as total
  678.             FROM text_spectacle ts, spectacles s
  679.             WHERE ts.idspectacle=s.idspectacle';
  681.         // est-ce qu'on veux les publié ou pas ?
  682.         if ($publish != false) {
  683.             $sql .= ' AND s.publish=' . (int)$publish;
  684.         }
  686.         //compter aussi les adaptations
  687.         $sql .= ' AND (ts.idtext=' . $idtext . '
  688.                 OR ts.idtext IN (
  689.                     ' . implode(',', $resutat_function_textes) . '
  690.                 )';
  692.         //compter aussi les adaptations à l'étranger
  693.         if (array_key_exists('countforeignshow', $params)) {
  694.             $sql .= 'OR ts.idtext IN(
  695.                     SELECT DISTINCT(t.idtext)
  696.                             FROM
  697.                                 texts t,
  698.                                 text_traduction tt
  699.                             WHERE
  700.                             t.idtext = tt.idtexttraduction
  701.                             AND tt.idtext = ' . $idtext . '
  702.                 )';
  703.         }
  705.         $sql .= ')';
  707.         return $this->queryOne($sql);
  708.     }
  710.     // }}}
  712.     //  {{{ countTranslations()
  714.     /** Compter le nombre de traductions pour un texte
  715.      *
  716.      * @access public
  717.      * @param int $idtext Identifiant du texte
  718.      * @return int
  719.      */
  720.     public function countTranslations($idtext = null, $publish = false)
  721.     {
  723.         if (empty($idtext)) {
  724.             $sql = 'SELECT COUNT(DISTINCT(t.`idtext`)) as total
  725.                     FROM texts t
  726.                     WHERE t.`type`=1';
  727.         } else {
  728.             $sql = 'SELECT COUNT(DISTINCT(t.`idtext`)) as total
  729.                     FROM text_traduction tt, texts t
  730.                     WHERE tt.`idtexttraduction`=t.`idtext` AND tt.`idtext`=' . $idtext;
  731.         }
  733.         // est-ce qu'on veux les publié ou pas ?
  734.         if ($publish != false) {
  735.             $sql .= ' AND t.publish=' . $publish;
  736.         }
  738.         return $this->queryOne($sql);
  739.     }
  741.     // }}}
  743.     //  {{{ getCountTranslations()
  745.     /** faut-il compter (dans des listes de resultats) ?
  746.      *
  747.      * @access public
  748.      * @param bool $count
  749.      * @return int
  750.      */
  752.     public function getCountTranslations($count = true)
  753.     {
  755.         if ($count == true) {
  756.             $this->count_translations = true;
  757.         }
  759.     }
  761.     // }}}
  763.     //  {{{ countLanguageTranslations()
  765.     /** Compter le nombre de langue de traduction pour un texte
  766.      *
  767.      * Défini le tri par défaut pour les requêtes de type SELECT
  768.      *
  769.      * @access public
  770.      * @param int $idtext Identifiant du texte
  771.      * @return int
  772.      */
  773.     public function countLanguageTranslations($idtext = null)
  774.     {
  776.         $sql = 'SELECT COUNT(DISTINCT(t.language))
  777.                  FROM texts t, text_traduction tt
  778.                  WHERE tt.idtext=' . ((int)$idtext) . '
  779.                  AND t.idtext=tt.idtexttraduction';
  781.         return $this->queryOne($sql);
  783.     }
  785.     // }}}
  787.     //  {{{ getListLanguageTranslations()
  789.     /** Liste des langues d'un texte
  790.      *
  791.      * @access  public
  792.      * @param int $idtext id du texte
  793.      * @return  array
  794.      */
  795.     public function getListLanguageTranslations($idtext)
  796.     {
  797.         //langue
  798.         $tr = $GLOBALS['tr'];
  800.         $sql = null;
  802.         // requete
  803.         $sql = 'SELECT DISTINCT(t.language),t.idtext
  804.                 FROM texts t,text_traduction tt
  805.                 WHERE tt.idtext=' . $idtext . '
  806.                 AND t.idtext=tt.idtexttraduction GROUP BY t.language';
  808.         // execution de la requete
  809.         $this->query($sql);
  811.         while ($this->fetch()) {
  812.             $lg = $this->getLink('language', 'languages', 'id');
  813.             $lang[$this->idtext]['lang'] = $lg->$GLOBALS['lng'];
  814.             $lang[$this->idtext]['idtext'] = $this->idtext;
  815.         }
  817.         // retourner les enregistrements
  818.         return $lang;
  819.     }
  821.     // }}}
  823.     //  {{{ getListSearch()
  825.     /** Liste des textes
  826.      *
  827.      * Pour les champs Ajax de relations et les recherches diverses
  828.      * permet de générer un tabelau associatif des titres des textes en
  829.      * fonction de critères de recherche alphabétique ou mots clès
  830.      *
  831.      * @access  public
  832.      * @param string $lettres Pour la recherche alphabetique
  833.      * @param string $keywords Recherche par mots cles
  834.      * @return  array
  835.      */
  836.     public function getListSearch($lettre, $type = null, $keywords = null, $other, $type_object = null)
  837.     {
  839.         $queryBuilder = $this->createQueryBuilder('t');
  840.         $queryBuilder->select('partial t.{idtext,title,type,country,language}');
  842.         // uniquement les textes originaux
  843.         if ($type != 'text_spectacle' && $type != 'new_text' && $type != 'podcast_text' && $type != 'idobject' && $type_object != 'playlist') {
  844.             $queryBuilder->andWhere('t.type=0');
  845.         }
  847.         // selection par ordre alpha
  848.         if (!empty($lettre)) {
  849. //            $queryBuilder->andWhere('LOWER(LEFT(LTRIM(t.title),1))=\''.$this->escape($lettre).'\'');
  850.             $queryBuilder->andWhere('t.title LIKE \'' . $this->escape($lettre) . '%\'');
  851.         }
  853.         // recherche avec un mot cle
  854.         $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.                     $queryBuilder->andWhere('t.title LIKE \'%' . $s . '%\'');
  860.                 }
  861.             }
  862.             if (!empty($list[$this->IDNUM])) {
  863.                 // recherche par numéro d'id pour les mots clés numériques
  864.                 $queryBuilder->orWhere('idtext IN (' . implode(',', $list[$this->IDNUM]) . ')');
  865.             }
  866.         }
  868. //        $this->orderBy('title');
  869.         $query = $queryBuilder->getQuery();
  870.         $texts = $query->getResult(Query::HYDRATE_ARRAY);
  872. //        $this->find();
  874.         $r = array();
  877.         foreach ($texts as $text) {
  878.             $this->loadResult($text);
  879.             // texte et auteur (ou collectif)
  880.             $r[$this->idtext] = $this->cutSentence($this->title, 45) . ' (' . $this->getOneAuthor() . ')';
  881.             // si c'est une traduction, ajouter le code langue
  882.             if ($this->type == 1) {
  883.                 $r[$this->idtext] .= ' (' . $this->language . ')';
  884.             }
  885.             // si trouvé par id, on l'affiche en fin de titre
  886.             if (!empty($list[$this->IDNUM]) && in_array($this->idtext, $list[$this->IDNUM])) {
  887.                 $r[$this->idtext] .= ' - n°' . $this->idtext;
  888.             }
  890.         }
  891.         $this->free();
  893.         return $r;
  895.     }
  897.     // }}}
  899.     //  {{{ getOneAuthor()
  901.     /** Retourner sous forme de string le nom de l'auteur ou 'collectif'
  902.      *
  903.      * @param int $idtext Identifiant du texte
  904.      * @return  string
  905.      */
  906.     public function getOneAuthor($idtext = null)
  907.     {
  909.         $author = null;
  911.         if (empty($idtext)) {
  912.             $idtext = $this->idtext;
  913.         }
  915.         if ($authors = $this->getAuthors($idtext)) {
  917.             if (count($authors) > 1) {
  918.                 $author = 'Collectif';
  919.             } else {
  920.                 foreach ($authors as $key => $value) {
  921.                     if (!empty($value['firstname'])) {
  922.                         $author .= $value['firstname'] . ' ';
  923.                     }
  924.                     $author .= $value['lastname'];
  925.                 }
  926.             }
  928.         }
  930.         return $author;
  931.     }
  933.     // }}}
  935.     //  {{{ getObjectTitle()
  937.     /** Infos de l'item recherché
  938.      *
  939.      * Pour les champs Ajax de relations
  940.      *
  941.      * @access private
  942.      */
  943.     public function getObjectTitle($idobject = null, $infos_object = array(), $params = array())
  944.     {
  946.         // si on n'a pas passé l'id a la méthode, on doit-être dans une boucle
  947.         if (!$idobject) {
  948.             $idobject = $this->idtext;
  949.         }
  951.         $fields = array('idtext', 'title', 'type', 'url_clean', 'valid');
  953.         // si on a les valeurs
  954.         if (!empty($infos_object)) {
  955.             foreach ($fields as $k => $v) {
  956.                 if (array_key_exists($v, $infos_object)) {
  957.                     $infos[$v] = $infos_object[$v];
  958.                 }
  959.             }
  960.         } else { // si on n'a les valeurs dans une boucle
  961.             // si on n'a pas $this->title, c'est qu'il faut les infos
  962.             if (!isset($this->title)) {
  964.                 $sql = 'SELECT ' . implode(',', $fields) . '
  965.                         FROM ' . $this->__table . '
  966.                         WHERE ' . $this->__idtable . '=' . ((int)$idobject);
  968.                 $infos = $this->queryRow($sql);
  970.                 if (empty($infos)) {
  971.                     return false;
  972.                 }
  973.             } else { // sinon, dans le tableau infos
  974.                 foreach ($fields as $k => $v) {
  975.                     if (isset($this->$v) && $this->$v != '') {
  976.                         $infos[$v] = trim($this->$v);
  977.                     }
  978.                 }
  979.             }
  980.         }
  982.         // title
  983.         $title_view = $infos['title'];
  985.         // ajouter les metteurs en scène en chaine si demandé
  986.         if (!array_key_exists('noauthor', $params)) {
  987.             $infos_author = $this->getOneAuthor($infos['idtext']);
  988.             if (!empty($infos_author)) {
  989.                 $title_view .= ' (' . $infos_author . ')';
  990.                 $infos['title'] = $title_view;
  991.             }
  992.         }
  994.         // renvoyer un array plutôt que le titre (utile si on veux l'url)
  995.         if (array_key_exists('return_array', $params)) {
  996.             return $infos;
  997.         }
  999.         return $title_view;
  1001.     }
  1003.     // }}}
  1005.     //  {{{ getGenretextList()
  1007.     /** Liste des genres de texte
  1008.      *
  1009.      * @access  public
  1010.      * @return  array
  1011.      */
  1012.     public function getGenretextList($plus = null, $visibility = null, $return_array = false)
  1013.     {
  1014.         $sql_genretext = 'SELECT idgenretext,genretext FROM genretexts ';
  1015.         if (!empty($visibility)) {
  1016.             $sql_genretext .= ' WHERE visibility IN (' . $this->arrayToIn($visibility) . ') ';
  1017.         }
  1018.         $sql_genretext .= ' ORDER BY ordergenre';
  1020.         $genre_list = $this->getEntityManager()->getConnection()->fetchAllKeyValue($sql_genretext);
  1022.         // objet de traduction
  1023.         $tr = $GLOBALS['tr'];
  1025.         if (!$return_array) {
  1026.             foreach ($genre_list as $k => $v) {
  1027.                 $new_genre_list[$k] = $tr->trans($v . $plus);
  1028.             }
  1029.         } else {
  1030.             foreach ($genre_list as $k => $v) {
  1031.                 $new_genre_list[$k]['name'] = $tr->trans($v . $plus);
  1032.                 $new_genre_list[$k]['code'] = str_replace('genre_', '', $v);
  1033.             }
  1034.         }
  1036.         return $new_genre_list;
  1037.     }
  1039.     // }}}
  1041.     //  {{{ getTypeText()
  1043.     /** Retrouver le type de texte
  1044.      *
  1045.      * @access  public
  1046.      * @param int idtype ID du type de texte
  1047.      * @return  string
  1048.      */
  1049.     public function getTypeText($idtype)
  1050.     {
  1052.         if (empty($typetxt)) {
  1053.             if ($idtype == 1) {
  1054.                 $typetxt = 'translate';
  1055.             } else if ($idtype == 2) {
  1056.                 $typetxt = 'adaptation';
  1057.             } else {
  1058.                 $typetxt = 'original';
  1059.             }
  1060.         }
  1062.         return $typetxt;
  1064.     }
  1066.     // }}}
  1068.     //  {{{ getVignetteText()
  1070.     /** Récupére la vignette d'un texte ou la cree si besoin
  1071.      *
  1072.      * @access   public
  1073.      * param     int idtext identifiant du texte
  1074.      * @return   string
  1075.      */
  1076.     public function getVignetteText($idtext = null, $format = array())
  1077.     {
  1079.         if (empty($idtext)) {
  1080.             $idtext = $this->idtext;
  1081.         }
  1083.         // par default : image normal 100px x 100px qualite 75
  1084.         if (!empty($format)) {
  1085.             $set_format = $format;
  1086.         } else {
  1087.             $set_format = array('width' => $_ENV['VIGN_TEXT_WIDTH'], 'height' => $_ENV['VIGN_TEXT_HEIGHT'], 'direction' => 'thumb');
  1088.         }
  1090.         // generation par la classe Images
  1091.         if (!isset($this->images)) {
  1092.             $this->images = Images::getInstance($this->getEntityManager());
  1093.         }
  1095.         $this->images->setVignetteFormat($set_format);
  1096.         return $this->images->getVignetteObject($idtext, 'texts', 'class_couv');
  1098.     }
  1100.     // }}}
  1102.     // {{{ getInfosTextRow()
  1104.     /** Retrouner un tableau standard dans les listes
  1105.      *
  1106.      *
  1107.      * @param bool $allauthors afficher les auteurs
  1108.      * @param bool $vignette trouver les vignettes
  1109.      * @param bool $genre le genre
  1110.      * @param bool $tabpublisher publisher sous forme de tableau
  1111.      * @access public
  1112.      * @return array
  1113.      */
  1114.     public function getInfosTextRow($allauthors = true, $vignette = true, $genre = false, $tabpublisher = true, $params = array())
  1115.     {
  1116.         $month = array(
  1117.             1 => 'Janvier',
  1118.             2 => 'Février',
  1119.             3 => 'Mars',
  1120.             4 => 'Avril',
  1121.             5 => 'Mai',
  1122.             6 => 'Juin',
  1123.             7 => 'Juillet',
  1124.             8 => 'Août',
  1125.             9 => 'Septembre',
  1126.             10 => 'Octobre',
  1127.             11 => 'Novembre',
  1128.             12 => 'Decembre',
  1129.         );
  1131.         $txt = array();
  1132.         $idtext = $this->idtext;
  1134.         // id du texte, titre, url, auteur du texte
  1135.         $txt['idtext'] = $idtext;
  1136.         $txt['title'] = $this->title;
  1137.         $txt['url_clean'] = $this->url_clean;
  1138.         if (isset($this->date)) {
  1139.             $txt['date'] = $this->date;
  1140.         }
  1142.         $txt['textorder'] = $this->textorder;
  1144.         // date d'écriture
  1145.         if (isset($this->datewrite)) {
  1146.             $txt['datewrite'] = $this->datewrite;
  1147.         }
  1149.         // text fictif
  1150.         if (isset($this->textfictif)) {
  1151.             $txt['textfictif'] = $this->textfictif;
  1152.         }
  1154.         if (isset($this->isbn)) {
  1155.             $txt['isbn'] = $this->isbn;
  1156.         }
  1157.         if (isset($this->ean)) {
  1158.             $txt['ean'] = $this->ean;
  1159.         }
  1161.         if (isset($this->nbpages)) {
  1162.             $txt['nbpages'] = $this->nbpages;
  1163.         }
  1164.         if (isset($this->publication_year)) {
  1165.             $txt['publication_year'] = $this->publication_year;
  1166.             $publication_month_caractere[] = $publication_date[] = $txt['publication_year'];
  1167.         }
  1168.         if (isset($this->publication_month)) {
  1169.             if (strlen($this->publication_month) == 1) {
  1170.                 $txt['publication_month'] = '0' . $this->publication_month;
  1171.             } else {
  1172.                 $txt['publication_month'] = $this->publication_month;
  1173.             }
  1174.             $publication_date[] = $txt['publication_month'];
  1175.             $txt['publication_month_caractere'] = $month[$this->publication_month];
  1176.         }
  1178.         // les auteurs du texte
  1179.         if ($allauthors) {
  1180.             $txt['allauthors'] = $this->noPunct($this->getAuthors($idtext));
  1181.             $this->collectif($txt['allauthors'], 0, 3);
  1182.         }
  1184.         // si traduction, aussi le traducteur
  1185.         if (isset($this->type) && $this->type == 1) {
  1186.             $txt['alltranslators'] = $this->noPunct($this->getTranslators($idtext));
  1187.         }
  1189.         // date de publication complète
  1190.         if (!empty($publication_date)) {
  1191.             $txt['publication_date'] = join('-', $publication_date);
  1192.         }
  1194.         // date d'ajout
  1195.         if (isset($this->dateinsert)) {
  1196.             $txt['dateinsert'] = $this->dateinsert;
  1197.             $txt['dateinsert_lng'] = $this->getFormeDate($this->dateinsert, $GLOBALS['format_date'][$GLOBALS['lng']]);
  1198.             $txt['dateinsert_hour_lng'] = $this->getFormeDate($this->dateinsert, 'H:i');
  1199.         }
  1201.         // l'editeur
  1202.         if (isset($this->url_clean_publisher) && $this->url_clean_publisher != '') {
  1203.             if (!empty($params['api'])) {
  1204.                 $txt['publisher'][$this->idcontact] = array(
  1205.                     'organisation' => $this->organisation,
  1206.                     'url_clean' => $this->url_clean_publisher,
  1207.                 );
  1208.             } elseif ($tabpublisher) {
  1209.                 $txt['publisher']['organisation'] = $this->organisation;
  1210.                 $txt['publisher']['url_clean'] = $this->url_clean_publisher;
  1211.             } else {
  1212.                 $txt['publisher'] = $this->organisation;
  1213.                 $txt['url_clean_publisher'] = $this->url_clean_publisher;
  1214.             }
  1215.         }
  1217.         // vignette de base
  1218.         if ($vignette) {
  1219.             if (is_array($vignette)) {
  1220.                 $format = $vignette;
  1221.             } else {
  1222.                 $format = array();
  1223.             }
  1224.             $txt['vignette'] = $this->getVignetteText($idtext, $format);
  1226.             $format['blur'] = true;
  1227.             $txt['vignette_flou'] = $this->getVignetteText($idtext, $format);
  1228.         }
  1230.         // pour une traduction, il faut aussi le texte orginal
  1231.         if (isset($this->type) && $this->type == 1) {
  1232.             $txt['original_texts'] = $this->getOriginalsTexts($idtext);
  1233.         }
  1235.         // genre de texte (theatre si pas précisé)
  1236.         if ($genre) {
  1237.             if (isset($this->idgenretext)) {
  1238.                 $txt['idgenretext'] = $this->idgenretext;
  1239.             } else {
  1240.                 $txt['idgenretext'] = 1;
  1241.             }
  1242.             // traduction du genre de text
  1243.             if (isset($this->genretext)) {
  1244.                 $txt['genretext'] = $GLOBALS['tr']->trans($this->genretext);
  1245.             }
  1246.         }
  1248.         // si c'est une traduction, id du texte original
  1249.         if (isset($this->idtextoriginal)) {
  1250.             $txt['idtextoriginal'] = $this->idtextoriginal;
  1251.         }
  1253.         // langue
  1254.         if (isset($this->language)) {
  1255.             $txt['language'] = $this->getNameLanguage($this->language);
  1256.         }
  1258.         // pays
  1259.         if (isset($this->country)) {
  1260.             $txt['country'] = $this->getNameCountry($this->country);
  1261.         }
  1263.         // statut et validation
  1264.         if (isset($this->valid)) {
  1265.             $txt['valid'] = $this->valid;
  1266.         }
  1267.         if (isset($this->publish)) {
  1268.             $txt['publish'] = $this->publish;
  1269.         }
  1270.         if (isset($this->statut)) {
  1271.             $txt['statut'] = $this->statut;
  1272.         }
  1274.         if (!empty($params['stylemore'])) {
  1275.             $txt['stylemore'] = $params['stylemore'];
  1276.         } else {
  1277.             $txt['stylemore'] = array('imagep' => 'width:85px;', 'desctxt' => 'width:170px;');
  1278.         }
  1280.         return $txt;
  1282.     }
  1284.     // }}}
  1286.     //  {{{ getRelationsArray()
  1288.     /** Tableau des relations
  1289.      *
  1290.      * @access  public
  1291.      * @param string|int $type le type de champ
  1292.      */
  1293.     public function getRelationsArray($type = null)
  1294.     {
  1295.         // tout ça est dans la table "contacts"
  1296.         $types_idcontact = array(
  1297.             'publisher',
  1298.             'idcontact_publisher',
  1299.             'idcontact_translation',
  1300.             'idcontact_performing',
  1301.             'source',
  1302.         );
  1304.         if (!empty($type) && in_array($type, $types_idcontact)) {
  1305.             $precise_type = $type;
  1306.             $type = 'idcontact';
  1307.         } else {
  1308.             $precise_type = null;
  1309.         }
  1311.         // author est avec la relation text_author
  1312.         if (!empty($type) && $type == 'author') {
  1313.             $type = 'text_author';
  1314.         }
  1316.         $array_types = array(
  1317.             'text_trailer' => array(// documents multimedia associés
  1318.                 'type_join' => 'method',
  1319.                 'method' => 'getMultimediaList',
  1320.             ),
  1321.             // contacts idcontact
  1322.             'idcontact' => array(// contacts associés ?
  1323.                 'type_join' => 'simple',
  1324.                 'dest_table' => 'contacts',
  1325.                 'fields' => array('idcontact', 'organisation', 'lastname', 'firstname', 'type', 'url_clean', 'valid'),
  1326.                 'join_field_src' => $precise_type,
  1327.             ),
  1328.             'text_classification' => array(// classifications associées
  1329.                 'field_input' => 'idclassification',
  1330.                 'type_join' => 'multiple',
  1331.                 'dest_table' => 'classifications',
  1332.                 'join_table' => 'text_classification',
  1333.                 'fields' => array('idclassification', 'classification', 'type'),
  1334.             ),
  1335.             'text_translator' => array(// traducteurs
  1336.                 'type_join' => 'multiple',
  1337.                 'dest_table' => 'persons',
  1338.                 'join_field_src' => 'idtext',
  1339.                 'join_field_dest' => 'idperson',
  1340.                 'join_table' => 'text_translator',
  1341.                 'fields' => array('idperson', 'lastname', 'firstname', 'url_clean', 'valid'),
  1342.                 'sql_more' => ' ORDER BY j2.classement ASC',
  1343.             ),
  1344.             'text_author' => array(// auteurs
  1345.                 'type_join' => 'multiple',
  1346.                 'dest_table' => 'persons',
  1347.                 'join_field_src' => 'idtext',
  1348.                 'join_field_dest' => 'idperson',
  1349.                 'join_table' => 'text_author',
  1350.                 'fields' => array('idperson', 'lastname', 'firstname', 'url_clean', 'valid'),
  1351.                 'sql_more' => ' ORDER BY j2.classement ASC',
  1352.             ),
  1353.             'text_traduction' => array(// texts originaux liés à la traduction
  1354.                 'type_join' => 'multiple',
  1355.                 'dest_table' => 'texts',
  1356.                 'join_field_src' => 'idtexttraduction',
  1357.                 'join_field_dest' => 'idtext',
  1358.                 'join_table' => 'text_traduction',
  1359.                 'fields' => array('idtext', 'title', 'type', 'url_clean', 'valid'),
  1360.                 'title_params' => array('noauthor' => true), // sans l'auteur
  1361.             ),
  1362.             'text_adaptation' => array(// text originaux liés à l'adaptation
  1363.                 'type_join' => 'multiple',
  1364.                 'dest_table' => 'texts',
  1365.                 'join_field_src' => 'idtextadaptation',
  1366.                 'join_field_dest' => 'idtext',
  1367.                 'join_table' => 'text_adaptation',
  1368.                 'fields' => array('idtext', 'title', 'type', 'url_clean', 'valid'),
  1369.                 'title_params' => array('noauthor' => true), // sans l'auteur
  1370.             ),
  1371.             'text_person' => array(// persons liées à un texte
  1372.                 'type_join' => 'multiple',
  1373.                 'dest_table' => 'persons',
  1374.                 'join_table' => 'text_person',
  1375.                 'join_field_dest' => 'idperson',
  1376.                 'field_link' => 'idrole', //TODO
  1377.                 'fields' => array('idperson', 'lastname', 'firstname', 'url_clean', 'valid'),
  1378.             ),
  1379.             'text_multimedia' => array(// classifications associées
  1380.                 'type_join' => 'multiple',
  1381.                 'dest_table' => 'multimedias',
  1382.                 'join_table' => 'object_multimedia',
  1383.                 'join_table_object' => 'texts',
  1384.                 //'join_table_constraint' => 'object_multimedia.object=\'texts\' AND object_multimedia.idobject=?',
  1385.                 'fields' => array('idmultimedia', 'sujet_titre', 'url_clean'),
  1386.             ),
  1387.             // idextranetuser idtext
  1388.             'idextranetuser' => array(// utilisateur associé
  1389.                 'type_join' => 'simple',
  1390.                 'dest_table' => 'extranetusers',
  1391.                 'join_field_src' => 'idextranetuser', // jointure
  1392.                 'fields' => array('idextranetuser', 'login', 'email'),
  1393.                 'description' => 'Utilisateur associé au texte',
  1394.                 'silent_delete_relation' => true,
  1395.             ),
  1396.         );
  1398.         if (!empty($array_types[$type])) {
  1399.             $array_types[$type]['type'] = $type;
  1400.             return $array_types[$type];
  1401.         } else {
  1402.             return $array_types;
  1404.         }
  1406.     }
  1408.     // }}}
  1410.     //  {{{ getLinkedObject()
  1412.     /** Particularité pour Texts
  1413.      *
  1414.      * @access  public
  1415.      * @see     Theatre::getLinkedObject()
  1416.      */
  1417.     public function getLinkedObject($infos_link, $idobject, $type, $src)
  1418.     {
  1420.         $itemslist = $this->getLinkedObjectTrait($infos_link, $idobject, $type, $src);
  1422.         foreach ($itemslist as $k => $v) {
  1423.             if (!empty($v['lastname']) && $v['lastname'] == 'Collectif') {
  1424.                 $itemslist[$k]['collectif'] = true;
  1425.             }
  1426.         }
  1428.         return $itemslist;
  1430.     }
  1432.     // }}}
  1434.     // {{{ collectif()
  1436.     /** Modifie le tableau pour les collectifs
  1437.      *
  1438.      *
  1439.      * @param array  le tableau des auteurs (ou traducteurs)
  1440.      * @param int $nb nombre d'auteurs ou de traducteurs
  1441.      * @param int $type 0=auteurs 1=traducteurs
  1442.      * @access protected
  1443.      * @return array
  1444.      */
  1445.     protected function collectif(&$arr, $type = 0, $nb_supp = 1)
  1446.     {
  1448.         static $types = array(
  1449.             0 => 'auteurs',
  1450.             1 => 'traducteurs'
  1451.         );
  1453.         $nb = count($arr);
  1455.         if ($nb <= $nb_supp || !isset($types[$type])) return;
  1457.         $arr = array(1 => array(
  1458.             'lastname' => '(' . $nb . ' ' . $types[$type] . ')',
  1459.             'firstname' => 'Collectif',
  1460.             'collectif' => true)
  1461.         );
  1462.     }
  1464.     // }}}
  1466.     // {{{ countAssociateTexts()
  1468.     /** Compter le nb de textes associés à un objet
  1469.      *
  1470.      *
  1471.      * @param string $object Type d'objet
  1472.      * @param int $idobject Identifiant
  1473.      * @param int $idclassification Classification
  1474.      * @access public
  1475.      * @return array
  1476.      */
  1477.     public function countAssociateTexts($object, $idobject, $idclassification)
  1478.     {
  1480.         $infos_link = $this->getRelationsArray('text_person');
  1482.         if (!empty($infos_link)) {
  1483.             return $this->getLinkedObject($infos_link, $idobject, $infos_link['type'], 'texts');
  1484.         }
  1486.     }
  1488.     // }}}
  1490.     //  {{{ getSQLTexts()
  1492.     /** Générer la requete standard pour un text
  1493.      *
  1494.      * $params = array(
  1495.      *  'select' => champs en plus pour le select,
  1496.      *  'from' => champs en plus pour le from,
  1497.      *  'where' => paramètres en plus le where,
  1498.      *  'order' => classement des résultats,
  1499.      *  'limit' => limiter le nb de résultats array(debut,fin), (all pour pas de limit)
  1500.      * )
  1501.      * $special = array(
  1502.      *  'select_by_text_or_adaptation' => text et adaptation,
  1503.      *  'prochains' => true = date dans le future, un entier = fait un between
  1504.      *  'anciens' =>
  1505.      *  'join' => jointure gauche sur contacts et schedules
  1506.      * )
  1507.      *
  1508.      *
  1509.      * @access   public
  1510.      * @param array $params Les paramètres pour la requete
  1511.      * @param array $special Les paramètres supplémentaires
  1512.      * @param bool $debug afficher la requête TODO
  1513.      * @return   string
  1514.      */
  1515.     public function getSQLTexts($params = array(), $special = array(), $debug = false)
  1516.     {
  1518.         // tables et champs
  1519.         $tables_list = array(
  1520.             'texts' => array(
  1521.                 /* @TODO Suppression de 'date' ticket #171 est-ce que d'autres pages vont bug suite à ça ? */
  1522.                 'fields' => array('title', 'url_clean', 'publication_year', 'publication_month', 'isbn', 'textfictif', 'dateinsert', 'textorder', 'type', 'publish', 'statut', 'valid'),
  1523.             ),
  1524.             'contacts' => array(
  1525.                 'fields' => array('idcontact', 'url_clean as url_clean_publisher', 'organisation'),
  1526.             ),
  1527.         );
  1529.         // définition de l'alias
  1530.         $al = 1;
  1532.         foreach ($tables_list as $k => $v) {
  1533.             $tables_list[$k]['table_alias'] = $k . ' T' . $al;
  1534.             foreach ($v['fields'] as $f) {
  1535.                 // si le champ contient ' as '
  1536.                 if (strpos($f, ' as ') !== false) {
  1537.                     $ff = explode(' as ', $f);
  1538.                     $select_fields_array[] = 'T' . $al . '.`' . $ff[0] . '` as `' . $ff[1] . '`';
  1539.                 } else {
  1540.                     $select_fields_array[] = 'T' . $al . '.`' . $f . '`';
  1541.                 }
  1542.             }
  1543.             $al++;
  1544.         }
  1546.         // select de base
  1547.         $sql_select = 'SELECT DISTINCT(T1.`idtext`), ' . join(',', $select_fields_array) . ',
  1548.                         CONCAT(T1.`publication_year`, T1.`publication_month`) AS publication_date,
  1549.                         CAST(CONCAT(T1.`publication_year`, T1.`publication_month`) AS DATE) AS publication_date_full ';
  1551.         // select en plus
  1552.         if (array_key_exists('select', $params)) {
  1553.             $sql_select .= ',' . $params['select'];
  1554.         }
  1556.         // compte seulement
  1557.         if (array_key_exists('count_only', $special)) {
  1558.             $sql_select = 'SELECT COUNT(DISTINCT(T1.`idtext`)) as total ';
  1559.         }
  1561.         // from avec jointure entre texts/contacts
  1562.         if (array_key_exists('join', $special)) {
  1563.             $sql_from = ' FROM texts T1
  1564.                                 LEFT JOIN contacts T2 ON T2.`idcontact`=T1.`idcontact_publisher` ';
  1565.         } else {
  1566.             foreach ($tables_list as $k => $v) {
  1567.                 $sql_from_tables[] = $v['table_alias'];
  1568.             }
  1569.             $sql_from = ' FROM ' . join(',', $sql_from_tables);
  1570.         }
  1572.         // selectionde table en plus
  1573.         if (array_key_exists('from', $params)) {
  1574.             if (is_array($params['from'])) {
  1575.                 foreach ($params['from'] as $k => $v) {
  1576.                     $sql_from .= ',' . $v . ' T' . $al;
  1577.                     // join avec la table principale ?
  1578.                     if (!empty($k) && $k == 'join') {
  1579.                         $params['where'] = ' T1.idtext=T' . $al . '.idtext';
  1580.                     }
  1581.                 }
  1582.                 $al++;
  1583.             } else {
  1584.                 $sql_from .= ',' . $params['from'];
  1585.             }
  1586.         }
  1588.         // where standard
  1589.         $sql_where = ' WHERE 1 ';
  1591.         // avec couv uniquement
  1592.         if (array_key_exists('avec_couverture', $special)) {
  1593.             $sql_from .= ' ,object_file of, files f, file_classification fc ';
  1594.             $sql_where .= ' AND of.idfile=f.idfile
  1595.                             AND of.idobject=T1.idtext
  1596.                             AND fc.idfile=f.idfile
  1597.                             AND fc.idclassification=20
  1598.                             AND of.object=\'texts\' ';
  1600.         }
  1602.         // avec un contenu associé en particulier
  1603.         if (!empty($special['idclassification'])) {
  1604.             $sql_from .= ' ,object_content oc2, contents c2, content_classification cc2 ';
  1605.             $sql_where .= ' AND oc2.idcontent=c2.idcontent
  1606.                             AND cc2.idcontent=c2.idcontent
  1607.                             AND oc2.idobject=T1.idtext
  1608.                             AND cc2.idclassification IN (' . join(',', $special['idclassification']) . ')
  1609.                             AND oc2.object=\'texts\' ';
  1611.         }
  1614.         // par classification
  1615.         if (array_key_exists('by_classification', $special)) {
  1616.             if (!is_array($special['by_classification'])) {
  1617.                 $sql_from .= ' ,text_classification tcl,classifications cl2';
  1618.                 $sql_where .= ' AND tcl.idtext=s.idtext
  1619.                                 AND tcl.idclassification=cl2.idclassification';
  1620.                 if ($this->my_is_int($special['by_classification'])) {
  1621.                     $sql_where .= ' AND cl2.idclassification=' . ((int)$special['by_classification']) . ' ';
  1622.                 } else {
  1623.                     $sql_where .= ' AND cl2.classification=\'' . $this->escape($special['by_classification']) . '\' ';
  1624.                 }
  1625.             } else {
  1626.                 $sql_from .= ' ,text_classification tcl,classifications cl2';
  1627.                 $sql_where .= ' AND tcl.`idtext`=T1.`idtext`
  1628.                                 AND tcl.`idclassification`=cl2.`idclassification`';
  1629.                 $sql_where .= ' AND cl2.`idclassification` IN (' . $this->arrayToIn($special['by_classification']) . ') ';
  1630.             }
  1631.         }
  1633.         $having_more = '';
  1636.         // pour les playlists
  1637.         if (!empty($special['playlists'])) {
  1638.             if (!empty($special['playlists']['text'])) {
  1639.                 $sql_from .= ' ,`playlists` ';
  1640.                 $sql_where .= ' AND `playlists`.`idtext`=T1.`idtext` ';
  1641.             }
  1642.             if (!empty($special['playlists']['idclassifications'])) {
  1643.                 $sql_from .= ' ,`playlist_classification` ';
  1644.                 $sql_where .= ' AND `playlist_classification`.`idplaylist`=`playlists`.`idplaylist` ';
  1645.                 $sql_where .= ' AND `playlist_classification`.idclassification IN (' . $this->arrayToIn($special['playlists']['idclassifications']) . ') ';
  1646.             }
  1647.             if (!isset($special['playlists']['publish'])) {
  1648.                 $sql_where .= ' AND `playlists`.`publish`=1 ';
  1649.             }
  1650.         }
  1652.         // pour les podcasts
  1653.         if (!empty($special['podcasts'])) {
  1654.             $sql_from .= ' ,`podcasts`,`podcast_text` ';
  1656.             $sql_select .= ' , podcasts.idpodcast ';
  1658.             if (!empty($special['podcasts']['type_podcast'])) {
  1659.                 //franceculture
  1660.                 if ($special['podcasts']['type_podcast'] == 'franceculture') {
  1661.                     $sql_where .= ' AND `podcasts`.`code_franceinter` IS NOT NULL ';
  1662.                 } //culturebox
  1663.                 else {
  1664.                     $sql_where .= ' AND `podcasts`.`code_ft` IS NOT NULL ';
  1665.                 }
  1666.             }
  1668.             $sql_where .= ' AND `podcast_text`.`idtext`= T1.`idtext` ';
  1669.             $sql_where .= ' AND `podcasts`.`idpodcast`=`podcast_text`.`idpodcast` ';
  1671.             if (!isset($special['podcasts']['publish'])) {
  1672.                 $sql_where .= ' AND `podcasts`.`publish`=1 ';
  1673.             }
  1674.         }
  1676.         // par aide => le type d'aide = idaide
  1677.         if (array_key_exists('aides', $special)) {
  1678.             // jionture avec text_aide et aides
  1679.             $sql_from .= ' ,text_aide tai, aides ai, aidecontacts aic';
  1680.             $sql_where .= ' AND tai.`idtext`=T1.`idtext`
  1681.                             AND tai.`idaide`=ai.`idaide`
  1682.                             AND ai.`idaidecontact`=aic.`idaidecontact` ';
  1683.             // recherche par l'aide'
  1684.             if (!empty($special['aides']['idaide'])) {
  1685.                 $sql_where .= ' AND tai.`idaide`=' . ((int)$special['aides']['idaide']) . ' ';
  1686.             }
  1687.             // recherche par la catégorie d'aide
  1688.             if (!empty($special['aides']['idaidecontact_or_type_aide']) && !empty($special['aides']['idaidecontact']) && !empty($special['aides']['type_aide'])) {
  1691.                 $sql_where .= ' AND ( aic.`idaidecontact`=' . ((int)$special['aides']['idaidecontact']) . ' OR ';
  1693.                 if (is_array($special['aides']['type_aide'])) {
  1694.                     $sql_where .= ' ai.`type_aide`IN (' . implode(',', $special['aides']['type_aide']) . ' ))';
  1695.                 } else {
  1696.                     $sql_where .= ' ai.`type_aide`=' . ((int)$special['aides']['type_aide']) . ' )';
  1697.                 }
  1699.             } else {
  1700.                 if (!empty($special['aides']['idaidecontact'])) {
  1701.                     $sql_where .= ' AND aic.`idaidecontact`=' . ((int)$special['aides']['idaidecontact']) . ' ';
  1702.                 }
  1703.                 // recherche par la catégorie d'aide
  1704.                 if (!empty($special['aides']['type_aide'])) {
  1705.                     if (is_array($special['aides']['type_aide'])) {
  1706.                         $sql_where .= ' AND ai.`type_aide`IN (' . implode(',', $special['aides']['type_aide']) . ' ) ';
  1707.                     } else {
  1708.                         $sql_where .= ' AND ai.`type_aide`=' . ((int)$special['aides']['type_aide']) . ' ';
  1709.                     }
  1710.                 }
  1711.             }
  1713.             // recherche par le contact
  1714.             if (!empty($special['aides']['idcontact'])) {
  1715.                 $sql_where .= ' AND tai.`idcontact`=' . ((int)$special['aides']['idcontact']) . ' ';
  1716.             }
  1717.             // rechercher l'année de l'aide
  1718.             if (!empty($special['aides']['year'])) {
  1719.                 $sql_where .= ' AND YEAR(tai.`date_start`)=\'' . ((int)$special['aides']['year']) . '\' ';
  1720.             }
  1721.             // par période d'aide
  1722.             if (!empty($special['aides']['period'])) {
  1723.                 if (!empty($special['aides']['period']['start'])) {
  1724.                     $sql_where .= ' AND (tai.`date_start` BETWEEN \'' . $special['aides']['period']['start'] . '\' AND \'' . $special['aides']['period']['end'] . '\') ';
  1725.                 }
  1726.             }
  1728.             if (!empty($special['aides']['get_by_nombres_aides'])) {
  1729.                 if (!empty($special['aides']['get_by_nombres_aides_val'])) {
  1730.                     $having_more .= ' HAVING COUNT(DISTINCT tai.idaide) = ' . (int)$special['aides']['get_by_nombres_aides_val'] . '';
  1731.                 } else {
  1732.                     $having_more .= ' HAVING COUNT(DISTINCT tai.idaide) > 1';
  1733.                 }
  1734.             }
  1736.         }
  1738.         // recherche par traducteur
  1739.         if (array_key_exists('type', $special) && $special['type'] == 'translation') {
  1740.             $sql_from .= ' text_translator tt, persons p';
  1741.             $sql_where .= ' AND tt.idtext=t.idtext AND p.idperson=tt.idperson AND T1.type=1';
  1742.         }
  1744.         // recherche par auteur
  1745.         if (array_key_exists('authors', $special)) {
  1746.             $sql_from .= ' ,text_author ta, persons p';
  1747.             $sql_where .= ' AND ta.`idtext`=T1.`idtext`
  1748.                             AND p.`idperson`=ta.`idperson` ';
  1749.             if ((isset($special['authors'][0]) && isset($special['authors'][1]))
  1750.                 && !is_array($special['authors'][0]) && is_array($special['authors'][1])) {
  1751.                 $sql_where .= ' AND ta.`idperson` ' . $special['authors'][0] . ' (' . join(',', $special['authors'][1]) . ') ';
  1752.             } else {
  1753.                 if (!empty($special['authors']['letter'])) {
  1754.                     $sql_where .= ' AND LOWER(LEFT(LTRIM(p.`lastname`),1))=\'' . $this->escape($special['authors']['letter']) . '\' ';
  1755.                 } else {
  1756.                     $sql_where .= ' AND ta.`idperson` IN (' . join(',', $special['authors']) . ') ';
  1757.                 }
  1758.             }
  1759.         }
  1761.         // uniquement si pas de jointure
  1762.         if (!array_key_exists('join', $special)) {
  1763.             $sql_where .= ' AND T2.idcontact=T1.idcontact_publisher';
  1764.         }
  1766.         // genre de texte
  1767.         if (!empty($special['genretext'])) {
  1768.             $sql_where .= ' AND T1.idgenretext IN (' . $this->arrayToIn($special['genretext']) . ') ';
  1769.         }
  1771.         // paramètres en plus
  1772.         if (array_key_exists('where', $params)) {
  1773.             $sql_where .= $params['where'];
  1774.         }
  1776.         // publie
  1777.         /*if(!array_key_exists('publish', $params)) {
  1778.             $sql_where .= ' AND publish=1';
  1779.         }*/
  1781.         // par utilisateur
  1782.         if (!empty($special['idextranetuser'])) {
  1783.             $sql_where .= ' AND T1.idextranetuser=' . (int)$special['idextranetuser'] . ' ';
  1784.         }
  1786.         // type de texte
  1788.         // recherche alpha
  1789.         if (array_key_exists('alpha', $special)) {
  1790.             if (is_array($special['alpha'])) {
  1791.                 foreach ($special['alpha'] as $k => $v) {
  1792.                     $sql_where .= ' AND ' . $k . ' REGEXP \'^' . $v . '\' ';
  1793.                 }
  1794.             } else {
  1795.                 $sql_where .= ' AND T1.lastname REGEXP \'^' . $special['alpha'] . '\' ';
  1796.             }
  1797.         }
  1799.         // recherche des textes
  1800.         if (!empty($special['idtext'])) {
  1801.             if (is_array($special['idtext'])) {
  1802.                 if (isset($special['idtext'][0]) && isset($special['idtext'][1]) && (!is_array($special['idtext'][0]) && is_array($special['idtext'][1]))) {
  1803.                     $sql_where .= ' AND T1.`idtext` ' . $special['idtext'][0] . ' (' . join(',', $special['idtext'][1]) . ') ';
  1804.                 } else {
  1805.                     $sql_where .= ' AND T1.`idtext` IN (' . join(',', $special['idtext']) . ') ';
  1806.                 }
  1807.             } else {
  1808.                 $sql_where .= ' AND T1.`idtext` IN (' . $special['idtext'] . ') ';
  1809.             }
  1810.         }
  1812.         // par période de publication
  1813.         if (!empty($special['periode'])) {
  1814.             if (!empty($special['periode']['from'])) {
  1815.                 $now = new DateTime(date('Y-m-d'));
  1816.                 $now->modify($special['periode']['from']);
  1817.                 $sql_where .= ' AND CAST(CONCAT(T1.`publication_year`,\'-\',T1.`publication_month`,\'-00\') AS DATE) BETWEEN \'' . $now->format('Y-m') . '-00\' AND \'' . date('Y-m') . '-00\' ';
  1818.             } elseif (is_array($special['periode'])) {
  1819.                 $sql_where .= ' AND CAST(CONCAT(T1.`publication_year`,\'-\',T1.`publication_month`,\'-00\') AS DATE) BETWEEN \'' . $special['periode']['datestart'] . '\' AND \'' . $special['periode']['dateend'] . '\' ';
  1820.             }
  1821.         }
  1823.         if (!empty($special['deja_paru'])) {
  1824.             $sql_where .= ' AND CAST(CONCAT(T1.`publication_year`,\'-\',T1.`publication_month`,\'-00\') AS DATE)<=\'' . date('Y-m') . '-00\' ';
  1825.         }
  1827.         // par année de publication
  1828.         if (!empty($special['year'])) {
  1829.             $sql_where .= ' AND T1.`publication_year`=' . (int)$special['year'] . ' ';
  1830.         }
  1832.         // groupement par défaut
  1833.         if (!isset($special['no_group'])) {
  1834.             if (!array_key_exists('groupby', $params)) {
  1835.                 $groupby = ' GROUP BY T1.idtext ';
  1836.             } else {
  1837.                 $groupby = ' GROUP BY ' . $params['groupby'];
  1838.             }
  1839.         } else {
  1840.             $groupby = '';
  1841.         }
  1843.         // classement par défaut
  1844.         if (!array_key_exists('order', $params)) {
  1845.             // si ancien, classement DESC
  1846.             if (array_key_exists('anciens', $special)) {
  1847.                 $classement = 'DESC';
  1848.             } else {
  1849.                 $classement = 'ASC';
  1850.             }
  1851.             if (array_key_exists('classement', $params)) {
  1852.                 $classement = $params['classement'];
  1853.             }
  1854.             //$order = ' ORDER BY T1.publication_year '.$classement;
  1855.             $order = ' ORDER BY CAST(CONCAT(T1.`publication_year`,\'-\',T1.`publication_month`,\'-00\') AS DATE) ' . $classement;
  1856.         } else {
  1857.             $order = ' ORDER BY ' . $params['order'];
  1858.         }
  1860.         // classement aléatoire
  1861.         if (array_key_exists('random', $special)) {
  1862.             $order = ' ORDER BY RAND() ' . $special['random'];
  1863.         }
  1864.         if (array_key_exists('no_order', $special)) {
  1865.             $order = ' ';
  1866.         }
  1868.         // limite par défaut
  1869.         if (!array_key_exists('limit', $params)) {
  1870.             $limit = ' LIMIT 0,10';
  1871.         } else {
  1872.             if ($params['limit'] != 'all') {
  1873.                 $limit = ' LIMIT ' . $params['limit'][0] . ',' . $params['limit'][1];
  1874.             } else {
  1875.                 $limit = ' ';
  1876.             }
  1877.         }
  1879.         $sql_global = $sql_select . $sql_from . $sql_where . $groupby . $having_more . $order . $limit;
  1881.         return $sql_global;
  1883.     }
  1885.     // }}}
  1887.     //  {{{ countListTexts()
  1889.     /** Compter la liste des texts
  1890.      *
  1891.      * @access   public
  1892.      * @param array $params_sql paramètre pour la requete SQL
  1893.      * @param bool $debug mode débugage
  1894.      * @return   int
  1895.      */
  1896.     public function countListTexts($params_sql = null, $debug = false)
  1897.     {
  1899.         // si pas de tableau
  1900.         if (!isset($params_sql['special'])) {
  1901.             $params_sql['special'] = array();
  1902.         }
  1903.         if (!isset($params_sql['params'])) {
  1904.             $params_sql['params'] = array();
  1905.         }
  1907.         // si pas de limite => tout
  1908.         if (empty($params_sql['params']['limit'])) {
  1909.             $params_sql['params']['limit'] = 'all';
  1910.         }
  1912.         $params_sql['special']['count_only'] = true;
  1913.         $params_sql['special']['no_group'] = true;
  1915.         // construction de la requête avec le passage de paramètres
  1916.         return $this->queryOne($this->getSQLTexts($params_sql['params'], $params_sql['special'], $debug));
  1918.     }
  1920.     // }}}
  1922.     //  {{{ getListTexts()
  1924.     /** Récupére la liste des texts
  1925.      *
  1926.      * Récupére les texts de manière standard
  1927.      *
  1928.      * @access   public
  1929.      * @param array $params_sql paramètre pour la requete SQL
  1930.      * @param array $format de la vignette si pas standard
  1931.      * @param bool $debug mode débugage
  1932.      * @return   array
  1933.      */
  1934.     public function getListTexts($params_sql = array(), $params = array(), $debug = false)
  1935.     {
  1937.         // si pas de tableau
  1938.         if (!isset($params_sql['special'])) {
  1939.             $params_sql['special'] = array();
  1940.         }
  1941.         if (!isset($params_sql['params'])) {
  1942.             $params_sql['params'] = array();
  1943.         }
  1946.         // construction de la requête avec le passage de paramètres
  1947.         $sql = $this->getSQLTexts($params_sql['params'], $params_sql['special'], $debug);
  1948.         $params_row = array();
  1950.         // style more ?
  1951.         if (!empty($params['stylemore'])) {
  1952.             $params_row['stylemore'] = $params['stylemore'];
  1953.         } else {
  1954.             $params_row['stylemore'] = array('imagep' => 'width:80px;', 'desctxt' => 'width:200px;');
  1955.         }
  1957.         // format de la vignette
  1958.         if (!empty($params['vignette_format'])) {
  1959.             $vignette_format = $params['vignette_format'];
  1960.         } else {
  1961.             $vignette_format = array('height' => $_ENV['VIGN_TEXT_HEIGHT'], 'width' => $_ENV['VIGN_TEXT_WIDTH'], 'direction' => 'thumb');
  1962.         }
  1964.         // paramètre de debug
  1965.         $dbg = (empty($params_sql['dbg'])) ? array() : $dbg = $params_sql['dbg'];
  1967.         // executer la requete
  1968.         $this->query($sql, $dbg);
  1969.         $txt = array();
  1971.         // debug
  1972.         $start_boucle = microtime(true);
  1974.         if (!isset($params_sql['api'])) {
  1975.             $params_row['api'] = true;
  1976.         }
  1978.         // mettre en forme chaque reponse
  1979.         while ($this->fetch()) {
  1980.             $text = $this->getInfosTextRow($this->idtext, $vignette_format, false, true, $params_row);
  1981.             $text['publisher_first'] = true;
  1982.             if (!empty($params['publisher_first_inverse'])) {
  1983.                 $text['publisher_first_inverse'] = true;
  1984.             }
  1985.             $txt[$this->idtext] = $text;
  1986.             if (!empty($txt['translators'])) {
  1987.                 ;
  1988.                 exit;
  1989.             }
  1990.         }
  1992.         // debug de la boucle
  1993.         if ($this->isTraceMode('list_object')) {
  1994.             $this->setTraceInfos(array(
  1995.                 'execution_time_boucle' => (microtime(true) - $start_boucle),
  1996.                 'dbg' => $dbg,
  1997.             ));
  1998.         }
  2000.         // libère
  2001.         $this->free();
  2003.         return $txt;
  2004.     }
  2006.     // }}}
  2008.     //  {{{ getTextsPersons()
  2010.     /** Trouver tous les texts d'une ou plusieurs personnes
  2011.      *
  2012.      * @access   public
  2013.      * @param string $type_text = type de texte
  2014.      * @return   array
  2015.      */
  2016.     public function getTextsPersons($idperson, $typetext = 'all', $publish = 'all', $join = false)
  2017.     {
  2019.         // publié ou pas ou tus
  2020.         if ($this->my_is_int($publish)) {
  2021.             $sql_publish = ' AND t.`publish`=1 AND t.`valid`=1 ';
  2022.         } else {
  2023.             $sql_publish = ' ';
  2024.         }
  2026.         if (is_array($idperson)) {
  2027.             $idpersons = join(',', $idperson);
  2028.         } else {
  2029.             $idpersons = $idperson;
  2030.         }
  2032.         // trouver les textes orginaux de cette personne
  2033.         if ($typetext == 'all' || $typetext == 'original') {
  2034.             $sql_author = 'SELECT t.`idtext`
  2035.                            FROM text_author ta
  2036.                            JOIN texts t ON ta.`idtext`=t.`idtext`
  2037.                            WHERE ta.`idperson` IN (' . $idpersons . ')' . $sql_publish;
  2038.             $author = $this->queryAll($sql_author);
  2039.         }
  2041.         // trouver les adaptations des textes de cette personne
  2042.         if ($typetext == 'all' || $typetext == 'adaptation') {
  2043.             $sql_adaptation = 'SELECT tad.`idtextadaptation`
  2044.                                FROM text_adaptation tad
  2045.                                JOIN texts t ON t.`idtext`=tad.`idtext`
  2046.                                JOIN text_author ta ON t.`idtext`=ta.`idtext`
  2047.                                WHERE ta.`idperson` IN (' . $idpersons . ')' . $sql_publish;
  2048.             $adaptation = $this->queryAll($sql_adaptation);
  2049.         }
  2051.         // trouver les traductions par cette personne
  2052.         if ($typetext == 'all' || $typetext == 'translator') {
  2053.             $sql_translator = 'SELECT t.`idtext`
  2054.                                FROM text_translator tt
  2055.                                JOIN texts t ON tt.`idtext`=t.`idtext`
  2056.                                WHERE
  2057.                                tt.`idperson` IN (' . $idpersons . ')' . $sql_publish;
  2058.             $translator = $this->queryAll($sql_translator);
  2059.         }
  2061.         // trouver les traductions des textes de cette personne
  2062.         if ($typetext == 'all' || $typetext == 'translation') {
  2063.             $sql_translation = 'SELECT tt.`idtexttraduction`
  2064.                                 FROM text_traduction tt
  2065.                                 JOIN text_author ta ON tt.`idtext`=ta.`idtext`
  2066.                                 JOIN texts t ON tt.`idtext`=t.`idtext`
  2067.                                 WHERE ta.`idperson` IN (' . $idpersons . ')' . $sql_publish;
  2068.             $translation = $this->queryAll($sql_translation);
  2069.         }
  2071.         $idtexts = array();
  2073.         if (!empty($author)) {
  2074.             foreach ($author as $k => $v) {
  2075.                 $idtexts[] = $v['idtext'];
  2076.             }
  2077.         }
  2078.         if (!empty($adaptation)) {
  2079.             foreach ($adaptation as $k => $v) {
  2080.                 $idtexts[] = $v['idtextadaptation'];
  2081.             }
  2082.         }
  2083.         if (!empty($translator)) {
  2084.             foreach ($translator as $k => $v) {
  2085.                 $idtexts[] = $v['idtext'];
  2086.             }
  2087.         }
  2088.         if (!empty($translation)) {
  2089.             foreach ($translation as $k => $v) {
  2090.                 $idtexts[] = $v['idtexttraduction'];
  2091.             }
  2092.         }
  2094.         if ($join) {
  2095.             return join(',', $idtexts);
  2096.         }
  2098.         return $idtexts;
  2100.     }
  2102.     // }}}
  2104.     //  {{{ countTexts()
  2106.     /** Compter le nombre total de textes
  2107.      *
  2108.      * @access public
  2109.      * @params int $type 0 ou 1 original ou traduction
  2110.      * @params int $idcontact_publisher Identifiant d'un éditeur
  2111.      * @return int
  2112.      */
  2113.     public function countTexts($type = 0, $idcontact_publisher = null, $language = null)
  2114.     {
  2116.         $sql = 'SELECT COUNT(DISTINCT(`idtext`))
  2117.                  FROM texts WHERE 1 ';
  2119.         if ($type != 'all') {
  2120.             $sql .= ' AND `type`=' . $type;
  2121.         }
  2123.         if (!empty($idcontact_publisher)) {
  2124.             if ($idcontact_publisher == 'all') {
  2125.                 $sql .= ' AND `idcontact_publisher` IS NOT NULL ';
  2126.             } else {
  2127.                 $sql .= ' AND `idcontact_publisher`=' . (int)$idcontact_publisher;
  2128.             }
  2129.         }
  2131.         if (!empty($language)) {
  2132.             $sql .= ' AND `language`=' . $this->quote($language);
  2133.         }
  2135.         return $this->queryOne($sql);
  2137.     }
  2139.     // }}}
  2141.     //  {{{ getApiFields()
  2143.     /** champs à renvoyer par l'API
  2144.      *
  2145.      * @access  public
  2146.      * @param array tableau de données
  2147.      */
  2148.     protected function getApiFields()
  2149.     {
  2151.         return array(
  2152.             'object' => 'url_clean',
  2153.             'title' => 'title',
  2154.             'url_clean' => 'permanent_url#(.*)#' . $_ENV['URL_THNET'] . '/textes/${1}/', // url complète
  2155.             'type' => 'type',
  2156.             'isbn' => 'isbn',
  2157.             'allauthors->authors' => array(
  2158.                 'lastname' => 'lastname',
  2159.                 'firstname' => 'firstname',
  2160.                 'url_clean' => 'permanent_url#(.*)#' . $_ENV['URL_THNET'] . '/biographies/${1}/',
  2161.             ),
  2162.             'alltranslators->translators' => array(
  2163.                 'object' => 'url_clean',
  2164.                 'lastname' => 'lastname',
  2165.                 'firstname' => 'firstname',
  2166.                 'url_clean' => 'permanent_url#(.*)#' . $_ENV['URL_THNET'] . '/biographies/${1}/',
  2167.             ),
  2168.             'original' => array(
  2169.                 'object' => 'url_clean',
  2170.                 'title' => 'title',
  2171.                 'url_clean' => 'permanent_url#(.*)#' . $_ENV['URL_THNET'] . '/spectacles/${1}/', // url complète
  2172.                 'allauthors->authors' => array(
  2173.                     'lastname' => 'lastname',
  2174.                     'firstname' => 'firstname',
  2175.                     'url_clean' => 'permanent_url#(.*)#' . $_ENV['URL_THNET'] . '/biographies/${1}/',
  2176.                 ),
  2177.             ),
  2178.             'publisher->publishers' => array(
  2179.                 'object' => 'url_clean',
  2180.                 'organisation' => 'name',
  2181.                 'url_clean' => 'permanent_url#(.*)#' . $_ENV['URL_THNET'] . '/contacts/${1}/',
  2182.             ),
  2183.             'vignette' => 'cover',
  2184.             'dateinsert' => 'insert_date',
  2185.         );
  2187.     }
  2189.     // }}}
  2191.     //  {{{ getTextsFromSpectacles()
  2193.     /** récupèrer les textes à partir d'une liste de spectacle
  2194.      *
  2195.      * @access  public
  2196.      * @param array $list_spectacles Liste des spectacles
  2197.      */
  2198.     public function getTextsFromSpectacles($list_spectacles, $params_sql = array(), $params_display = array())
  2199.     {
  2201.         $conn = $this->getEntityManager();
  2203.         // retrouver des textes
  2204.         foreach ($list_spectacles as $k => $v) {
  2205.             if (!empty($v['idtext'])) {
  2206.                 $idtexts[$v['idtext']] = $v['idtext'];
  2207.             }
  2208.         }
  2210.         // rechercher les textes
  2211.         if (!empty($idtexts)) {
  2212.             if (empty($params_display)) {
  2213.                 $params_display = array(
  2214.                     'stylemore' => array('imagep' => 'width:75px;', 'desctxt' => 'width:190px;'),
  2215.                     'vignette_format' => array('width' => 90, 'height' => 65, 'direction' => 'thumb')
  2216.                 );
  2217.             }
  2218.             if (empty($params_sql['params'])) {
  2219.                 $params_sql['params'] = array(
  2220.                     'limit' => 'all',
  2221.                     'order' => ' FIELD(T1.idtext, ' . implode(',', $idtexts) . ')'
  2222.                 );
  2223.             }
  2224.             if (empty($params_sql['special'])) {
  2225.                 $params_sql['special'] = array(
  2226.                     'idtext' => array('IN', $idtexts),
  2227.                     'join' => true,
  2228.                 );
  2229.             }
  2231.             if (!empty($params_sql['limit'])) {
  2232.                 $params_sql['params']['limit'] = $params_sql['limit'];
  2233.                 unset($params_sql['limit']);
  2234.             }
  2236.             $params_sql['dbg'] = array('texts_affiche_' . uniqid(), 'Textes des spectacles à l\'affiche');
  2238.             $list_texts = $this->getListTexts($params_sql, $params_display);
  2240.             if (!empty($list_texts) && !empty($params_display['hide_publishing_date'])) {
  2241.                 foreach ($list_texts as $k => $v) {
  2242.                     $list_texts[$k]['publication_year'] = null;
  2243.                 }
  2244.             }
  2246.             // associer texts et spectacles
  2247.             $i = 0;
  2248.             foreach ($list_spectacles as $k => $v) {
  2249.                 if (empty($v['collage']) && !empty($list_texts[$v['idtext']])) {
  2250.                     if (empty($list_texts_listes[$v['idtext']])) {
  2251.                         $list_texts_listes[$v['idtext']] = $list_texts[$v['idtext']];
  2252.                     }
  2253.                     if (!empty($list_texts_listes[$v['idtext']]) && array_key_exists($v['idtext'], $idtexts)) {
  2254.                         // gros dirty hack pour un texte qui a plusieurs spectacles
  2255.                         if (!empty($list_texts_listes[$v['idtext']]['spectacle'][1])) {
  2256.                             $id = uniqid();
  2257.                             $list_texts_listes[$id] = $list_texts[$v['idtext']];
  2258.                             $list_texts_listes[$id]['spectacle'][1] = $v;
  2259.                             if (!empty($params_sql['get_aides'])) {
  2260.                                 $params_sql['get_aides']['special']['idtexts'] = array($v['idtext']);
  2261.                                 $params_sql['get_aides']['dbg'] = array('aide_text_' . $v['idtext'], 'Aide pour le texte ' . $v['idtext']);
  2262.                                 $list_texts_listes[$id]['aides'] = $conn->getRepository(Aides::class)->getListAides($params_sql['get_aides']);
  2263.                             }
  2264.                         } else {
  2265.                             $list_texts_listes[$v['idtext']]['spectacle'][1] = $v; // limite 1 spectacle
  2266.                             // trouver les aides du texte et éventuellement pour le contact courant
  2267.                             if (!empty($params_sql['get_aides'])) {
  2268.                                 $params_sql['get_aides']['special']['idtexts'] = array($v['idtext']);
  2269.                                 $params_sql['get_aides']['dbg'] = array('aide_text_' . $v['idtext'], 'Aide pour le texte ' . $v['idtext']);
  2270.                                 $list_texts_listes[$v['idtext']]['aides'] = $conn->getRepository(Aides::class)->getListAides($params_sql['get_aides']);
  2271.                             }
  2272.                         }
  2273.                     }
  2274.                 }
  2275.             }
  2276.             return $list_texts_listes;
  2277.         }
  2279.     }
  2281.     // }}}
  2283.     // {{{ makeJsonLD()
  2285.     /** Génére le code en js+ld pour les moteurs de recherche
  2286.      *
  2287.      *
  2288.      * @access public
  2289.      * @return string
  2290.      */
  2291.     public function makeJsonLD($infos)
  2292.     {
  2293.         $tableau = array(
  2294.             "@type" => "Book",
  2295.             'bookFormat' => 'Paperback',
  2296.             'inLanguage' => $infos['language'],
  2297.             'name' => $infos['title'],
  2298. //            'numberOfPages' => $infos['nbpages'],
  2299.             'url' => $_ENV['URL_THNET'] . 'textes/' . $infos['url_clean'],
  2300.             'workExample' => array(
  2301.                 "@type" => "Book",
  2302. //                'datePublished' => $infos['publication_year'].'-'.$infos['publication_month'],
  2303. //                'isbn' => $infos['isbn'],
  2304.             )
  2305.         );
  2306.         //L'illustration du livre
  2307.         if (!empty($infos['illustrations'])) {
  2308.             $tableau['image'] = $infos['illustrations'][0]['url_file_path'];
  2309.         } else if (!empty($infos['vignette_object'])) {
  2310.             $tableau['image'] = $infos['vignette_object'];
  2311.         }
  2312.         //Ajout de l'éditeur
  2313.         if (!empty($infos['publisher']['organisation'])) {
  2314.             $tableau['workExample']['publisher'] = $infos['publisher']['organisation'];
  2315.         }
  2316.         foreach ($infos['authors'] as $idperson => $person) {
  2317.             $tableau['author'][] = array(
  2318.                 "@type" => "Person",
  2319.                 "familyName" => $person['lastname'],
  2320.                 "givenName" => $person['firstname'],
  2321.                 "name" => $person['view_name']
  2322.             );
  2323.         }
  2325.         $jsonld = '
  2326.         <script type="application/ld+json">
  2327.         {
  2328.         "@context": "http://schema.org",
  2329.         "@type": "WebPage",
  2330.         "mainEntity": ' . json_encode($tableau) . '
  2331.         }</script>';
  2334.         return $jsonld;
  2335.     }
  2337.     // }}}
  2338. }