vendor/theatre/core/src/Repository/PersonsRepository.php line 737

Open in your IDE?
  1. <?php
  3. namespace TheatreCore\Repository;
  5. use TheatreCore\Classes\Images\Images;
  6. use TheatreCore\Entity\ContactPerson;
  7. use TheatreCore\Entity\Directories;
  8. use TheatreCore\Entity\Extranetusers;
  9. use TheatreCore\Entity\Persons;
  10. use TheatreCore\Traits\TheatreTrait;
  11. use DateInterval;
  12. use DateTime;
  13. use Doctrine\Bundle\DoctrineBundle\Repository\ServiceEntityRepository;
  14. use Doctrine\Persistence\ManagerRegistry;
  15. use Symfony\Contracts\Translation\TranslatorInterface;
  16. use TheatreCore\Entity\Texts;
  18. /**
  19.  * PersonsRepository
  20.  *
  21.  * This class was generated by the Doctrine ORM. Add your own custom
  22.  * repository methods below.
  23.  */
  24. class PersonsRepository extends ServiceEntityRepository
  25. {
  27.     use TheatreTrait;
  29.     private $em;
  30.     public $__table;
  31.     public $__table_object;
  32.     public $__idtable;
  33.     public $idperson;
  35.     // style de texte
  36.     protected $stylemore_text = array('imagep' => 'width:110px;', 'desctxt' => 'width:170px;');
  38.     // style de vignette
  39.     protected $format_vignette = array('width' => 130, 'height' => 100, 'direction' => 'thumb');
  41.     public function __construct(ManagerRegistry $registry, TranslatorInterface $tr, Images $images)
  42.     {
  43.         parent::__construct($registry, Persons::class);
  44.         $this->__table = $this->getClassMetadata()->getTableName();
  45.         $this->__table_object = $this->getClassMetadata()->name;
  46.         $this->__idtable = $this->getClassMetadata()->getSingleIdentifierFieldName();
  48.         $this->idperson = null;
  50.         $this->translator = $tr;
  51.         $this->images = $images;
  52.     }
  54.     /**
  55.      * Prepare attributes for entity
  56.      * replace foreign keys with entity instances
  57.      *
  58.      * @param array $attributes entity attributes
  59.      * @return array modified attributes values
  60.      */
  61.     public function prepareAttributes(array $attributes)
  62.     {
  63.         foreach ($attributes as $fieldName => &$fieldValue) {
  64.             if (!$this->getClassMetadata()->hasAssociation($fieldName)) {
  65.                 continue;
  66.             }
  68.             $association = $this->getClassMetadata()
  69.                 ->getAssociationMapping($fieldName);
  71.             if (is_null($fieldValue)) {
  72.                 continue;
  73.             }
  75.             $fieldValue = $this->getEntityManager()
  76.                 ->getReference($association['targetEntity'], $fieldValue);
  78.             unset($fieldValue);
  79.         }
  81.         return $attributes;
  82.     }
  84.     //  {{{ findData()
  86.     /** Recherche des personnes
  87.      *
  88.      * Permet de rechercher des personnes en fonction de certains critères :
  89.      * la première lettre, un bout du nom, le type de personne, si il est en ligne ou pas
  90.      *
  91.      * @access  public
  92.      * @see     Theatre::find()
  93.      */
  94.     public function findData($idperson = null, $lettre = null, $keywords = null, $search = null)
  95.     {
  97.         $query = $this->createQueryBuilder('e');
  99.         // parametres
  100.         if (isset($_REQUEST['idperson']) && is_numeric($_REQUEST['idperson'])) {
  101.             $idperson = $_REQUEST['idperson'];
  102.         }
  103.         if (isset($_REQUEST['idcontact_ecole']) && is_numeric($_REQUEST['idcontact_ecole'])) {
  104.             $idcontact_ecole = $_REQUEST['idcontact_ecole'];
  105.             $search = 'idcontact_ecole';
  106.         }
  107.         if (isset($_REQUEST['lettre']) && !empty($_REQUEST['lettre'])) {
  108.             $lettre = $_REQUEST['lettre'];
  109.         }
  110.         if (isset($_REQUEST['keywords']) && $_REQUEST['keywords'] != 'nom' && !empty($_REQUEST['keywords'])) {
  111.             $keywords = $_REQUEST['keywords'];
  112.             // si keywords est un entier => recherche par id
  113.             if ($this->my_is_int($keywords)) {
  114.                 $idperson = (int)$keywords;
  115.                 $keywords = null;
  116.             }
  117.         }
  118.         if (isset($_REQUEST['search']) && !empty($_REQUEST['search'])) {
  119.             $search = $_REQUEST['search'];
  120.         }
  122.         // select ou select as
  123.         if (empty($search) || isset($_REQUEST['typeobj'])) {
  124. //            $this->selectAdd();
  125. //            $this->selectAdd('idperson,lastname,firstname,country,url_clean,language,language2,publish,valid');
  126.         } else {
  127. //            $this->selectAs();
  128. //            $this->selectAs(array('idperson,lastname,firstname,country,url_clean,language,language2,publish,valid'));
  129.         }
  131.         //recherche stricte par id
  132.         if (!empty($idperson)) {
  133. //            $this->whereAdd('persons.idperson='.$idperson);
  134.             $query->andWhere('e.idperson = ' . $idperson);
  135.         }
  136.         // recherche par mot cles
  137.         if (!empty($lettre)) {
  138. //            $this->whereAdd('lastname REGEXP \'^'.$lettre.'\' ');
  139. //            $query->andWhere('e.idperson = '.$idperson);
  140.             $query->andWhere(' ( (e.lastname LIKE \'%' . $this->escape($lettre) . '%\')');
  141.             $query->andWhere(' ( (e.idperson = ' . $idperson);
  142.         }
  143.         if (!empty($keywords)) {
  144.             $list = $this->splitKeywords($keywords);
  145.             if ($list) {
  146.                 // si la liste est > 1 alors 0 = prénom et 1 = nom ou le contraire
  147.                 if (count($list[$this->IDSTR]) == 2) {
  148. //                    $this->whereAdd('(lastname LIKE \'%'.$list[$this->IDSTR][0].'%\'
  149. //                                            AND firstname LIKE \'%'.$list[$this->IDSTR][1].'%\')
  150. //                                    OR (firstname LIKE \'%'.$list[$this->IDSTR][0].'%\'
  151. //                                            AND lastname LIKE \'%'.$list[$this->IDSTR][1].'%\')');
  153.                     $query->andWhere(' (e.lastname LIKE \'%' . $list[$this->IDSTR][0] . '%\'
  154.                                             AND e.firstname LIKE \'%' . $list[$this->IDSTR][1] . '%\')
  155.                                     OR (e.firstname LIKE \'%' . $list[$this->IDSTR][0] . '%\'
  156.                                             AND e.lastname LIKE \'%' . $list[$this->IDSTR][1] . '%\') ');
  157.                 } else {
  158.                     // mots clés
  159.                     foreach ($list[$this->IDSTR] as $s) {
  160.                         $query->orWhere('e.lastname LIKE \'%' . $s . '%\'');
  161.                     }
  162.                 }
  163.                 /*if (!empty($list[$this->IDNUM])) {
  164.                     // recherche par numéro d'id pour les mots clés numériques
  165.                     $sql_where[] = array('idperson IN ('.implode(',', $list[$this->IDNUM]).')', 'OR');
  166.                 }*/
  167.             }
  168.         }
  170.         // selectionne uniquement les auteurs
  171.         if ($search == 'author') {
  172. //            $ta = DB_DataObject::factory('text_author');
  173. //            $this->joinAdd($ta);
  174. //            $this->selectAs();
  175. //            $this->selectAs($ta,'ta_%s');
  176. //            $query->addSelect('ta');
  178.         }
  179. //        // selectionne uniquement les traducteurs
  180.         if ($search == 'translator') {
  181. //            $tt = DB_DataObject::factory('text_translator');
  182. //            $this->joinAdd($tt);
  183. //            $this->selectAs();
  184. //            $this->selectAs($tt,'tt_%s');
  185.             $query->join('e.textTranslatortext', 'ttt');
  186.         }
  187.         // selectionne uniquement les metteurs en scenes
  188.         if ($search == 'director') {
  189. //            $sp = DB_DataObject::factory('spectacle_person');
  190. //            $this->joinAdd($sp);
  191. //            $this->selectAs();
  192. //            $this->selectAs($sp,'tt_%s');
  193.         }
  194. //        // selectionne les élèves d'une école
  195. //        if (!empty($idcontact_ecole)) {
  196. //            $pe = DB_DataObject::factory('person_ecole');
  197. //            $this->joinAdd($pe);
  198. //            $this->selectAs();
  199. //            $this->selectAs($pe,'pe_%s');
  200. //            $this->whereAdd('idcontact='.$idcontact_ecole);
  201. //        }
  202. //
  203. //        // selectionne les fiches hors ligne
  204. //        if (isset($_REQUEST['publish']) && $_REQUEST['publish']=='no') {
  205. //            $this->whereAdd('publish=0');
  206. //        }
  208. //        $this->groupBy('persons.idperson');
  210.         $query->orderBy('e.idperson', 'DESC');
  212.         // on lance la recherche
  213.         return $query->getQuery();
  214.     }
  216.     // }}}
  218.     //  {{{ setToArray()
  220.     /** Liste des personnes dans un tableau associatif
  221.      *
  222.      * Tableau associatif notament utilisé pour lister les informations sur des personnes
  223.      * Utile pour générer les tableaux HTML de listes de personnes
  224.      *
  225.      * @access  public
  226.      * @return  array
  227.      * @see     findData()
  228.      */
  229.     public function setToArray($spec = true)
  230.     {
  232.         // recherche
  233.         if ($spec == true) {
  234.             $this->findData();
  235.         }
  237.         $values = array();
  238.         $color = null;
  240.         $nb = 0;
  242.         while ($this->fetch()) {
  244.             $values[$nb] = $this->getInfosPerson();
  245.             $values[$nb]['id'] = $this->idperson;
  247.             // couleur de ligne alternative
  248.             $color = $this->colorAlternate($color);
  249.             $values[$nb]['colorline'] = $color;
  251.             $nb++;
  253.         }
  255.         return $values;
  256.     }
  258.     // }}}
  260.     //  {{{ getInfosPerson()
  262.     /** Informations sur une personne
  263.      *
  264.      * Permet de récupérer sous forme de tableau associatif
  265.      * les informations complete sur une personne (sauf contenu associe)
  266.      *
  267.      * @access  public
  268.      * @param int $idperson id de la personne pour une recherche hors contexte
  269.      * @return  array
  270.      */
  271.     public function getInfosPerson($idperson = null, $params = array())
  272.     {
  273.         $infos = array();
  275.         // infos de la table
  276.         if (!empty($idperson)) {
  277.             $query = $this->createQueryBuilder('u')
  278.                 ->select('u')
  279.                 ->where('u.' . $this->__idtable . ' =:value')->setParameter('value', $idperson);
  281.             $datas = $query->getQuery()
  282.                 ->getOneOrNullResult();
  284.             $this->idperson = $datas->getIdperson();
  286.         } else {
  287.             $idperson = $this->idperson;
  288.         }
  290.         $lastname = (!empty($this->lastname)) ? $this->lastname : $datas->getLastname();
  291.         $firstname = (!empty($this->firstname)) ? $this->firstname : $datas->getFirstname();
  293.         $infos += array(
  294.             'lastname' => (!empty($this->lastname)) ? $this->lastname : $datas->getLastname(),
  295.             'firstname' => (!empty($this->firstname)) ? $this->firstname : $datas->getFirstname(),
  296.             'sexe' => (!empty($this->sexe)) ? $this->sexe : $datas->getSexe(),
  297.             'idperson' => (!empty($this->idperson)) ? $this->idperson : $datas->getIdperson(),
  298.             'is_author' => $this->isAuthor(),
  299.             'is_translator' => $this->isTranslator(),
  300.             //'is_adaptateur' => $this->isAdaptateur(),
  301.             'is_director' => $this->isDirector(),
  302.             'publish' => (!empty($this->publish)) ? $this->publish : $datas->getPublish(),
  303.             'valid' => (!empty($this->valid)) ? $this->valid : $datas->getValid(),
  304.             'url_clean' => (!empty($this->urlClean)) ? $this->urlClean : $datas->getUrlClean(),
  305.             'datestart' => (!empty($this->datestart)) ? $this->datestart : $datas->getDatestart(),
  306.             'dateend' => (!empty($this->dateend)) ? $this->dateend : $datas->getDateend(),
  307.             'idcorvin' => $datas->getIdCorvin(),
  308.         );
  310.         if (!empty($this->country)) {
  311.             $infos['country'] = $this->getNameCountry($this->country);
  312.             $infos['country_code'] = $this->country;
  313.         } else if ($datas->getCountry()) {
  314.             $infos['country'] = $this->getNameCountry($datas->getCountry()->getId());
  315.             $infos['country_code'] = $datas->getCountry()->getId();
  316.         }
  318.         if (!empty($this->language)) {
  319.             $infos['language'] = $this->getNameLanguage($this->language, $GLOBALS['lng']);
  320.             $infos['language_code'] = $this->language;
  321.         } else if (!empty($datas->getLanguage())) {
  322.             $infos['language'] = $this->getNameLanguage($datas->getLanguage(), $GLOBALS['lng']);
  323.             $infos['language_code'] = $datas->getLanguage();
  324.         }
  326.         // nom complet
  327.         $has_lastname = !empty($lastname);
  328.         $has_firstname = !empty($firstname);
  329.         if ($has_lastname && $has_firstname) {
  330.             $infos['fullname'] = $firstname . ' ' . $lastname;
  331.         } else {
  332.             if ($has_lastname) {
  333.                 $infos['fullname'] = $lastname;
  334.             } else if ($has_firstname) {
  335.                 $infos['fullname'] = $firstname;
  336.             } else {
  337.                 $infos['fullname'] = ''; // ne devrait pas se produire
  338.             }
  339.         }
  341.         // retrouver les comptes mon théâtre associés
  342.         if (array_key_exists('get_extranetusers', $params)) {
  343.             $infos['extranetusers'] = $this->getEntityManager()->getRepository(Extranetusers::class)->getObjectExtranetusers('person', $infos['idperson']);
  344.             $infos['nb_extranetusers'] = count($infos['extranetusers']);
  345.         }
  347.         // retrouver les fiches annuaires associées
  348.         if (array_key_exists('get_directories', $params)) {
  349.             $infos['directories'] = $this->getEntityManager()->getRepository(Directories::class)->getDirectoriesByObject('person', $infos['idperson']);
  350.             $infos['nb_directories'] = count($infos['directories']);
  351.         }
  353.         // retrouver les contacts associés
  354.         if (array_key_exists('get_contact_persons', $params)) {
  355.             $infos['contact_persons'] = $this->getEntityManager()->getRepository(ContactPerson::class)->getContacts($infos['idperson']);
  356.             $infos['nb_contact_persons'] = count($infos['contact_persons']);
  357.         }
  359.         if (!empty($params_display['carrer_couleurs'])) {
  360.             $infos['carrer'] = $this->getObjectsCarrerDetails($infos['idperson'], 'persons');
  361.         }
  363.         return $infos;
  365.     }
  367.     // }}}
  369.     //  {{{ getTextsPerson()
  371.     /** Textes d'une personne
  372.      *
  373.      * Permet de récupérer sous forme de tableau associatif
  374.      * les enregistrements de la table 'texts' liés à l'auteur
  375.      *
  376.      * @access  public
  377.      * @param string $type Type de texte (original, traduction...)
  378.      * @param int $idtextoriginal id du texte original pour la recherche d'un traduction
  379.      * @param int $idperson id de la personne pour une recherche hors contexte
  380.      * @param int $publish textes publie ou pas ?
  381.      * @return  array
  382.      */
  383.     public function getTextsPerson($idperson = null, $type = 'original', $publish = null, $language = null, $idtextoriginal = null, $std_result = false)
  384.     {
  386.         $conn = $this->getEntityManager();
  388.         $texts = array();
  390.         // cast
  391.         $idperson = ((int)$idperson);
  392.         $idtextoriginal = ((int)$idtextoriginal);
  394.         $sql = null;
  396.         $select_fields_tabs = array('idtext', 'title', 'date', 'type', 'language', 'country', 'idcontact_publisher', 'isbn', 'ean', 'publication_year', 'nbpages', 'idgenretext', 'textorder', 'url_clean');
  398.         foreach ($select_fields_tabs as $k => $v) {
  399.             $select_fields_tabs_sql[] = 't.`' . $v . '`';
  400.         }
  402.         $select_fields = join(',', $select_fields_tabs_sql) . ',contacts.`organisation`, contacts.`url_clean` as url_clean_publisher ';
  404.         // les textes originaux
  405.         if ($type == 'original') {
  406.             $sql = 'SELECT ' . $select_fields . '
  407.                         FROM text_author ta, texts t
  408.                             LEFT JOIN contacts ON contacts.idcontact=t.idcontact_publisher
  409.                         WHERE 1
  410.                         AND t.idtext=ta.idtext
  411.                         AND ta.idperson=' . $idperson . '
  412.                         AND t.type=0';
  414.             // filtre sur le genre de texte original
  415.             if (isset($this->byGenreText) && $this->byGenreText == 1) {
  416.                 $sql .= ' AND (t.idgenretext=1 OR t.idgenretext IS NULL)';
  417.             } elseif (isset($this->byGenreText) && $this->byGenreText > 1) {
  418.                 $sql .= ' AND t.idgenretext=' . $this->byGenreText;
  419.             }
  421.         } // toutes les adaptations de texte faites par l'auteur
  422.         elseif ($type == 'adaptation') {
  423.             $sql = 'SELECT ' . $select_fields . ', tad.`idtextadaptation`
  424.                     FROM text_adaptation tad
  425.                         JOIN texts t ON t.idtext=tad.idtextadaptation
  426.                         JOIN text_author ta ON t.idtext=ta.idtext
  427.                         LEFT JOIN contacts contacts ON contacts.idcontact=t.idcontact_publisher
  428.                     WHERE ta.idperson=' . (int)$idperson . '
  429.                     AND t.type=2';
  430.         } // toutes les adaptations d'un texte faites par la langue du spectacle
  431.         elseif ($type == 'adaptation_by_language_spectacle') {
  432.             $sql = 'SELECT ' . $select_fields . '
  433.                         FROM texts t
  434.                         LEFT JOIN contacts ON contacts.idcontact=t.idcontact_publisher
  435.                             WHERE (
  436.                             t.idtext IN(
  437.                                 SELECT t.idtext
  438.                                 FROM texts t
  439.                                     LEFT JOIN text_adaptation ta ON ta.idtext = ' . $idtextoriginal . '
  440.                                     LEFT JOIN text_spectacle ts ON ts.idtext = ta.idtextadaptation
  441.                                     LEFT JOIN spectacles s ON s.idspectacle = ts.idspectacle
  442.                                     LEFT JOIN contacts ON contacts.idcontact=t.idcontact_publisher
  443.                                     WHERE t.idtext = ta.idtextadaptation';
  445.             // on ignore les textes dans une langue
  446.             if (!empty($language)) {
  447.                 $sql .= ' AND s.language != \'' . $language . '\'';
  448.             }
  449.             $sql .= '
  450.                                 )
  451.                             OR t.idtext IN(
  452.                                 SELECT t.idtext
  453.                                 FROM spectacles s, text_spectacle ts, text_traduction tt, texts t
  454.                                             WHERE 1
  455.                                             AND ts.idtext = t.idtext
  456.                                             AND s.idspectacle = ts.idspectacle
  457.                                             AND t.idtext=tt.idtexttraduction
  458.                                             AND tt.idtext=' . $idtextoriginal . '
  459.                             )
  460.                         )';
  461.         } // toutes les traductions d'un texte (page 26 du CDC) TODO = voir a mettre dans la classe texte ?
  462.         elseif ($type == 'translation') {
  463.             $sql = 'SELECT ' . $select_fields . '
  464.                         FROM text_traduction tt, texts t
  465.                             LEFT JOIN contacts ON contacts.idcontact=t.idcontact_publisher
  466.                         WHERE 1
  467.                         AND t.idtext=tt.idtexttraduction
  468.                         AND tt.idtext=' . $idtextoriginal . '
  469.                         AND t.type=1';
  470.             // uniquement les traductions dans une langue
  471.             if (!empty($language)) {
  472.                 $sql .= ' AND t.language=\'' . $language . '\'';
  473.             }
  474.         } // recuperer les six dernieres traductions (page 59 du CDC)
  475.         elseif ($type == 'search_translation') {
  476.             $sql = 'SELECT ' . $select_fields . '
  477.                         FROM text_traduction tt, texts t
  478.                             LEFT JOIN contacts ON contacts.idcontact=t.idcontact_publisher
  479.                         WHERE 1
  480.                         AND t.idtext=tt.idtexttraduction
  481.                         AND t.type=1
  482.                         AND tt.idtext IN (
  483.                             SELECT DISTINCT(t.idtext) FROM texts t,text_author ta
  484.                             WHERE 1';
  485.             if (!empty($publish)) {
  486.                 $sql .= '   AND t.publish=1';
  487.             }
  488.             $sql .= '
  489.                             AND t.idtext=ta.idtext
  490.                             AND ta.idperson=' . $idperson . '
  491.                     )';
  492.             // uniquement les traductions dans une langue
  493.             if (!empty($language)) {
  494.                 $sql .= ' AND t.language=\'' . $language . '\' ';
  495.             }
  496.             //piece recherchee
  497.             if (!empty($idtextoriginal)) {
  498.                 $idtextsearch = $idtextoriginal;
  499.                 $sql .= ' AND tt.idtext=' . $idtextsearch;
  500.             }
  501.         } // recherche les traductions d'une personne
  502.         elseif ($type == 'translator_translation') {
  503.             $sql = 'SELECT ' . $select_fields . '
  504.                          FROM text_traduction tt, text_translator ttr, texts t
  505.                             LEFT JOIN contacts ON contacts.idcontact=t.idcontact_publisher
  506.                          WHERE 1
  507.                          AND t.idtext=tt.idtexttraduction
  508.                          AND t.idtext=ttr.idtext
  509.                          AND ttr.idperson=' . $idperson . '
  510.                          AND t.type=1';
  511.         } elseif ($type == 'translator_translation_count') {
  512.             $sql = 'SELECT COUNT(t.`idtext`) AS total
  513.                          FROM text_traduction tt, text_translator ttr, texts t
  514.                             LEFT JOIN contacts ON contacts.idcontact=t.idcontact_publisher
  515.                          WHERE 1
  516.                          AND t.idtext=tt.idtexttraduction
  517.                          AND t.idtext=ttr.idtext
  518.                          AND ttr.idperson=' . $idperson . '
  519.                          AND t.type=1';
  520.             return $this->queryOne($sql);
  521.         } elseif ($type == 'count_all_texts_translations') {
  522.             $sql = 'SELECT COUNT(DISTINCT(t.idtext))
  523.                         FROM text_traduction tt, texts t
  524.                         LEFT OUTER JOIN contacts ON contacts.idcontact=t.idcontact_publisher
  525.                         WHERE 1
  526.                         AND tt.idtexttraduction=t.idtext
  527.                         AND t.publish=1
  528.                         AND tt.idtext IN (
  529.                             SELECT idtext
  530.                             FROM text_author
  531.                             WHERE idperson=' . $idperson . '
  532.                         )
  533.             ';
  535.             return $this->queryOne($sql);
  536.         }
  538.         // uniquement les textes publies
  539.         if (!empty($publish)) {
  540.             $sql .= ' AND t.publish=1';
  541.         }
  543.         // pas les fictifs
  544.         $sql .= ' AND t.textfictif=0';
  546.         // classement
  547.         $order = ' ORDER BY date DESC';
  549.         // groupement
  550.         $sql .= ' GROUP BY t.idtext';
  552.         // tri
  553.         $sql .= $order;
  555.         //objet texts
  556.         $txt = $conn->getRepository(Texts::class);
  558.         // on lance la recherche
  559.         $txt->query($sql);
  560.         while ($txt->fetch()) {
  562.             $vignette = array('width' => $_ENV['VIGN_TEXT_WIDTH'], 'height' => $_ENV['VIGN_TEXT_HEIGHT'], 'direction' => 'thumb');
  564.             if ($std_result) {
  565.                 $texts[$txt->idtext] = $txt->getInfosTextRow(true, $vignette, true, true);
  566.                 continue;
  567.             }
  568.             $infotxt = array();
  570.             // s'agit-il d'une adaptation
  571.             if ($type == 'adaptation') {
  572.                 $idtext = $txt->idtextoriginal;
  573.             } else {
  574.                 $idtext = $txt->idtext;
  575.             }
  577.             // infos communes
  578.             if ($GLOBALS['module'] == 'theduc') {
  579.                 $pb_publisher = true;
  580.             } else {
  581.                 $pb_publisher = false;
  582.             }
  583.             $infotxt = $txt->getInfosTextRow(false, false, true, $pb_publisher);
  585.             $infotxt['language'] = $txt->getNameLanguage($txt->language);
  586.             $infotxt['country'] = $txt->getNameCountry($txt->country);
  588.             //pour les adapations
  589.             if ($type == 'adaptation') {
  591.                 $infotxt['idtextoriginal'] = $txt->idtextoriginal;
  592.                 $infotxt['idtextadaptation'] = $txt->idtextadaptation;
  594.                 // recuperer les auteurs du text adapte
  595.                 $infotxt['textadaptationauthors'] = $this->getAuthors($txt->idtextoriginal);
  597.                 // recuperer le titre du text adapte et son identifiant (array)
  598.                 $infotxt['textadaptation'] = $this->getInfoText($txt->idtextoriginal);
  600.             }
  602.             // $infotxt = $txt->getInfosTextRow($txt->idtext,$this->format_vignette);
  603.             $infotxt['stylemore'] = array('imagep' => 'width:60px;', 'desctxt' => 'width:400px;');
  604.             $infotxt['publisher_first'] = true;
  606.             $texts[$idtext] = $infotxt;
  608.         }
  609.         // retourner les enregistrements
  610.         return $texts;
  612.     }
  614.     // }}}
  616.     //  {{{ isAuthor()
  618.     /** Voir si c'est un auteur de texte original (type=0)
  619.      *
  620.      * @access public
  621.      * @return bool
  622.      */
  623.     public function isAuthor($idperson = null, $idcontact_publisher = null)
  624.     {
  625.         if (empty($idperson)) {
  626.             $idperson = $this->idperson;
  627.         }
  629.         $sql = 'SELECT COUNT(DISTINCT(t.idtext))
  630.                 FROM text_author ta, texts t
  631.                 WHERE t.idtext=ta.idtext AND t.textfictif=0
  632.                 AND ta.idperson=' . (int)$idperson;
  634.         if ($_ENV['CHECK_IF_ONLINE']) {
  635.             $sql .= ' AND t.publish=1';
  636.         }
  638.         // si on recherche spécifiquement chez un editeur
  639.         if ($idcontact_publisher && $this->my_is_int($idcontact_publisher)) {
  641.             $sql .= ' AND t.idcontact_publisher=' . $idcontact_publisher;
  643.             // on trouve aussi le nombre de traductions des textes de cet auteur chez cet éditeur
  644.             $sql_trads = 'SELECT COUNT(DISTINCT(t.idtext)) as total
  645.                             FROM text_traduction tt, texts t
  646.                             WHERE 1
  647.                             AND t.idtext=tt.idtexttraduction
  648.                             AND t.idcontact_publisher=' . $idcontact_publisher . '
  649.                             AND t.textfictif=0
  650.                             AND tt.idtext IN (
  651.                                 SELECT idtext FROM text_author WHERE idperson=' . $idperson . '
  652.                             )';
  654.             if ($_ENV['CHECK_IF_ONLINE']) {
  655.                 $sql .= ' AND t.publish=1';
  656.             }
  658.             $nb_trads = $this->queryOne($sql_trads);
  660.         } else {
  662.             // TODO
  663.             $sql .= ' AND t.type IN (0,2) ';
  665.         }
  667.         $nb_textes = $this->queryOne($sql);
  669.         if (!empty($nb_trads)) {
  670.             return $nb_textes + $nb_trads;
  671.         } else {
  672.             return $nb_textes;
  673.         }
  674.     }
  676.     // }}}
  678.     //  {{{ isAdaptateur()
  680.     /** Voir si c'est un adaptateur (type=2)
  681.      *
  682.      * @access public
  683.      * @return bool
  684.      */
  685.     public function isAdaptateur($idperson = null)
  686.     {
  687.         if (empty($idperson)) {
  688.             $idperson = $this->idperson;
  689.         }
  691.         $sql = 'SELECT COUNT(DISTINCT(t.idtext)) as total
  692.                 FROM text_author ta, texts
  693.                 WHERE 1
  694.                 AND t.idtext=ta.idtext
  695.                 AND t.textfictif=0
  696.                 AND ta.idperson=' . $idperson . '
  697.                 AND t.type=2';
  699.         if ($_ENV['CHECK_IF_ONLINE']) {
  700.             $sql .= ' AND t.publish=1';
  701.         }
  703.         return $this->queryOne($sql);
  704.     }
  706.     // }}}
  708.     //  {{{ isTranslator()
  710.     /** Voir si c'est un traducteur
  711.      *
  712.      * @access public
  713.      * @return bool
  714.      */
  715.     public function isTranslator($idperson = null, $idcontact_publisher = null)
  716.     {
  717.         if (empty($idperson)) {
  718.             $idperson = $this->idperson;
  719.         }
  721.         $sql = 'SELECT COUNT(DISTINCT(tt.idtext)) as total
  722.                 FROM text_translator tt, texts t
  723.                 WHERE 1
  724.                 AND t.idtext=tt.idtext
  725.                 AND t.textfictif=0
  726.                 AND tt.idperson=' . $idperson;
  728.         if ($_ENV['CHECK_IF_ONLINE']) {
  729.             $sql .= ' AND t.publish=1';
  730.         }
  732.         // si on recherche spécifiquement chez un editeur
  733.         if ($idcontact_publisher) {
  734.             $sql .= ' AND t.idcontact_publisher=' . ((int)$idcontact_publisher);
  735.         }
  737.         return $this->queryOne($sql);
  739.     }
  741.     // }}}
  743.     //  {{{ isDirector()
  745.     /** Voir si c'est un metteur en scene
  746.      *
  747.      * @access public
  748.      * @return bool
  749.      */
  751.     public function isDirector($idperson = null)
  752.     {
  753.         if (empty($idperson)) {
  754.             $idperson = $this->idperson;
  755.         }
  756.         $sql = 'SELECT COUNT(DISTINCT(sp.idspectacle)) as total
  757.                 FROM spectacle_person sp, spectacles s
  758.                 WHERE 1
  759.                 AND sp.idspectacle=s.idspectacle
  760.                 AND sp.idperson=' . $idperson . '
  761.                 AND sp.idrole=1';
  763.         if ($_ENV['CHECK_IF_ONLINE']) {
  764.             $sql .= ' AND s.publish=1';
  765.         }
  766.         return $this->queryOne($sql);
  767.     }
  769.     // }}}
  771.     //  {{{ getAuthors()
  773.     /** Récupération des auteurs d'un texte
  774.      *
  775.      * @access public
  776.      * @return array
  777.      */
  778.     public function getAuthors($idtext = null)
  779.     {
  780.         if (!empty($idtext)) {
  781.             // objet texts
  782.             $text = $this->getEntityManager()->getRepository(Texts::class);
  783.             return $text->getAuthors($idtext);
  784.         }
  785.     }
  787.     // }}}
  789.     //  {{{ getTextTitle()
  791.     /** Récupération du titre d'un texte
  792.      *
  793.      * @access public
  794.      * @return array
  795.      */
  796.     public function getInfoText($idtext = null)
  797.     {
  798.         if (empty($idtext)) $idtext = $this->idtext;
  799.         $texts = $this->getEntityManager()->getRepository(Texts::class);
  800.         return $texts->getObjectTitle($idtext, array(), array('noauthor' => true, 'return_array' => true));
  801.     }
  803.     // }}}
  805.     //  {{{ orderByDefaut()
  807.     /** Classement par défaut
  808.      *
  809.      * Défini le tri par défaut pour les requêtes de type SELECT
  810.      *
  811.      * @access public
  812.      * @return string
  813.      */
  814.     public function orderByDefaut($order = null)
  815.     {
  816.         if (empty($order)) $order = 'persons.idperson';
  817.         return $order;
  818.     }
  820.     // }}}
  822.     //  {{{ getListSearch()
  824.     /** Liste de personnes
  825.      *
  826.      * Pour les champs Ajax de relations et les recherches diverses
  827.      *
  828.      * @access  public
  829.      * @param string $lettres Pour la recherche alphabetique
  830.      * @param string $type Pour le type recherche (traducteur, auteur...)
  831.      * @param string $keywords Recherche par mots cles
  832.      * @return  array
  833.      */
  834.     public function getListSearch($lettre, $type = null, $keywords = null)
  835.     {
  837.         $sql = 'SELECT p.`idperson`, p.`firstname`, p.`lastname`
  838.                  FROM ' . $this->__table . ' p
  839.                  WHERE 1 ';
  841.         // selection par ordre alpha
  842.         if (!empty($lettre)) {
  843.             $sql_where[] = array('LOWER(LEFT(LTRIM(p.`lastname`),1))=\'' . $this->escape($lettre) . '\'');
  844.         }
  846.         // recherche avec un mot cle
  847.         $list = $this->splitKeywords($keywords);
  849.         if ($list) {
  850.             if (!empty($list[$this->IDSTR])) {
  851.                 // si la liste est > 1 alors 0 = prénom et 1 = nom ou le contraire
  852.                 if (count($list[$this->IDSTR]) == 2) {
  853.                     $sql_where[] = array('(p.`lastname` LIKE \'%' . $list[$this->IDSTR][0] . '%\' AND p.`firstname` LIKE \'%' . $list[$this->IDSTR][1] . '%\')
  854.                                     OR (p.`firstname` LIKE \'%' . $list[$this->IDSTR][0] . '%\' AND p.`lastname` LIKE \'%' . $list[$this->IDSTR][1] . '%\')');
  855.                 } else {
  856.                     // mots clés
  857.                     foreach ($list[$this->IDSTR] as $s) {
  858.                         $sql_more_name[] = 'p.`lastname` LIKE \'%' . $s . '%\'';
  859.                     }
  860.                     $sql_where[] = array('(' . join(' OR ', $sql_more_name) . ')');
  861.                 }
  862.             }
  863.             if (!empty($list[$this->IDNUM])) {
  864.                 // recherche par numéro d'id pour les mots clés numériques
  865.                 $sql_where[] = array('p.`idperson` IN (' . implode(',', $list[$this->IDNUM]) . ')', 'OR');
  866.             }
  867.         }
  869.         // on recherche par type
  870.         if ($type == 'translator') {
  871.             $sql_more = 'SELECT DISTINCT(idperson) FROM text_translator';
  872.             $sql_where[] = array('p.`idperson` IN (' . $sql_more . ')', 'AND');
  873.         }
  874.         if ($type == 'author') {
  875.             $sql_more = 'SELECT DISTINCT(idperson) FROM text_author';
  876.             $sql_where[] = array('p.`idperson` IN (' . $sql_more . ')', 'AND');
  877.         }
  878.         // uniquement associé à un multimedia
  879.         if ($type == 'multimedia') {
  880.             $sql_more = 'SELECT DISTINCT(idobject) FROM object_multimedia WHERE object=\'persons\'';
  881.             $sql_where[] = array('p.`idperson` IN (' . $sql_more . ')', 'AND');
  882.         }
  884.         // recherche AND ou autre
  885.         foreach ($sql_where as $k => $v) {
  886.             if (!empty($v[1])) {
  887.                 $sql .= ' ' . $v[1] . ' ' . $v[0];
  888.             } else {
  889.                 $sql .= ' AND ' . $v[0];
  890.             }
  891.         }
  893.         $sql .= ' ORDER BY p.`lastname`, p.`firstname`';
  895.         $this->query($sql);
  897.         $r = array();
  899.         while ($this->fetch()) {
  900.             $r[$this->idperson] = mb_strtoupper($this->lastname) . ' ' . $this->firstname;
  901.             // si trouvé par id, on l'affiche en fin de titre
  902.             if (!empty($list[$this->IDNUM]) && in_array($this->idperson, $list[$this->IDNUM])) {
  903.                 $r[$this->idperson] .= ' - n°' . $this->idperson;
  904.             }
  905.         }
  906.         $this->free();
  908.         return $r;
  909.     }
  911.     // }}}
  913.     //  {{{ getObjectTitle()
  915.     /** Infos de l'item recherché
  916.      *
  917.      *
  918.      * @access public
  919.      * @param int $idobject Identifiant de l'item
  920.      * @param array $infos_object Informations pour construire le titre
  921.      * @param array $params Paramétres supplémentaires
  922.      * @return string|array
  923.      */
  924.     public function getObjectTitle($idobject = null, $infos_object = array(), $params = array())
  925.     {
  926.         if (!$idobject && isset($this->idperson)) {
  927.             $idobject = $this->idperson;
  928.         }
  930.         if (is_object($idobject)) {
  931.             $idobject = $idobject->getIdperson();
  932.         }
  934.         // champs
  935.         $fields = array('idperson', 'lastname', 'firstname');
  937.         if (!empty($infos_object)) {
  938.             // Pour les données chargés grace à Doctrine
  939.             $fields[] = 'urlClean';
  941.             foreach ($fields as $k => $v) {
  942.                 if (array_key_exists($v, $infos_object)) {
  943.                     $infos[$v] = $infos_object[$v];
  944.                 } else {
  945.                     $infos[$v] = '';
  946.                 }
  947.             }
  948.         } else {
  949.             //charger les infos que si necessaire
  950.             if (empty($this->lastname)) {
  951.                 // Pour les données chargés grace à du SQL native
  952.                 $fields[] = 'url_clean';
  954.                 $sql = 'SELECT ' . implode(',', $fields) . '
  955.                         FROM ' . $this->__table . '
  956.                         WHERE ' . $this->__idtable . '=' . $idobject;
  958.                 $infos = $this->queryRow($sql);
  959.             } else {
  960.                 // Pour les données chargés grace à Doctrine
  961.                 $fields[] = 'urlClean';
  963.                 foreach ($fields as $k => $v) {
  964.                     if (isset($this->$v) && $this->$v != '') {
  965.                         $infos[$v] = trim($this->$v);
  966.                     } else {
  967.                         $infos[$v] = '';
  968.                     }
  969.                 }
  970.             }
  971.         }
  973.         // changer l'ordre si besoin
  974.         if (in_array('inverse', $params)) {
  975.             if (!empty($infos['firstname'])) {
  976.                 $infos['title'] = $infos['firstname'] . ' ' . $infos['lastname'];
  977.             } else {
  978.                 $infos['title'] = $infos['lastname'];
  979.             }
  980.         } else {
  981.             $infos = $infos ?: [];
  982.             $infos['lastname_oupper'] = mb_strtoupper($infos['lastname']);
  983.             if (!empty($infos['firstname'])) {
  984.                 $infos['title'] = $infos['lastname_oupper'] . ' ' . $infos['firstname'];
  985.             } else {
  986.                 $infos['title'] = $infos['lastname_oupper'];
  987.             }
  988.         }
  990.         // renvoyer un array plutôt que le titre (utile si on veux l'url)
  991.         if (array_key_exists('return_array', $params)) {
  992.             return $infos;
  993.         }
  995.         return $infos['title'];
  996.     }
  998.     // }}}
  1000.     //  {{{ byGenre()
  1002.     /** Genre du texte pour une recherche
  1003.      *
  1004.      * chercher le titre traduit du texte dans une langue donnée
  1005.      *
  1006.      * @access  public
  1007.      */
  1008.     public function byGenre($idgenretext)
  1009.     {
  1010.         $this->byGenreText = $idgenretext;
  1011.     }
  1013.     // }}}
  1015.     //  {{{ getInfosObject()
  1017.     /** Alias de getInfosPerson
  1018.      *
  1019.      * @access  public
  1020.      * @param int $idobject identifiant
  1021.      * @return  array
  1022.      * @see     getInfosPerson()
  1023.      */
  1024.     public function getInfosObject($idobject = null)
  1025.     {
  1026.         return $this->getInfosPerson($idobject);
  1027.     }
  1029.     // }}}
  1031.     // {{{ getVignettePerson()
  1033.     /** Récupére la vignette d'une personne ou la cree si besoin
  1034.      *
  1035.      * @access   public
  1036.      * param     int $idperson identifiant de la fiche persons
  1037.      * param     array $format format de l'image
  1038.      * param     bool $return_only Ne pas retourner l'image par défaut
  1039.      * @return   string
  1040.      */
  1041.     public function getVignettePerson($idperson = null, $format = array(), $return_only = true)
  1042.     {
  1043.         if (!$idperson) $idperson = $this->idperson;
  1045.         // par default : image normal 100px x 100px qualite 75
  1046.         if ($format) {
  1047.             $set_format = $format;
  1048.         } else {
  1049.             $set_format = array('width' => 70, 'height' => 70, 'direction' => 'thumb');
  1050.         }
  1052.         // generation par la classe Images
  1053.         $images = $this->images;
  1054.         $images->setVignetteFormat($set_format);
  1055.         return $images->getVignetteObject($idperson, 'persons', 'class_photo_person', null, 1, $return_only);
  1057.     }
  1059.     // }}}
  1061.     // {{{ getVignette()
  1063.     /** Récupére la vignette d'une personne ou la cree si besoin
  1064.      *
  1065.      * @see getVignettePerson
  1066.      */
  1067.     public function getVignette($idperson = null, $format = array())
  1068.     {
  1069.         return $this->getVignettePerson($idperson, $format);
  1070.     }
  1072.     // }}}
  1074.     //  {{{ getRelationsArray()
  1076.     /** Décrit les relations de l'objet
  1077.      *
  1078.      * @access  public
  1079.      * @param string|int $type si on souhaite retourner uniquement un type precis
  1080.      * @see     Theatre::getLinkedObject()
  1081.      */
  1082.     public function getRelationsArray($type = null)
  1083.     {
  1084.         $array_types = array(
  1085.             'person_classification' => array(// classifications associées
  1086.                 'type_join' => 'multiple',
  1087.                 'dest_table' => 'classifications',
  1088.                 'join_table' => 'person_classification',
  1089.                 'fields' => array('idclassification', 'classification', 'type'),
  1090.             ),
  1091.             'text_person' => array(// persons liées à un texte
  1092.                 'type_join' => 'multiple',
  1093.                 'dest_table' => 'texts',
  1094.                 'join_table' => 'text_person',
  1095.                 'field_link' => 'idrole', //TODO
  1096.                 'fields' => array('title', 'url_clean', 'valid'),
  1097.             ),
  1098.             // contact_person idcontact/idperson/idrole
  1099.             'contact_person' => array(// contact associé à des personnes (direction d'une structure...)
  1100.                 'type_join' => 'multiple',
  1101.                 'dest_table' => 'contacts',
  1102.                 'join_table' => 'contact_person',
  1103.                 'fields' => array('idcontact', 'organisation', 'url_clean'),
  1104.                 'fields_join_table' => array('idoffice', 'date_start', 'date_end'),
  1105.                 'description' => 'Personne(s) associée(s) au contact',
  1106.             ),
  1107.             // person annuaire
  1108.             'directories' => array(// contact associé à des personnes (direction d'une structure...)
  1109.                 'type_join' => 'simple',
  1110.                 'dest_table' => 'directories',
  1111.                 'fields' => array('idperson', 'idcontact'),
  1112.                 'description' => 'Fiche(s) annuaire(s)',
  1113.             ),
  1115.             /*bookmark_extranetuser
  1116.             contact_person
  1117.             dvd_person
  1118.             files
  1119.             contents
  1120.             new_person
  1121.             object_content > object/idobject
  1122.             object_file => object/idobject
  1123.             object_multimedia => object/idobject
  1124.             persons
  1125.             person_classification
  1126.             person_ecole
  1127.             person_extranetuser
  1128.             spectacle_person
  1129.             stats => object/idobject
  1130.             text_author
  1131.             text_person
  1132.             text_translator*/
  1134.         );
  1136.         // retourne uniquement un type précis
  1137.         if (!empty($array_types[$type])) {
  1138.             $array_types[$type]['type'] = $type;
  1139.             return $array_types[$type];
  1140.         } else {
  1141.             return $array_types;
  1143.         }
  1145.     }
  1147.     // }}}
  1149.     //  {{{ getSQLPersons()
  1151.     /** Générer la requete standard pour une person
  1152.      *
  1153.      * $params = array(
  1154.      *  'select' => champs en plus pour le select,
  1155.      *  'from' => champs en plus pour le from,
  1156.      *  'where' => paramètres en plus le where,
  1157.      *  'order' => classement des résultats,
  1158.      *  'limit' => limiter le nb de résultats array(debut,fin), (all pour pas de limit)
  1159.      * )
  1160.      * $special = array(
  1161.      *  'alpha' => recherche alphabétique sur le nom
  1162.      *  'search' =>  recherche par mots-clés sur le nom
  1163.      * )
  1164.      *
  1165.      *
  1166.      * @access   public
  1167.      * @param array $params Les paramètres pour la requete
  1168.      * @param array $special Les paramètres supplémentaires
  1169.      * @param bool $debug afficher la requête TODO
  1170.      * @return   string
  1171.      */
  1172.     public function getSQLPersons($params = array(), $special = array(), $debug = false)
  1173.     {
  1175.         $sql_join = '';
  1177.         if (empty($params['where'])) {
  1178.             $params['where'] = '';
  1179.         }
  1180.         if (empty($params['from'])) {
  1181.             $params['from'] = '';
  1182.         }
  1183.         if (empty($params['select'])) {
  1184.             $params['select'] = '';
  1185.         }
  1187.         // selon une classification
  1188.         if (!empty($special['idclassification'])) {
  1190.             // commun
  1191.             $params['from'] .= ' person_classification c1';
  1192.             $params['where'] .= ' AND T1.idperson= c1.idperson
  1193.                                   AND c1.idclassification=' . (int)$special['idclassification'];
  1194.         }
  1196.         // selon une personne
  1197.         if (!empty($special['idperson'])) {
  1198.             $params['where'] .= ' AND c1.idperson = ' . (int)$special['idperson'];
  1199.         }
  1201.         // role special dans un spectacle
  1202.         if (!empty($special['idrole'])) {
  1204.             // commun
  1205.             $params['from'] .= ' spectacle_person sp, spectacles s';
  1206.             $params['where'] .= ' AND T1.idperson=sp.idperson
  1207.                                  AND s.publish=1
  1208.                                  AND s.idspectacle=sp.idspectacle ';
  1210.             // si recherche table role ou direct id
  1211.             if (!$this->my_is_int($special['idrole'])) {
  1212.                 $params['from'] .= ', roles r';
  1213.                 $params['where'] .= ' AND sp.idrole=r.idrole
  1214.                                       AND r.role=\'' . $this->escape($special['idrole']) . '\' ';
  1215.             } else {
  1216.                 $params['where'] .= ' AND sp.idrole=' . (int)$special['idrole'];
  1217.             }
  1219.         }
  1221.         // personnes avec photo
  1222.         if (!empty($special['with_photo'])) {
  1223.             $sql_join .= '
  1224.                     JOIN object_file of ON T1.`idperson`=of.`idobject`
  1225.                     JOIN files f ON of.`idfile`=f.`idfile`
  1226.                     JOIN file_classification fc ON f.`idfile`=fc.`idfile` ';
  1227.             // class_photo_person
  1228.             $params['where'] .= '
  1229.                     AND fc.`idclassification`=14
  1230.             ';
  1231.         }
  1233.         // sexe de la personne
  1234.         if (!empty($special['sexe'])) {
  1235.             $params['where'] .= ' AND sexe=' . $this->getSexeValue($special['sexe']) . ' ';
  1236.         }
  1238.         // personne ayant un texte édité chez un éditeur
  1239.         if (!empty($special['contacts']['publishers'])) {
  1240.             //Les traducteurs
  1241.             if (!empty($special['translator'])) {
  1242.                 $sql_join .= ' 
  1243.                     JOIN text_author T3 ON T2.`idperson` = T3.`idperson`
  1244.                     JOIN texts t ON t.`idtext`=T3.`idtext` 
  1245.                 ';
  1246.             } //Les auteurs
  1247.             else if (empty($special['contacts']['desactive_jointure_author'])) {
  1248.                 $sql_join .= ' 
  1249.                     JOIN text_author T2 ON T2.`idperson` = T1.`idperson`
  1250.                     JOIN texts t ON t.`idtext`=T2.`idtext` 
  1251.                 ';
  1252.             }
  1254.             $params['where'] .= ' AND t.`idcontact_publisher` IN  (' . $this->arrayToIn($special['contacts']['publishers']) . ') ';
  1255.         }
  1257.         // personnes à l'affiche
  1258.         if (!empty($special['spectacle'])) {
  1260.             $params['where'] .= '
  1261.                     AND s.`valid`=1
  1262.                     AND s.`publish`=1
  1263.                     AND s.`textfictif`=0
  1264.                     AND T1.`publish`=1 ';
  1266.             $roles_types = array(
  1267.                 'director' => array(1),
  1268.                 'actors' => array(5)
  1269.             );
  1271.             if (!empty($special['spectacle']['type'])) {
  1272.                 if ($special['spectacle']['type'] == 'author') {
  1273.                     $sql_join .= '
  1274.                             JOIN spectacle_author sa ON T1.`idperson`=sa.`idperson`
  1275.                             JOIN spectacles s ON sa.`idspectacle`=s.`idspectacle`
  1276.                             JOIN text_spectacle ts ON s.`idspectacle`=ts.`idspectacle`
  1277.                             JOIN texts t ON t.`idtext`=ts.`idtext` ';
  1278.                     $params['where'] .= ' AND t.`type` IN (0,1) ';
  1279.                 } elseif (array_key_exists($special['spectacle']['type'], $roles_types)) { // autres roles
  1280.                     $sql_join .= '
  1281.                             JOIN spectacle_person sp ON T1.`idperson`=sp.`idperson`
  1282.                             JOIN spectacles s ON sp.`idspectacle`=s.`idspectacle`
  1283.                             JOIN text_spectacle ts ON s.`idspectacle`=ts.`idspectacle`
  1284.                             JOIN texts t ON t.`idtext`=ts.`idtext` ';
  1285.                     $params['where'] .= ' AND sp.`idrole` IN (' . join(',', $roles_types[$special['spectacle']['type']]) . ') ';
  1286.                 } elseif ($special['spectacle']['type'] == 'all') {
  1287.                     $sql_join .= '
  1288.                             LEFT JOIN spectacle_author sa ON T1.`idperson`=sa.`idperson`
  1289.                             LEFT JOIN spectacle_person sp ON T1.`idperson`=sp.`idperson`
  1290.                             JOIN spectacles s ON s.idspectacle=sp.idspectacle
  1291.                             JOIN text_spectacle ts ON s.`idspectacle`=ts.`idspectacle`
  1292.                             JOIN texts t ON t.`idtext`=ts.`idtext` ';
  1293.                 }
  1294.             } else {
  1295.                 $sql_join .= '
  1296.                         JOIN spectacle_author sa ON T1.`idperson`=sa.`idperson`
  1297.                         JOIN spectacles s ON sa.`idspectacle`=s.`idspectacle`
  1298.                         JOIN text_spectacle ts ON s.`idspectacle`=ts.`idspectacle`
  1299.                         JOIN texts t ON t.`idtext`=ts.`idtext` ';
  1300.             }
  1302.             if (!empty($special['spectacle']['count_date'])) {
  1303.                 $params['select'] .= ' COUNT( sc.`idschedule` ) AS nb_dates ';
  1304.                 $params['groupby'] = ' T1.`idperson`, t.`idtext` ';
  1305.                 $params['order'] = ' nb_dates DESC ';
  1306.             }
  1308.             // uniquement certain type de text
  1309.             if (!empty($special['spectacle']['text']['type'])) {
  1310.                 $params['where'] .= ' AND t.`type` IN  (' . $this->arrayToIn($special['spectacle']['text']['type']) . ') ';
  1311.             }
  1313.             $sql_join .= '
  1314.                     JOIN schedules sc ON s.`idspectacle`=sc.`idspectacle` ';
  1316.             if (!empty($special['spectacle']['prochains'])) {
  1317.                 $date = new \DateTime('now');
  1318.                 $date->add(new DateInterval('P' . $special['spectacle']['prochains']));
  1319.                 $params['where'] .= ' AND sc.`date` BETWEEN \'' . date('Y-m-d') . '\' AND \'' . $date->format('Y-m-d') . '\' ';
  1320.             }
  1322.             if (!empty($special['spectacle']['saison'])) {
  1323.                 $s = explode('-', $special['spectacle']['saison']);
  1324.                 $params['where'] .= ' AND sc.`date` BETWEEN \'' . $s[0] . '-09-01\' AND \'' . $s[1] . '-08-31\' ';
  1325.             }
  1327.             if (!empty($special['spectacle']['year'])) {
  1328.                 $params['where'] .= ' AND sc.`date` BETWEEN \'' . (int)$special['spectacle']['year'] . '-01-01\' AND \'' . $special['spectacle']['year'] . '-12-31\' ';
  1329.             }
  1331.             if (!empty($special['spectacle']['person_periode'])) {
  1333.                 $date = new \DateTime('now');
  1334.                 $date->sub(new DateInterval('P70Y'));
  1336.                 if ($special['spectacle']['person_periode'] == 'public') {
  1337.                     $params['where'] .= ' AND (T1.`dateend`!=0 AND T1.`dateend`<=\'' . $date->format('Y-m-d') . '\') ';
  1338.                 } elseif ($special['spectacle']['person_periode'] == 'contemporain') {
  1339.                     $params['where'] .= ' AND (T1.`dateend` IS NULL OR T1.`dateend` = 0 OR T1.`dateend`>=\'' . $date->format('Y') . '\' ) ';
  1340.                 } else {
  1341.                     $params['where'] .= ' AND (T1.`dateend` IN (0,\'\') OR T1.`dateend` IS NULL) ';
  1342.                 }
  1344.             }
  1346.             if (!empty($special['spectacle']['text_edite'])) {
  1347.                 //$params['where'] .= ' AND T1.`idperson` IN (SELECT idperson FROM text_author JOIN texts WHERE text_author.idtext=texts.idtext AND texts.idcontact_publisher IS NOT NULL) ';
  1348.                 $params['where'] .= ' AND t.`idcontact_publisher` IS NOT NULL ';
  1349.             }
  1351.             if (!empty($special['spectacle']['periode'])) {
  1352.                 if (strpos($special['spectacle']['periode']['start'], '/') !== false) {
  1353.                     $datestart = DateTime::createFromFormat('d/m/Y', $special['spectacle']['periode']['start']);
  1354.                     $dateend = DateTime::createFromFormat('d/m/Y', $special['spectacle']['periode']['end']);
  1355.                 } else {
  1356.                     $datestart = DateTime::createFromFormat('Y-m-d', $special['spectacle']['periode']['start']);
  1357.                     $dateend = DateTime::createFromFormat('Y-m-d', $special['spectacle']['periode']['end']);
  1358.                 }
  1359.                 $params['where'] .= ' AND sc.`date` BETWEEN \'' . $datestart->format('Y-m-d') . '\'
  1360.                                       AND \'' . $dateend->format('Y-m-d') . '\' ';
  1361.             }
  1363.             if (!empty($special['spectacle']['idtypestructure'])) {
  1364.                 $sql_join .= ' JOIN contacts ON sc.`idcontact` = contacts.`idcontact` ';
  1365.                 $join_contact = true;
  1366.                 if (is_array($special['spectacle']['idtypestructure'])) {
  1367.                     foreach ($special['spectacle']['idtypestructure'] as $k => $v) {
  1368.                         $idtypestructures[$k] = '\'' . $v . '\'';
  1369.                     }
  1370.                     $params['where'] .= ' AND contacts.`idtypestructure` IN (' . join(',', $idtypestructures) . ') ';
  1371.                 } else {
  1372.                     $params['where'] .= ' AND contacts.`idtypestructure`=\'' . $special['spectacle']['idtypestructure'] . '\' ';
  1373.                 }
  1374.             }
  1376.             if (!empty($special['spectacle']['country'])) {
  1377.                 if (empty($join_contact)) {
  1378.                     $sql_join .= ' JOIN contacts ON sc.`idcontact`= contacts.`idcontact` ';
  1379.                 }
  1380.                 $params['where'] .= ' AND contacts.`country`=\'' . $special['spectacle']['country'] . '\' ';
  1381.             }
  1383.         }
  1385.         // étudiants d'une école
  1386.         if (!empty($special['person_ecole'])) {
  1388.             foreach (array('url_clean', 'idcontact', 'organisation') as $f) {
  1389.                 $params['select'] .= ' cte.`' . $f . '` as contact_' . $f . ', ';
  1390.             }
  1392.             $params['select'] .= ' pe.*, YEAR(pe.`date_start`) as year_start, YEAR(pe.`date_end`) as year_end ';
  1394.             $sql_join .= ' JOIN person_ecole pe ON T1.`idperson`=pe.`idperson`
  1395.                            JOIN contacts cte ON pe.`idcontact`=cte.`idcontact` ';
  1397.             // pour un contact précis
  1398.             if (!empty($special['person_ecole']['idcontact'])) {
  1399.                 $params['where'] .= ' AND pe.`idcontact` IN (' . $this->arrayToIn($special['person_ecole']['idcontact']) . ') ';
  1400.             }
  1402.             // pour un role
  1403.             if (!empty($special['person_ecole']['idrole'])) {
  1404.                 $sql_join .= ' JOIN ecole_role er ON pe.`idperson`=er.`idperson` ';
  1405.                 $params['where'] .= ' AND er.`idrole` IN (' . $this->arrayToIn($special['person_ecole']['idrole']) . ') ';
  1406.             }
  1408.             if (!empty($special['person_ecole']['exclude_jtn'])) { // pas le JTN
  1409.                 $params['where'] .= ' AND pe.`idcontact`!=3914 ';
  1410.             }
  1412.             if (!empty($special['person_ecole']['periode'])) { // uniquement les actifs => date de fin vide
  1413.                 if ($special['person_ecole']['periode'] == 'actual') {
  1414.                     $params['where'] .= '
  1415.                     AND (
  1416.                         (pe.`date_end` IS NULL OR pe.`date_end`=\'0000-00-00 00:00:00\' OR pe.`date_end`>=\'' . date('Y-m-d') . '\')
  1417.                         AND pe.`date_start`<=\'' . date('Y-m-d') . '\'
  1418.                     )';
  1419.                 }
  1420.                 if ($this->my_is_int($special['person_ecole']['periode']) && strlen($special['person_ecole']['periode']) == 4) {
  1421.                     $params['where'] .= ' AND YEAR(pe.`date_end`)=\'' . $special['person_ecole']['periode'] . '\' ';
  1422.                 }
  1423.             }
  1425.         }
  1427.         // directeur de structure en particulier
  1428.         if (!empty($special['contact_person'])) {
  1430.             $sql_join .= ' JOIN contact_person cp ON T1.`idperson`=cp.`idperson`
  1431.                            JOIN contacts c1 ON c1.`idcontact`=cp.`idcontact` ';
  1433.             $roles_types = array(
  1434.                 'directeur' => array(1),
  1435.                 'actors' => array(5)
  1436.             );
  1438.             // auteurs
  1439.             if (array_key_exists($special['contact_person']['idoffice'], $roles_types)) { // autres roles
  1440.                 $params['where'] .= ' AND cp.`idoffice` IN (' . join(',', $roles_types[$special['contact_person']['idoffice']]) . ') ';
  1441.             }
  1443.             if (array_key_exists('actual', $special['contact_person'])) { // uniquement les actifs
  1444.                 $params['where'] .= ' AND ((cp.`date_end` IS NULL OR cp.`date_end`=\'0000-00-00 00:00:00\' OR cp.`date_end`>=\'' . date('Y-m-d') . '\') AND cp.`date_start`<=\'' . date('Y-m-d') . '\')';
  1445.             }
  1447.             if (array_key_exists('idtypestructure', $special['contact_person'])) {
  1448.                 $params['where'] .= ' AND c1.`idtypestructure`=\'' . $special['contact_person']['idtypestructure'] . '\' ';
  1449.             }
  1451.         }
  1453.         // recherche auteurs
  1454.         if (!empty($special['author'])) {
  1455.             $params['where'] = ' AND (
  1456.                         (T1.dateend=0 OR T1.dateend IS NULL OR T1.dateend>1970)
  1457.                         AND (
  1458.                                 T1.idperson IN
  1459.                                 (
  1460.                                     SELECT persons.idperson FROM persons, text_author, text_spectacle
  1461.                                     WHERE persons.idperson=text_author.idperson AND text_spectacle.idtext=text_author.idtext
  1462.                                     AND text_spectacle.idtext NOT IN (SELECT idtextadaptation FROM text_adaptation)
  1463.                                 )
  1464.                                 OR T1.idperson IN
  1465.                                 (
  1466.                                     SELECT persons.idperson FROM persons, text_author
  1467.                                     WHERE persons.idperson=text_author.idperson AND text_author.idtext IN (SELECT idtext FROM text_traduction)
  1468.                                 )
  1469.                             )
  1470.                         OR T1.idrole=21) ';
  1472.             if (!empty($special['contacts']['publishers'])) {
  1473.                 $params['where'] .= ' AND t.`idcontact_publisher` IN  (' . $this->arrayToIn($special['contacts']['publishers']) . ') ';
  1474.             }
  1475.         }
  1477.         // rechecher traducteurs
  1478.         if (!empty($special['translator'])) {
  1479.             $params['from'] = array('text_translator' => 'join');
  1480.         }
  1482.         // francophone
  1483.         if (isset($special['is_francophone'])) {
  1484.             $params['where'] .= ' AND T1.`language`=\'fr\' ';
  1485.         }
  1486.         if (isset($special['is_non_francophone'])) {
  1487.             $params['where'] .= ' AND T1.`language`!=\'fr\' ';
  1488.         }
  1490.         // publié
  1491.         if (isset($special['publish'])) {
  1492.             $params['where'] .= ' AND T1.`publish`=' . (int)$special['publish'];
  1493.         }
  1495.         // tables et champs
  1496.         $tables_list = array(
  1497.             'persons' => array(
  1498.                 'fields' => array('lastname', 'firstname', 'url_clean'),
  1499.             ),
  1500.         );
  1502.         $al = 1;
  1504.         foreach ($tables_list as $k => $v) {
  1505.             $tables_list[$k]['table_alias'] = $k . ' T' . $al;
  1506.             foreach ($v['fields'] as $f) {
  1507.                 $select_fields_array[] = 'T' . $al . '.' . $f;
  1508.             }
  1509.             $al++;
  1510.         }
  1512.         // select de base
  1513.         $sql_select = 'SELECT DISTINCT(T1.idperson), ' . join(',', $select_fields_array) . ' ';
  1515.         // select en plus
  1516.         if (array_key_exists('select', $params) && !empty($params['select'])) {
  1517.             $sql_select .= ',' . $params['select'];
  1518.         }
  1520.         // compte seulement
  1521.         if (array_key_exists('count_only', $special)) {
  1522.             $sql_select = 'SELECT COUNT(DISTINCT(T1.idperson)) as total ';
  1524.         }
  1526.         // récupère les lettres des prénoms
  1527.         if (array_key_exists('firstname_only', $special)) {
  1528.             $sql_select = 'SELECT DISTINCT(UPPER(LEFT(T1.`lastname`, 1))) as letter ';
  1529.         }
  1531.         // from
  1532.         foreach ($tables_list as $k => $v) {
  1533.             $sql_from_tables[] = $v['table_alias'];
  1534.         }
  1535.         $sql_from = ' FROM ' . join(',', $sql_from_tables);
  1537.         // déclaration si besoin de jointer avec la table persons
  1538.         $sql_join_more = array();
  1540.         // selectionde table en plus
  1541.         if (array_key_exists('from', $params) && !empty($params['from'])) {
  1542.             if (is_array($params['from'])) {
  1543.                 foreach ($params['from'] as $k => $v) {
  1544.                     $sql_from .= ',' . $k . ' T' . $al;
  1545.                     // join avec la table principale ?
  1546.                     if ($v == 'join') {
  1547.                         $sql_join_more[] = ' T1.idperson=T' . $al . '.idperson';
  1548.                     }
  1549.                 }
  1550.                 $al++;
  1551.             } else {
  1552.                 $sql_from .= ',' . $params['from'];
  1553.             }
  1554.         }
  1556.         // where standard
  1557.         $sql_where = ' WHERE 1 ';
  1559.         if (!empty($sql_join_more)) {
  1560.             $sql_where .= ' AND ' . join(' AND ', $sql_join_more);
  1561.         }
  1563.         // paramètres en plus
  1564.         if (array_key_exists('where', $params)) {
  1565.             $sql_where .= $params['where'];
  1566.         }
  1568.         // recherche alpha
  1569.         if (array_key_exists('alpha', $special)) {
  1570.             $sql_where .= ' AND T1.lastname REGEXP \'^' . $special['alpha'] . '\' ';
  1571.         }
  1573.         // recherche lastname
  1574.         if (array_key_exists('search', $special)) {
  1575.             // on split et on recherche sur les mots de plus de 2 cractères
  1576.             $keywords = explode(' ', trim($special['search']));
  1577.             if (!empty($keywords)) {
  1578.                 foreach ($keywords as $k) {
  1579.                     $sql_keywords[] = ' T1.lastname LIKE \'' . $this->escape('%' . trim($k) . '%') . '\' ';
  1580.                 }
  1581.                 $sql_where .= ' AND (' . join(' OR ', $sql_keywords) . ') ';
  1582.             } else {
  1583.                 $sql_where .= ' AND T1.lastname LIKE \'' . $this->escape('%' . $special['search'] . '%') . '\' ';
  1584.             }
  1585.         }
  1587.         if (empty($special['count_only'])) {
  1589.             // groupement par défaut
  1590.             if (!array_key_exists('groupby', $params)) {
  1591.                 $groupby = ' GROUP BY T1.idperson ';
  1592.             } else {
  1593.                 $groupby = ' GROUP BY ' . $params['groupby'];
  1594.             }
  1596.             // classement par défaut
  1597.             if (!array_key_exists('order', $params)) {
  1598.                 // si ancien, classement DESC
  1599.                 if (array_key_exists('desc', $special)) {
  1600.                     $classement = 'DESC';
  1601.                 } else {
  1602.                     $classement = 'ASC';
  1603.                 }
  1604.                 if (array_key_exists('classement', $params)) {
  1605.                     $classement = $params['classement'];
  1606.                 }
  1607.                 $order = ' ORDER BY T1.lastname ' . $classement;
  1608.             } else {
  1609.                 $order = ' ORDER BY ' . $params['order'];
  1610.             }
  1612.             // classement aléatoire
  1613.             if (array_key_exists('random', $special)) {
  1614.                 $order = ' ORDER BY RAND() ' . $special['random'];
  1615.             }
  1617.         } else {
  1618.             $order = null;
  1619.             $groupby = null;
  1620.         }
  1622.         // limite par défaut
  1623.         if (!array_key_exists('limit', $params)) {
  1624.             $limit = ' LIMIT 0,10';
  1625.         } else {
  1626.             if ($params['limit'] != 'all') {
  1627.                 $limit = ' LIMIT ' . $params['limit'][0] . ',' . $params['limit'][1];
  1628.             } else {
  1629.                 $limit = ' ';
  1630.             }
  1631.         }
  1633.         $sql_global = $sql_select . $sql_from . $sql_join . $sql_where . $groupby . $order . $limit;
  1635.         return $sql_select . $sql_from . $sql_join . $sql_where . $groupby . $order . $limit;
  1636.     }
  1638.     // }}}
  1640.     //  {{{ countListPersons()
  1642.     /** Compter une requête préparée
  1643.      *
  1644.      * @access   public
  1645.      * @param array $params_sql paramètre pour la requete SQL
  1646.      * @param bool $debug mode débugage
  1647.      * @return   int
  1648.      */
  1649.     public function countListPersons($params_sql = array(), $debug = false)
  1650.     {
  1652.         // si pas de tableau
  1653.         if (!isset($params_sql['special'])) {
  1654.             $params_sql['special'] = array();
  1655.         }
  1656.         if (!isset($params_sql['params'])) {
  1657.             $params_sql['params'] = array();
  1658.         }
  1660.         // si pas de limite => tout
  1661.         if (empty($params_sql['params']['limit'])) {
  1662.             $params_sql['params']['limit'] = 'all';
  1663.         }
  1665.         $params_sql['special']['count_only'] = true;
  1667.         // construction de la requête avec le passage de paramètres
  1668.         return $this->queryOne($this->getSQLPersons($params_sql['params'], $params_sql['special'], $debug));
  1670.     }
  1672.     // }}}
  1674.     //  {{{ getListPersons()
  1676.     /** Récupére la liste des persons
  1677.      *
  1678.      * Récupére les persons de manière standard
  1679.      *
  1680.      * @access   public
  1681.      * @param array $params_sql paramètre pour la requete SQL
  1682.      * @param array $format de la vignette si pas standard
  1683.      * @param bool $debug mode débugage
  1684.      * @return   array
  1685.      */
  1686.     public function getListPersons($params_sql = array(), $params = array(), $debug = false)
  1687.     {
  1688.         // si pas de tableau
  1689.         if (!isset($params_sql['special'])) {
  1690.             $params_sql['special'] = array();
  1691.         }
  1692.         if (!isset($params_sql['params'])) {
  1693.             $params_sql['params'] = array();
  1694.         }
  1696.         // construction de la requête avec le passage de paramètres
  1697.         $sql = $this->getSQLPersons($params_sql['params'], $params_sql['special'], $debug);
  1699.         // paramètre de debug
  1700.         $dbg = (empty($params_sql['dbg'])) ? array() : $dbg = $params_sql['dbg'];
  1702.         // executer la requete
  1703.         $this->query($sql, $dbg);
  1704.         $pers = array();
  1706.         $params_row = array();
  1708.         // debug
  1709.         $start_boucle = microtime(true);
  1711.         // style more ?
  1712.         if (!empty($params['stylemore'])) {
  1713.             $params_row['stylemore'] = $params['stylemore'];
  1714.         } else {
  1715.             $params_row['stylemore'] = array('imagep' => 'width:80px;', 'desctxt' => 'width:200px;');
  1716.         }
  1718.         // format de la vignette
  1719.         if (!empty($params['vignette_format'])) {
  1720.             $vignette_format_flou = $vignette_format = $params['vignette_format'];
  1721.         } else {
  1722.             $vignette_format_flou = $vignette_format = array('width' => $_ENV['VIGN_PERSONS_WIDTH'], 'height' => $_ENV['VIGN_PERSONS_HEIGHT'], 'direction' => 'crop');
  1723.         }
  1725.         $vignette_format_flou['blur'] = true;
  1727.         // mettre en forme chaque reponse
  1728.         $entity = new Persons();
  1730.         while ($attributes = $this->fetch()) {
  1732.             // uniquement les années d'étude
  1733.             if (!empty($params_sql['special']['person_ecole']['get_promos'])) {
  1734.                 $pers[$this->year_end]['annee'] = $this->year_end;
  1735.                 continue;
  1736.             }
  1738.             // infos sur la personne
  1739.             $pers[$this->idperson] = $this->getInfosPersonRow($vignette_format, $params_row);
  1740.             $pers[$this->idperson]['photo'] = $this->getVignettePerson($this->idperson, $vignette_format);
  1741.             $pers[$this->idperson]['photo_flou'] = $this->getVignettePerson($this->idperson, $vignette_format_flou);
  1743.             // dates
  1744.             if (isset($this->nb_dates)) {
  1745.                 $pers[$this->idperson]['nb_dates'] = $this->nb_dates;
  1746.             }
  1748.             // écoles
  1749.             if (!empty($params_sql['special']['person_ecole'])) {
  1750.                 $pers[$this->idperson]['person_ecole'] = array(
  1751.                     'date_start' => $this->date_start,
  1752.                     'date_end' => $this->date_end,
  1753.                     'year_start' => $this->year_start,
  1754.                     'year_end' => $this->year_end,
  1755.                     'comments' => $this->comments,
  1756.                     'contact' => array(
  1757.                         'url_clean' => $this->contact_url_clean,
  1758.                         'idcontact' => $this->contact_idcontact,
  1759.                         'organisation' => $this->contact_organisation,
  1760.                     )
  1761.                 );
  1762.             }
  1764.         }
  1766.         // libère
  1767.         $this->free();
  1769.         // debug de la boucle
  1770.         if ($this->isTraceMode('list_object')) {
  1771.             $this->setTraceInfos(array(
  1772.                 'execution_time_boucle' => (microtime(true) - $start_boucle),
  1773.                 'nb_occurence' => count($pers),
  1774.                 'dbg' => $dbg,
  1775.             ));
  1776.         }
  1778.         return $pers;
  1779.     }
  1781.     // }}}
  1783.     // {{{ getInfosPersonRow()
  1785.     /** Retrouner un tableau standard dans les listes
  1786.      *
  1787.      *
  1788.      * @param bool $vignette trouver les vignettes
  1789.      * @param array $params paramètres en plus
  1790.      * @access public
  1791.      * @return array
  1792.      */
  1793.     public function getInfosPersonRow($vignette = true, $params = array())
  1794.     {
  1796.         $pers = array();
  1797.         $idperson = $this->idperson;
  1799.         // id, nom, prenom, url_clean
  1800.         $pers = array(
  1801.             'idperson' => $this->idperson,
  1802.             'lastname' => mb_strtoupper($this->lastname, 'utf8'),
  1803.             'firstname' => $this->firstname,
  1804.             'url_clean' => $this->url_clean,
  1805.         );
  1807.         return $pers;
  1809.     }
  1811.     // }}}
  1813.     //  {{{ getAssociateTexts()
  1815.     /** Récupére des liste de texte en fonction de classification
  1816.      *
  1817.      * @access   public
  1818.      * @param int $idperson identifiant de la personne
  1819.      * @param int $idrole son role
  1820.      * @param int $classification la classification
  1821.      * @param array $params_link paramètre en plus
  1822.      * @return   array
  1823.      */
  1824.     public function getAssociateTexts($idperson, $idrole = null, $classification = null, $params_link = array())
  1825.     {
  1826.         if (!empty($classification)) {
  1827.             /*$classifications = Theatre::factory('classifications');
  1828.             $idlist = $classifications->classificationsToList($classification);
  1829.             $where = $classifications->listClassificationsWhere($idlist);*/
  1830.             if (is_array($classification)) {
  1831.                 $constraint_dest = 'idclassification IN (' . implode(',', $classification) . ')';
  1832.             } else {
  1833.                 $constraint_dest = 'idclassification=' . (int)$classification;
  1834.             }
  1835.         }
  1837.         $sql = 'SELECT DISTINCT(t.idtext)
  1838.                 FROM text_classification tc, text_person tp, classification cl, texts t
  1839.                 WHERE tc.idclassification=cl.idclassification
  1840.                 AND tp.idtext=tc.idtext
  1841.                 AND tp.idtext=t.idtext AND tc.idtext=t.idtext
  1842.                 AND tp.idperson=' . ((int)$idperson) . ' ';
  1844.         $infos_link = array( // liaison avec la table text_classification via la table text_author
  1845.             'type_join' => 'multiple',
  1846.             'dest_table' => 'text_classification',
  1847.             'join_table' => 'text_person',
  1848.             'fields' => array('idtext', 'idclassification'),
  1849.             'constraint_dest' => (!empty($constraint_dest)) ? $constraint_dest : '',
  1850.         );
  1852.         // si c'est pour l'auteur
  1853.         if (!empty($params_link['author'])) {
  1854.             $infos_link['join_table'] = 'text_author';
  1855.         }
  1857.         if (!empty($params['link'])) {
  1858.             $params_link = $params['link'];
  1859.         }
  1861.         // $params_link['debug'] = true;
  1862.         if (!empty($infos_link)) {
  1863.             $items = $this->getLinkedObject($infos_link, $idperson, null, 'persons', $params_link);
  1864.         }
  1866.         if (!empty($params_link['count_only'])) {
  1867.             return $items;
  1868.         }
  1870.         // grouper par classification
  1871.         if (!empty($classification) && !empty($params['by_classification'])) {
  1872.             if (is_array($classification)) {
  1873.                 foreach ($classification as $k => $v) {
  1874.                     $by_classification[$v] = array(
  1875.                         'classification' => $v,
  1876.                     );
  1877.                 }
  1878.             } else {
  1879.                 $by_classification[$classification] = array(
  1880.                     'classification' => $classification,
  1881.                 );
  1882.             }
  1883.         }
  1885.         if (!empty($items)) {
  1887.             // reourner uniquement le nb
  1888.             if (!empty($params_link['count_only'])) {
  1889.                 return $items;
  1890.             }
  1892.             // liste des texts
  1893.             foreach ($items as $k => $v) {
  1894.                 $idtext_list[] = $v['idtext'];
  1895.             }
  1897.             $texts = $this->getEntityManager()->getRepository(Texts::class);
  1898.             $params_sql = array(
  1899.                 'params' => array(
  1900.                     'where' => ' AND T1.idtext IN (' . join(',', $idtext_list) . ') ',
  1901.                     'limit' => array(0, 100)
  1902.                 )
  1903.             );
  1905.             if (!empty($params_link['order'])) {
  1906.                 $params_sql['params']['order'] = $params_link['order'];
  1907.             }
  1909.             $sql_texts = $texts->getSQLTexts($params_sql['params']);
  1910.             //$texts_list = $texts->getListTexts($params_sql);
  1912.             $texts->query($sql_texts);
  1914.             while ($texts->fetch($sql)) {
  1915.                 $text = $texts->getInfosTextRow($texts->idtext, $this->format_vignette);
  1916.                 $text['publisher_first'] = true;
  1917.                 $text['stylemore'] = $this->stylemore_text;
  1918.                 if (!empty($params['by_classification'])) {
  1919.                     foreach ($items as $item) {
  1920.                         if ($item['idtext'] == $texts->idtext) {
  1921.                             $by_classification[$item['idclassification']]['texts'][$texts->idtext] = $text;
  1922.                         }
  1923.                     }
  1924.                 } else {
  1925.                     $infos[$texts->idtext] = $text;
  1926.                 }
  1927.             }
  1929.             //print_r($by_classification);
  1930.             if (!empty($by_classification)) {
  1931.                 return $by_classification;
  1932.             } else {
  1933.                 //print_r($infos);
  1934.                 return $infos;
  1935.             }
  1937.         }
  1939.     }
  1941.     // }}}
  1943.     // {{{ countAuthors()
  1945.     /** Nombre de persons ayant au moins un texte original
  1946.      *
  1947.      * @param bool $sql_only On veut retourner la requête
  1948.      * @return int|string la valeur ou la requete
  1949.      */
  1950.     public function countAuthors($sql_only = false)
  1951.     {
  1953.         // compter avers getSQLPersons
  1954.         $params_sql = array(
  1955.             'limit' => 'all'
  1956.         );
  1957.         $params_special = array(
  1958.             'count_only' => true,
  1959.             'author' => true,
  1960.         );
  1961.         $sql = $this->getSQLPersons($params_sql, $params_special);
  1963.         if (!$sql_only) {
  1964.             return $this->queryOne($sql);
  1965.         } else {
  1966.             return $sql;
  1967.         }
  1969.     }
  1971.     // }}}
  1973.     // {{{ countDirectors()
  1975.     /** Nombre de persons ayant au moins mis en scène
  1976.      *
  1977.      * @param bool $sql_only On veut retourner la requête
  1978.      * @return int|string la valeur ou la requete
  1979.      */
  1980.     public function countDirectors($sql_only = false)
  1981.     {
  1982.         // compter avers getSQLPersons
  1983.         $params_sql = array(
  1984.             'limit' => 'all'
  1985.         );
  1986.         $params_special = array(
  1987.             'count_only' => true,
  1988.             'idrole' => 1,
  1989.         );
  1990.         $sql = $this->getSQLPersons($params_sql, $params_special);
  1992.         if (!$sql_only) {
  1993.             return $this->queryOne($sql);
  1994.         } else {
  1995.             return $sql;
  1996.         }
  1998.     }
  2000.     // }}}
  2002.     // {{{ countTranslators()
  2004.     /** Nombre de persons ayant au moins un texte traduit
  2005.      *
  2006.      * @param bool $sql_only On veut retourner la requête
  2007.      * @return int|string la valeur ou la requete
  2008.      */
  2009.     public function countTranslators($sql_only = false)
  2010.     {
  2012.         // compter avers getSQLPersons
  2013.         $params_sql = array(
  2014.             'limit' => 'all'
  2015.         );
  2016.         $params_special = array(
  2017.             'count_only' => true,
  2018.             'translator' => true,
  2019.         );
  2020.         $sql = $this->getSQLPersons($params_sql, $params_special);
  2022.         if (!$sql_only) {
  2023.             return $this->queryOne($sql);
  2024.         } else {
  2025.             return $sql;
  2026.         }
  2028.     }
  2030.     // }}}
  2032.     // {{{ countActors()
  2034.     /** Nombre de persons ayant au moins un joué un spectacle
  2035.      *
  2036.      * @param bool $sql_only On veut retourner la requête
  2037.      * @return int|string la valeur ou la requete
  2038.      */
  2039.     public function countActors($sql_only = false)
  2040.     {
  2042.         // compter avers getSQLPersons
  2043.         $params_sql = array(
  2044.             'limit' => 'all'
  2045.         );
  2046.         $params_special = array(
  2047.             'count_only' => true,
  2048.             'idrole' => 5,
  2049.         );
  2050.         $sql = $this->getSQLPersons($params_sql, $params_special);
  2052.         if (!$sql_only) {
  2053.             return $this->queryOne($sql);
  2054.         } else {
  2055.             return $sql;
  2056.         }
  2058.     }
  2060.     // }}}
  2062.     // {{{ countPersons()
  2064.     /** Nombre de persons
  2065.      *
  2066.      * @param bool $sql_only On veut retourner la requête
  2067.      * @param string $type On veut compter un type de personne en particulier
  2068.      * @return int|string la valeur ou la requete
  2069.      */
  2070.     public function countPersons($type = null, $sql_only = false)
  2071.     {
  2072.         if (!empty($type)) {
  2073.             $method_name = 'count' . ucfirst($type);
  2074.             if (method_exists($this, $method_name)) {
  2075.                 return $this->$method_name($sql_only);
  2076.             }
  2077.         } else {
  2078.             $sql = 'SELECT COUNT(*) as total FROM ' . $this->__table;
  2079.             $this->queryOne($sql);
  2080.         }
  2081.     }
  2083.     // }}}
  2085.     // {{{ setStylemoreText()
  2087.     /** Pour l'affichage des listes de texte
  2088.      *
  2089.      */
  2090.     public function setStylemoreText($stylemore_text)
  2091.     {
  2092.         $this->stylemore_text = $stylemore_text;
  2093.     }
  2095.     // }}}
  2097.     // {{{ setFormatVignette()
  2099.     /** Pour l'affichage des listes
  2100.      *
  2101.      */
  2102.     public function setFormatVignette($format_vignette)
  2103.     {
  2104.         $this->format_vignette = $format_vignette;
  2105.     }
  2107.     // }}}
  2109.     //  {{{ getAssociateContacts()
  2111.     /** Contacts aossociés à la personne
  2112.      *
  2113.      * @access  public
  2114.      * @param int $idperson identifiant de la personne
  2115.      * @param int $idoffice role (exemple : direction)
  2116.      * @param bool $actual_only uniquement les actuels  (contrainte sur la date)
  2117.      * @return  array
  2118.      */
  2119.     public function getAssociateContacts($idperson, $idoffice = null, $actual_only = null)
  2120.     {
  2122.         // infos sur la liaison
  2123.         $infos_link = $this->getRelationsArray('contact_person');
  2125.         // select egalement l'idrole
  2126.         if ($idoffice) {
  2127.             $infos_link['where'] = ' AND j2.idoffice=' . $idoffice;
  2128.         }
  2130.         // qui n'a pas fini son mandat
  2131.         if ($actual_only) {
  2132.             $infos_link['where'] .= ' AND (j2.date_end IS NULL OR j2.date_end>\'' . date('Y-m-d') . '\')';
  2133.         }
  2135.         // avec ou sans virgule avec le noPunct
  2136.         if (!empty($infos_link)) {
  2137.             return $this->noPunct($this->getLinkedObject($infos_link, $idperson, $infos_link['type'], 'persons'));
  2138.         }
  2140.     }
  2142.     // }}}
  2144.     //  {{{ getSexeValue()
  2146.     /** Trouver le sexe à partir de H/F
  2147.      *
  2148.      * @access  public
  2149.      * @param string $sexe sexe
  2150.      * @return  int
  2151.      */
  2152.     public function getSexeValue($sexe)
  2153.     {
  2155.         $sexes = array(
  2156.             'H' => 1,
  2157.             'F' => 2,
  2158.         );
  2160.         if (!empty($sexes[$sexe])) {
  2161.             return $sexes[$sexe];
  2162.         }
  2164.         return 0;
  2166.     }
  2168.     // }}}
  2170.     //  {{{ getPromos()
  2172.     /** Trouver les promos
  2173.      *
  2174.      * @access  public
  2175.      * @param array $params_sql
  2176.      * @return  array
  2177.      */
  2178.     public function getPromos($params_sql)
  2179.     {
  2180.         $conn = $this->getEntityManager();
  2182.         $params_sql['special']['person_ecole']['get_promos'] = true;
  2183.         $params_sql['dbg'] = array('get_promos', 'Les années de promos');
  2184.         $annees = $conn->getRepository(Persons::class)->getListPersons($params_sql);
  2185.         ksort($annees);
  2186.         return $annees;
  2187.     }
  2189.     // }}}
  2191.     //  {{{ getSpectacleRoles()
  2193.     /** Trouver les rôles joués par une personne dans un spectacle
  2194.      *
  2195.      * @access  public
  2196.      * @param int $idperson Identifiant personne
  2197.      * @return  array
  2198.      */
  2199.     public function getSpectacleRoles($idperson)
  2200.     {
  2201.         $sql = 'SELECT r.idrole, r.role, r.role_male, r.role_female, lg.fr
  2202.                 FROM
  2203.                     spectacle_person sp
  2204.                     JOIN roles r ON sp.idrole=r.idrole
  2205.                     JOIN langterms lg ON lg.id=r.role
  2206.                 WHERE sp.idperson=' . $idperson . '
  2207.                 GROUP BY r.idrole ';
  2209.         return $this->queryAll($sql);
  2210.     }
  2212.     // }}}
  2213. }