vendor/theatre/core/src/Repository/ContentsRepository.php line 563

Open in your IDE?
  1. <?php
  3. namespace TheatreCore\Repository;
  5. use TheatreCore\Classes\Images\Images;
  6. use TheatreCore\Entity\Classifications;
  7. use TheatreCore\Entity\Contents;
  8. use TheatreCore\Entity\Files;
  9. use TheatreCore\Entity\ObjectContent;
  10. use TheatreCore\Traits\TheatreTrait;
  11. use TheatreCore\Entity\Spectacles;
  12. use Doctrine\Bundle\DoctrineBundle\Repository\ServiceEntityRepository;
  13. use Doctrine\Persistence\ManagerRegistry;
  14. use Symfony\Contracts\Translation\TranslatorInterface;
  15. use Theatre_Extranetusers;
  17. /**
  18.  * ContentsRepository
  19.  *
  20.  * This class was generated by the Doctrine ORM. Add your own custom
  21.  * repository methods below.
  22.  */
  23. class ContentsRepository extends ServiceEntityRepository
  24. {
  25.     use TheatreTrait {
  26.         getItemsList as protected getItemsListTrait;
  27.     }
  29.     private $em;
  30.     public $__table;
  31.     public $__table_object;
  32.     public $__idtable;
  34.     private $translator;
  36.     public function __construct(ManagerRegistry $registry, TranslatorInterface $translator, Images $images)
  37.     {
  38.         parent::__construct($registry, Contents::class);
  39.         $this->__table = $this->getClassMetadata()->getTableName();
  40.         $this->__table_object = $this->getClassMetadata()->name;
  42.         $this->__idtable = $this->getClassMetadata()->getSingleIdentifierFieldName();
  44.         $this->setFields = $this->getClassMetadata()->getColumnNames();
  45.         $this->translator = $translator;
  47.         $this->images = $images;
  48. //        $this->__table = 'persons';
  49. //        $this->__table_object = '\\App\\Entity\\Persons';
  50.     }
  52.     //  {{{ getInfosContent()
  54.     /** Informations sur un contenu associe
  55.      *
  56.      * @access public
  57.      * @param int $idcontent identifiant du contenus associé
  58.      * @return array
  59.      */
  60.     public function getInfosContent($idcontent = null, $params = array())
  61.     {
  63.         $infos = array();
  65.         // selectionne aussi la classification
  66.         $sql = 'SELECT c.*, cl.classification, c.`range` as `range`, e.idextranetuser, e.login
  67.                 FROM ' . $this->__table . ' c
  68.                     LEFT JOIN extranetusers e ON c.idextranetuser=e.idextranetuser, classifications cl, content_classification cc
  69.                 WHERE cc.idcontent=c.idcontent AND cc.idclassification=cl.idclassification
  70.                 AND c.idcontent=' . ((int)$idcontent);
  72.         // restreindre à un extranetuser
  73.         /*if(!empty($params['idextranetuser'])) {
  75.         }*/
  77.         $infos = $this->queryRow($sql);
  79.         if (!empty($infos)) {
  81.             // est-ce qu'on converti le wiki en HTML ?
  82.             if (!empty($params['wiki_convert'])) {
  83.                 $infos['text'] = $this->wikiTransform($infos['text'], $infos['markdown']);
  84.                 $infos['deck'] = $this->wikiTransform($infos['deck'], $infos['markdown']);
  85.             }
  87.             // est-ce qu'on récup aussi les fichiers
  88.             if (!empty($params['get_files'])) {
  89.                 $datafile = $this->getAssociateFileContent($idcontent);
  90.                 if (!empty($datafile)) {
  91.                     $infos['files'] = $datafile;
  92.                 }
  93.             }
  95.             // selectionne éalement le journaliste associé et le journal et les contacts associes
  96.             foreach (array('idcontact_journalist', 'idcontact_newspaper') as $f) {
  97.                 if (!empty($infos[$f])) {
  98.                     $infos[$f] = $this->getLinkedContact($infos['idcontent'], $f);
  99.                 }
  100.             }
  102.             // contact signature
  103.             $infos['idcontact'] = $this->getLinkedContact($infos['idcontent'], 'idcontact');
  105.             $infos['idperson'] = $this->getLinkedPerson($infos['idcontent'], 'content_person');
  107.             // selectionne aussi la/les classification(s)
  108.             $classifications_list = $this->getClassifications($idcontent);
  110.             if (!empty($classifications_list)) {
  111.                 $infos['classifications'] = $classifications_list;
  112.                 $infos['classification_code'] = $infos['classification'];
  113.                 $infos['classification'] = $this->translator->trans($infos['classification']);
  114.             }
  116.             // récupèrer les infos sur l'extranetuser
  117.             if (!empty($infos['login'])) {
  118.                 $infos['extranetuser'] = array(
  119.                     'login' => $infos['login'],
  120.                     'idextranetuser' => $infos['idextranetuser'],
  121.                 );
  122.             }
  124.         }
  126.         // langue
  127.         if (!empty($infos['language'])) {
  128.             $infos['language_string'] = $this->getNameLanguage($infos['language']);
  129.         }
  131.         return $infos;
  132.     }
  134.     // }}}
  136.     //  {{{ getInfosObject()
  138.     /** Alias de getInfosContent
  139.      *
  140.      * @access  public
  141.      * @param int $idobject identifiant
  142.      * @return  array
  143.      * @see     getInfosObject()
  144.      */
  145.     public function getInfosObject($idobject = null)
  146.     {
  147.         return $this->getInfosContent($idobject);
  148.     }
  150.     // }}}
  152.     //  {{{ addContent()
  154.     /** Ajoute un contenu et l'associe si besoin
  155.      *
  156.      *
  157.      * @access   public
  158.      * @param string $objet le type d'objet à insérer (personnes, spectacles...)
  159.      * @param string $idobject (id de l'utilisateur pour le nom de son répertoire)
  160.      * @param string $idcontent (id du contenu à modifier si on est en mode modification)
  161.      * @param string $sort classement
  162.      */
  163.     public function addContent($object, $idobject, $idcontent = null, $sort = 0, $classifications = array(), $return_value = false, $group_idclassification = null, $values = null)
  164.     {
  166.         /**
  167.          * En modification, on doit verifier que le contenu ne soit pas deja utilise
  168.          * si il est utilise, on doit juste supprimer la relation
  169.          */
  170.         $em = $this->getEntityManager();
  172.         $content = null;
  173.         if (!is_null($idcontent)) {
  174.             $content = $em->getRepository(Contents::class)->find($idcontent);
  175.         }
  177.         if ($content) {
  178.             if ($x = $em->getRepository(ObjectContent::class)->findBy(['idcontent' => $content])) {
  179.                 // si associe a quelque chose d'autre
  180. //            if($this->isUseObjectContent($idcontent)) {
  181. //                $id = null;
  182.                 // supression de la relation dans object_content
  183.                 $this->deleteDataRelation('object_content', 'idcontent', $idcontent, 'idobject', $idobject, 'object', $object);
  184.                 // creation d'un nouveau contenu
  186.                 $newidcontent = $this->setData($idcontent, true);
  187.             } else {
  188.                 // modification simple
  189.                 if ($return_value) {
  190.                     $this->setData($idcontent);
  191.                     return $idcontent;
  192.                 } else {
  193.                     // mettre à jour le classement/groupement dans object_content si nécessaire
  194.                     $object_content = $this->getEntityManager()->getRepository(ObjectContent::class);
  195.                     // ajout dans object_content
  196.                     $object_content->setUpdateFields(array(
  197.                         'idclassification' => $group_idclassification
  198.                     ));
  199.                     $object_content->setData(null, false, true, 'idobject=' . $idobject . ' AND idcontent=' . $idcontent . ' AND object=\'' . $object . '\' ');
  200.                     return $this->setData($idcontent);
  201.                 }
  202.             }
  203.         } else { // creation
  204.             $newidcontent = $this->setData($idcontent, true);
  205.         }
  207.         // ajout dans object_content si nouveau contenu
  208.         if (isset($newidcontent)) {
  210.             $idcontent = $newidcontent;
  212.             $content_created = $this->find($idcontent);
  214.             //objet dans la table object_content
  215.             $object_content = new ObjectContent();
  217.             // ajout dans object_content
  218.             $object_content->setIdobject($idobject);
  219.             $object_content->setObject($object);
  220.             $object_content->setIdcontent($content_created);
  221.             $object_content->setRange($sort);
  222.             $object_content->setIdclassification($group_idclassification);
  224.             // ajout dans object_content
  225.             try {
  227.                 $em->persist($object_content);
  228.                 $em->flush();
  230.             } catch (Exception $e) {
  232.                 $em->getConnection()->rollBack();
  233.                 throw $e;
  235.             }
  237.         }
  239.         // ajouter aussi les classifications ?
  240.         if (!empty($classifications)) {
  241.             foreach ($classifications as $class) {
  242.                 $class_tab[$idcontent] = $class;
  243.             }
  244.             try {
  245.                 $this->setRelationSelect('content_classification', 'idclassification', 'idcontent', $class_tab, $idcontent);
  246.             } catch (\Exception $e) {
  247.                 return $e->getError();
  248.             }
  249.         }
  251.         //retourner l'idcontent du contenu
  252.         return $idcontent;
  254.     }
  256.     // }}}
  258.     //  {{{ setRelationSelectObject()
  260.     /** Enregistrement dans les table relationnelle avec object
  261.      *
  262.      * Permet l'enregistrement multiple de valeur dans les tables
  263.      * de relation avec object
  264.      *
  265.      * @access   public
  266.      * @param string $table Nom de la table de relation
  267.      * @param string $key Clé dans le tableau
  268.      * @param string $col Colonne
  269.      * @param array $array_values Valeur à enregistrer
  270.      * @param int $id Id de l'enregistrement principal
  271.      * @param string $object Nom de l'objet
  272.      * @return   bool
  273.      */
  274.     public function setRelationSelectObject($table, $key, $col, $array_values, $id, $object, $allRights = true, $group_idclassification = null)
  275.     {
  276. //        $this->setOption('quote_identifier', false);
  277.         $em = $this->getEntityManager()->getConnection();
  279.         if ($allRights) {
  280.             $rights = array('update' => 1);
  281.         }
  283.         if ($this->isCheckRights() || !$allRights) {
  284.             $extranetusers = Theatre_Extranetusers::factory('extranetusers');
  285.             $rights = $extranetusers->getRights();
  286.         }
  288.         if (isset($rights) && $rights['update'] == 1) {
  290.             // on supprime puis on insère (replace ne marche pas)
  291.             $sql_del = 'DELETE FROM ' . $table . ' WHERE ' . $key . '=\'' . $id . '\' AND object=\'' . $this->escape($object) . '\'';
  292.             $this->logDeletion('[Contents::setRelationSelectObject] Supprime de relations ' . $sql_del);
  295.             $em->exec($sql_del);
  297.             // si array_values est vide, c'est qu'on veux supprimer ?
  298.             if (empty($array_values)) {
  299.                 return true;
  300.             }
  302.             // on prepare
  303.             if (!empty($group_idclassification)) {
  304.                 $sql = 'INSERT INTO ' . $table . ' (' . $key . ', object, ' . $col . ', idclassification) VALUES (?, ?, ?, ?)';
  305.             } else {
  306.                 $sql = 'INSERT INTO ' . $table . ' (' . $key . ', object, ' . $col . ') VALUES (?, ?, ?)';
  307.             }
  308.             $prep = $em->prepare($sql);
  310.             foreach ($array_values as $key => $value) {
  311.                 if (!empty($group_idclassification)) {
  312.                     $prep_values[] = array($id, $object, $value, $group_idclassification);
  313.                 } else {
  314.                     $prep_values[] = array($id, $object, $value);
  315.                 }
  316.             }
  318.             foreach ($prep_values as $value) {
  319.                 $res = $prep->execute($value);
  320.             }
  322.         } else {
  323.             throw new \Exception($this->translator->trans('no_right') . 'setRelationSelectObject');
  324.         }
  326.     }
  328.     // }}}
  330.     //  {{{ deleteContent()
  332.     /** Supprimer un contenu
  333.      *
  334.      * On verifie que le contenu est utilise et on supprime
  335.      * la liaison et le contenu si plus utilise
  336.      *
  337.      * @access   public
  338.      * @param string $id id du contentu à supprimer
  339.      * @param string $object type de fichier à supprimer (ex : persons, contacts...)
  340.      * @param string $idobject id de la personne qui possède le fichier
  341.      */
  342.     public function deleteContent($id, $object, $idobject)
  343.     {
  344.         //le contenu n'est pas utilisé, on peut le supprimer
  345.         if (!$this->isUseContent($id)) {
  346.             return $this->deleteData($id);
  347.         }
  349.         //dans touts les cas, supprimer l'enregistrement dans la relation object_file
  350.         return $this->deleteDataRelation('object_content', 'idcontent', $id, 'idobject', $idobject, 'object', $object);
  352.     }
  354.     // }}}
  356.     //  {{{ isUseContent()
  358.     /** Vérifier si un contenu est utilisé par un autre objet
  359.      *
  360.      *
  361.      * @access   public
  362.      * @param string $id id du contenu à vérifier
  363.      */
  364.     public function isUseContent($idcontent)
  365.     {
  367.         $sql = 'SELECT COUNT(DISTINCT(idobject)) AS total
  368.                 FROM object_content
  369.                 WHERE object_content.idcontent=' . (int)$idcontent;
  371.         $total = $this->queryOne($sql);
  373.         //on a au moins 2 enregistrements liés
  374.         return ($total > 1);
  376.     }
  378.     // }}}
  380.     //  {{{ countAssociateContent()
  382.     /** compter les contenus associes par type
  383.      *
  384.      * @access   public
  385.      * @param string|int|array $classification classification recherchee
  386.      * @param int $idobject id de l'objet lié
  387.      * @param string $objet le type d'objet (personnes, spectacles...)
  388.      * @return   array
  389.      * @see Theatre_Classifications::getAssociate())
  390.      */
  391.     public function countAssociateContent($object, $idobject, $classification, $extra = array())
  392.     {
  393.         // string ou int pour classification
  394.         $con = $this->getEntityManager();
  395.         $classifications = $con->getRepository(Classifications::class);
  397.         if (!empty($extra['publish_status'])) {
  398.             $classifications->setPublishStatus($extra['publish_status']);
  399.         } else {
  400.             $classifications->setPublishStatus($this->publish_status);
  401.         }
  402.         return $classifications->getAssociate($idobject, $object, $classification, false, $extra);
  403.     }
  405.     // }}}
  407.     //  {{{ getAssociateContents()
  409.     /** Retourner les contenus lies a un objet
  410.      *
  411.      * Retourne un tableau associatif des contenus associes
  412.      * a un objet
  413.      *
  414.      * @access   public
  415.      * @param string $idobject id de l'objet lié
  416.      * @param string $objet le type d'objet (personnes, spectacles...)
  417.      * @param int|string|array $classification classification(s)
  418.      * @param string $params parametre (no_by_lang => 'pas de classement par langue', 'get_files' => demander également les fichiers)
  419.      * @see Theatre_Classifications::getAssociate())
  420.      */
  421.     public function getAssociateContents($idobject, $object, $classification = null, $params = array())
  422.     {
  424.         if (!empty($params['group_content'])) {
  425.             $fields = 'DISTINCT(c.idcontent)';
  426.         } else {
  427.             $fields = 'c.idcontent';
  428.         }
  430.         $fields .= ', c.idextranetuser, c.publish, c.title, c.language, oc.object, oc.idobject, l.fr';
  432.         // récupèrer aussi les texts
  433.         if (!empty($params['get_texts'])) {
  434.             $fields .= ', c.text, c.deck,c.dateinsert';
  435.         }
  437.         //if(!empty($classification)) {
  438.         $fields .= ', cl.classification';
  439.         //}
  441.         $extra = array(
  442.             'tables' => ',languages l',
  443.             'where' => 'AND c.language=l.id',
  444.             'order' => 'c.language,cc.idclassification,c.dateinsert',
  445.         );
  447.         // on exclut certains con
  448.         if (!empty($params['exclude_contents'])) {
  449.             $extra['where'] .= ' AND c.idcontent NOT IN(' . implode(',', $params['exclude_contents']) . ')';
  450.         }
  452.         if (!empty($params['group_content'])) {
  453.             $extra['group_content'] = true;
  454.         }
  456.         $classifications = $this->getEntityManager()->getRepository(Classifications::class);
  457.         $classifications->setPublishStatus($this->publish_status);
  459.         $tabcontent = $classifications->getAssociate($idobject, $object, $classification, $fields, $extra);
  461.         // si il y a des resultat
  462.         if (!empty($tabcontent)) {
  464.             // objet traduction
  465.             $tr = $this->translator;
  467.             // classement par langue
  468.             if (empty($params['no_by_lang'])) {
  470.                 // liste des langues
  471.                 $sql_lng = 'SELECT c.language
  472.                                FROM object_content oc, contents c
  473.                                WHERE oc.idcontent=c.idcontent
  474.                                AND oc.idobject=\'' . $idobject . '\'
  475.                                AND oc.object=\'' . $object . '\'
  476.                                GROUP BY c.language ORDER BY c.language';
  478.                 $languages = $this->queryAll($sql_lng);
  480.                 // valeurs
  481.                 foreach ($languages as $k => $v) {
  482.                     foreach ($tabcontent as $key => $value) {
  483.                         if ($tabcontent[$key]['language'] == $v['language']) {
  485.                             // si text
  486.                             if (!empty($value['text'])) {
  487.                                 $tabcontent[$key]['text'] = $this->wikiTransform($value['text'], $value['markdown']);
  488.                             }
  490.                             $tabcontent[$key]['classification'] = $tr->trans($value['classification']);
  491.                             $tabcontent[$key]['key_classification'] = $value['classification'];
  492.                             $tabcontent[$key]['language_term'] = $tabcontent[$key]['fr'];
  494.                             if ($idobject == 3 && $value['classification'] == 'class_journal') {
  495.                                 $tabcontent[$key]['is_collapse'] = 'display: none;';
  496.                             }
  498.                             // est-ce qu'on récup aussi les fichiers
  499.                             if (!empty($params['get_files']) && array_key_exists('idcontent', $value)) {
  500.                                 $tabcontent[$key]['files'] = $this->getAssociateFileContent($value['idcontent']);
  501.                             }
  503.                             if (!empty($params['api'])) {
  504.                                 $tabcontent[$key] = $this->getApiTab($tabcontent[$key]);
  505.                             }
  507.                             $tabbylang[$v['language']][] = $tabcontent[$key];
  509.                         }
  510.                     }
  511.                 }
  513.                 return $tabbylang;
  515.             } else {
  516.                 foreach ($tabcontent as $key => $value) {
  518.                     $tabcontent[$key]['classification'] = $tr->trans($value['classification']);
  519.                     $tabcontent[$key]['key_classification'] = $value['classification'];
  521.                     // est-ce qu'on récup aussi les fichiers
  522.                     if (!empty($params['get_files']) && array_key_exists('idcontent', $value)) {
  523.                         $tabcontent[$key]['files'] = $this->getAssociateFileContent($value['idcontent']);
  524.                     }
  526.                 }
  528.                 return $tabcontent;
  530.             }
  532.         } else {
  533.             return null;
  534.         }
  536.     }
  538.     // }}}
  540.     //  {{{ getAssociateContent()
  542.     /** Recuperer un contenu associe
  543.      *
  544.      * Recuperer les infos sur un seul contenu associe
  545.      *
  546.      * @access   public
  547.      * @param int $idobject id de l'objet lié
  548.      * @param string $objet le type d'objet (personnes, spectacles...)
  549.      * @param string|int|array $classification classification recherchee
  550.      * @param array $params_content options supplémentaires (media=>true|false, check_lng=>true|false, wiki_convert=>true|false,get_files=>true|false)
  551.      * @return   array
  552.      * @see Theatre_Classifications::getAssociate())
  553.      */
  554.     public function getAssociateContent($idobject, $object, $classification, $params_content = array())
  555.     {
  556.         $params_content['row'] = true;
  558.         // string ou int pour classification
  560.         $conn = $this->getEntityManager();
  561.         $classifications = $conn->getRepository(Classifications::class);
  562.         $classifications->setPublishStatus($this->publish_status);
  563.         $data = $classifications->getAssociate($idobject, $object, $classification, '*', $params_content);
  565.         if (!empty($data)) {
  567.             // les classifications
  568.             $classifications_list = $classifications->getObjectClassification($this->__table, $data['idcontent'], $this->getRelationsArray('content_classification'));
  569.             $data['classifications'] = $classifications_list;
  571.             // est-ce qu'on converti le wiki en HTML ?
  572.             if (!empty($params_content['wiki_convert']) && !empty($data['text'])) {
  573.                 $data['text'] = $this->wikiTransform($data['text'], $data['markdown']);
  574.             }
  576.             // est-ce qu'on récup aussi les fichiers
  577.             if (!empty($params_content['get_files'])) {
  578.                 if (array_key_exists('idcontent', $data)) {
  579.                     $datafile = $this->getAssociateFileContent($data['idcontent']);
  580.                     if (!empty($datafile)) {
  581.                         $data['files'] = $datafile;
  582.                     }
  583.                 }
  584.             }
  586.             if (!empty($data['dateinsert'])) {
  587.                 $data['dateinsert_lng'] = $this->getFormeDate($data['dateinsert'], "%A %d %B %Y", true);
  588.                 $data['dateinsert_lng_withtout_day'] = $this->getFormeDate($data['dateinsert'], "%d %B %Y", true);
  589.             }
  591.             if (!empty($data['dateupdate'])) {
  592.                 $data['dateupdate_lng'] = $this->getFormeDate($data['dateupdate'], "%A %d %B %Y", true);
  593.                 $data['dateupdate_lng_without_day'] = $this->getFormeDate($data['dateupdate'], "%d %B %Y", true);
  594.             }
  596.             //retourner le contenu
  597.             return $data;
  598.         }
  600.         return null;
  601.     }
  603.     // }}}
  605.     //  {{{ getMultimediaContents()
  607.     /** Recuperer les contenus associes qui ont un doc multimedia
  608.      *
  609.      *
  610.      * @access   public
  611.      * @param int $idobject id de l'objet lié
  612.      * @param string $objet le type d'objet (personnes, spectacles...)
  613.      * @param int|string|array $classification classification(s) (par défaut: toutes)
  614.      * @return   array
  615.      * @see Theatre_Classifications::getAssociate())
  616.      */
  617.     public function getMultimediaContents($idobject, $object, $classification = null)
  618.     {
  619.         $fields = 'c.idcontent, c.title, om.idmultimedia, cl.classification, cc.idclassification';
  620.         $extra = array(
  621.             'tables' => ',object_multimedia om',
  622.             'where' => 'AND c.idcontent=om.idobject AND om.object=\'contents\'',
  623.         );
  624.         $classifications = $this->getEntityManager()->getRepository(Classifications::class);
  625.         $classifications->setPublishStatus($this->publish_status);
  626.         $tabcontent = $classifications->getAssociate($idobject, $object, $classification, $fields, $extra);
  628.         //retourner les contenus
  629.         if (!empty($tabcontent)) {
  630.             foreach ($tabcontent as $k => $v) {
  631.                 $tabcontent[$k]['classification'] = $this->translator->trans($v['classification']);
  632.             }
  633.             return $tabcontent;
  634.         }
  636.         return null;
  637.     }
  639.     // }}}
  641.     //  {{{ getMoreAssociateContent()
  643.     /** Recuperer des contenus associes
  644.      *
  645.      *
  646.      * @access   public
  647.      * @param int $idobject id de l'objet lié
  648.      * @param string $objet le type d'objet (personnes, spectacles...)
  649.      * @param int|string|array $classification classification recherchee
  650.      * @return   array
  651.      * @see Theatre_Classifications::getAssociate())
  652.      */
  653.     public function getMoreAssociateContent($idobject, $object, $classification, $media = false, $extra = array())
  654.     {
  655.         $fields = '*';
  656.         $extra['media'] = $media;
  658.         $conn = $this->getEntityManager();
  660.         $classifications = $conn->getRepository(Classifications::class);
  661.         $classifications->setPublishStatus($this->publish_status);
  662.         $tabcontent = $classifications->getAssociate($idobject, $object, $classification, $fields, $extra);
  664.         //retourner les contenus
  665.         if (!empty($tabcontent)) {
  666.             return $tabcontent;
  667.         }
  669.         return null;
  670.     }
  672.     // }}}
  674.     //  {{{ getAssociateFileContent()
  676.     /** Recuperer les fichiers associes a un contenu
  677.      *
  678.      *
  679.      * @access   public
  680.      * @param int $idobject id de l'objet lié
  681.      * @param string $object type d'objet
  682.      * @param string|int|array $classification classification recherchee
  683.      * @return   array
  684.      * @see Theatre_Classifications::getAssociate())
  685.      */
  686.     public function getAssociateFileContent($idobject, $object = 'contents', $classification = null)
  687.     {
  689.         $conn = $this->getEntityManager();
  691.         $files = $conn->getRepository(Files::class);
  692.         $files->setPublishStatus($this->publish_status);
  693.         $infos_files = $files->getObjectFiles($idobject, $object, $classification);
  695.         return $infos_files;
  696.     }
  698.     // }}}
  700.     //  {{{ getObjectTitle()
  702.     /** Infos sur l'item recherche
  703.      *
  704.      * Affichage 'standard' du titre de l'item
  705.      *
  706.      * @access  public
  707.      * @param int $idobject Identifiant de l'item
  708.      * @param array $infos_object Informations pour construire le titre
  709.      * @param array $params Paramétres supplémentaires
  710.      * @return  string
  711.      */
  712.     public function getObjectTitle($idobject = null, $infos_object = array(), $params = array())
  713.     {
  714.         $title = '';
  716.         if (!$idobject) {
  717.             $idobject = $this->idcontent;
  718.         }
  720.         // champs
  721.         $fields = array('idcontent', 'title', 'idclassification');
  723.         if (!empty($infos_object)) {
  725.             foreach ($fields as $k => $v) {
  726.                 if (array_key_exists($v, $infos_object)) {
  727.                     $$v = $infos_object[$v];
  728.                 } else {
  729.                     $$v = '';
  730.                 }
  731.             }
  733.         } else {
  735.             //charger les infos que si necessaire
  736.             if (empty($this->idclassification)) {
  738.                 $sql = 'SELECT c.idcontent,c.title,cc.idclassification
  739.                         FROM contents c, content_classification cc
  740.                         WHERE cc.idcontent=c.idcontent AND c.idcontent=' . (int)$idobject;
  742.                 $data = $this->queryRow($sql);
  743.             }
  745.             foreach ($fields as $k => $v) {
  746.                 if (!empty($data[$v])) {
  747.                     $$v = trim($data[$v]);
  748.                 } else {
  749.                     $$v = '';
  750.                 }
  751.             }
  753.         }
  755.         if (empty($idclassification)) {
  756.             //error_log('Classification non trouvée'."\n".debug_string_backtrace());
  757.             return $title;
  758.         }
  760.         $query = 'SELECT cl.classification FROM classifications cl WHERE cl.idclassification=' . (int)$idclassification;
  762.         $classification = $this->queryOne($query);
  763.         $classification = $this->translator->trans($classification);
  765.         return $title . ' / ' . $classification;
  767.     }
  769.     // }}}
  771.     //  {{{ getIllustrations()
  773.     /** Récupère les illustrations
  774.      *
  775.      * Affiche pour les spectacles, couverture pour les textes
  776.      *
  777.      * @access  public
  778.      * @param int $idobject id de l'objet lié
  779.      * @param string $object type d'objet
  780.      * @param string|int|array $classification classification recherchee
  781.      * @return   array
  782.      * @see getAssociateFileContent()
  783.      */
  784.     public function getIllustrations($idobject, $object, $classification, $format = array())
  785.     {
  787.         // recuperer la couv
  788.         $illustrations = $this->getAssociateFileContent($idobject, $object, $classification);
  790.         $tab_illustrations = array();
  792.         if (!empty($illustrations)) {
  794.             // vignettes des illustrations
  795.             foreach ($illustrations as $k => $illustration) {
  796.                 $illustrations[$k]['vignette'] = $this->getThumbnail($illustrations[$k]['file'], 255, 'L');
  797.                 $illustrations[$k]['vignette_flou'] = $this->getThumbnail($illustrations[$k]['file'], 255, 'L', ['blur' => true]);
  798.             }
  799.             $tab_illustrations['illustrations'] = $illustrations;
  801.             // insctancier l'objet lié et trouver la méthode getVignetteObject
  802.             $obj = $this->getEntityManager()->getRepository('TheatreCore\Entity\\' . ucfirst($object));
  803.             $methode = 'getVignette' . ucfirst(substr($object, 0, -1));
  804.             if (method_exists($obj, $methode)) {
  805.                 $vignette = $obj->$methode($idobject, $format);
  806.                 if (!preg_match('/-def\.jpg$/', $vignette)) {
  807.                     $tab_illustrations['vignette_object'] = $vignette;
  808.                 }
  809.             }
  811.         }
  813.         return $tab_illustrations;
  815.     }
  817.     // }}}
  819.     //  {{{ getListSearch()
  821.     /** Liste des contenus associés
  822.      *
  823.      * Pour les champs Ajax de relations et les recherches diverses
  824.      *
  825.      * @access  public
  826.      * @param string $lettres Pour la recherche alphabetique
  827.      * @param string $type Pour le type recherche (editeurs, revues...)
  828.      * @param string $keywords Recherche par mots cles
  829.      * @return  array
  830.      */
  831.     public function getListSearch($lettre = null, $type = null, $keywords = null, $only = null)
  832.     {
  834.         $qb = $this->createQueryBuilder('c');
  835.         $qb->select('c')
  836.             ->orderBy('c.dateArticle', 'ASC');
  838.         return $qb;
  840.         // titre, classification
  841.         $sql = 'SELECT c.idcontent, c.title, cl.classification
  842.                 FROM contents c, classifications cl, content_classification cc
  843.                 WHERE cc.idclassification=cl.idclassification AND c.idcontent=cc.idcontent';
  845.         // par lettre
  846.         if (!empty($lettre)) {
  847.             $sql .= ' AND LOWER(LEFT(LTRIM(c.title),1))=\'' . $this->escape($lettre) . '\'';
  848.         }
  850.         // recherche avec un mot cle
  851.         $list = $this->splitKeywords($keywords);
  852.         if ($list) {
  853.             $subsql = '';
  854.             if (!empty($list[$this->IDSTR])) {
  855.                 // mots clés
  856.                 foreach ($list[$this->IDSTR] as $s) {
  857.                     if ($subsql) $subsql .= ' AND ';
  858.                     $subsql .= 'c.title LIKE \'%' . $s . '%\'';
  859.                 }
  860.             }
  861.             if (!empty($list[$this->IDNUM])) {
  862.                 // recherche par numéro d'id pour les mots clés numériques
  863.                 if ($subsql) $subsql .= ' OR ';
  864.                 $subsql .= 'c.idcontent IN (' . implode(',', $list[$this->IDNUM]) . ')';
  865.             }
  866.             if ($subsql) $sql .= ' AND (' . $subsql . ')';
  867.         }
  869.         $this->query($sql);
  871.         $r = array();
  873.         while ($this->fetch()) {
  874.             $r[$this->idcontent] = $this->title . ' (' . $this->translator->trans($this->classification) . ')';
  875.             // si trouvé par id, on l'affiche en fin de titre
  876.             if (!empty($list[$this->IDNUM]) && in_array($this->idcontent, $list[$this->IDNUM])) {
  877.                 $r[$this->idcontent] .= ' - n°' . $this->idcontent;
  878.             }
  879.         }
  881.         $this->free();
  882.         return $r;
  884.     }
  886.     // }}}
  888.     //  {{{ getRelationsArray()
  890.     /** Tableau des relations
  891.      *
  892.      * @access  public
  893.      * @param string|int $type le type de champ
  894.      */
  895.     public function getRelationsArray($type = null)
  896.     {
  898.         $array_types = array(
  899.             'multimedia_content' => array(// documents multimedia associés
  900.                 'type_join' => 'method',
  901.                 'method' => 'getMultimediaList',
  902.                 /*'type_join' => 'multiple',
  903.                 'dest_table' => 'multimedias',
  904.                 'join_table' => 'multimedia_content',
  905.                 'fields' => array('idmultimedia','sujet_titre','url_clean'),*/
  906.             ),
  907.             'object_multimedia' => array(// documents multimedia associés
  908.                 'type_join' => 'multiple',
  909.                 'dest_table' => 'multimedias',
  910.                 'join_table' => 'object_multimedia',
  911.                 'fields' => array('idmultimedia', 'sujet_titre', 'url_clean'),
  912.             ),
  913.             'idcontact_newspaper' => array(// journal associé
  914.                 'type_join' => 'simple',
  915.                 'dest_table' => 'contacts',
  916.                 'join_field_src' => 'idcontact_newspaper',
  917.                 'fields' => array('idcontact', 'organisation', 'url', 'type'),
  918.             ),
  919.             'idcontact_journalist' => array(// journaliste associé
  920.                 'type_join' => 'simple',
  921.                 'dest_table' => 'contacts',
  922.                 'join_field_src' => 'idcontact_journalist',
  923.                 'fields' => array('idcontact', 'organisation', 'lastname', 'firstname', 'type'),
  924.             ),
  925.             'idcontact' => array(// contact associé
  926.                 'type_join' => 'multiple',
  927.                 'dest_table' => 'contacts',
  928.                 'join_table' => 'content_contact',
  929. //                'join_field_src' => 'idcontact',
  930. //                'join_field_dest' => 'contact_idcontact',
  931.                 'fields' => array('idcontact', 'organisation', 'url', 'type', 'city'),
  932.             ),
  933.             'content_contact' => array(// contacts associés
  934.                 'type_join' => 'multiple',
  935.                 'dest_table' => 'contacts',
  936.                 'join_table' => 'content_contact',
  937.                 'fields' => array('idcontact', 'organisation', 'lastname', 'firstname', 'type'),
  938.             ),
  939.             'content_person' => array(// persons associés
  940.                 'type_join' => 'multiple',
  941.                 'dest_table' => 'persons',
  942.                 'join_table' => 'content_person',
  943.                 'fields' => array('idperson', 'lastname', 'firstname'),
  944.             ),
  945.             'content_classification' => array(// classifications associées
  946.                 'type_join' => 'multiple',
  947.                 'dest_table' => 'classifications',
  948.                 'join_table' => 'content_classification',
  949.                 'fields' => array('idclassification', 'classification', 'type', 'idgroupclassification'),
  950.             ),
  951.             'content_publisher' => array(// classifications associées
  952.                 'type_join' => 'multiple',
  953.                 'dest_table' => 'contacts',
  954.                 'join_table' => 'content_publisher',
  955.                 'join_field_dest' => 'idcontact',
  956.                 'fields' => array('idcontact', 'organisation', 'lastname', 'firstname', 'type'),
  957.             ),
  958.             'content_content' => array(// contenus associés
  959.                 'type_join' => 'multiple',
  960.                 'dest_table' => 'contents',
  961.                 'join_table' => 'object_content',
  962.                 'fields' => array('idcontent', 'title', 'dateinsert'),
  963.             ),
  964.             'content_template' => array(// classifications associées
  965.                 'type_join' => 'multiple',
  966.                 'dest_table' => 'templates',
  967.                 'join_table' => 'content_template',
  968.                 'fields' => array('idtemplate', 'description', 'fichier'),
  969.             ),
  970.             /*'object_content' => array(// classifications associées
  971.                 'type_join' => 'multiple',
  972.                 'dest_table' => 'content',
  973.                 'join_table' => 'object_content',
  974.                 'fields' => array('idcontent','title','subtitle'),
  975.             ),*/
  976.         );
  978.         if (!empty($array_types[$type])) {
  979.             $array_types[$type]['type'] = $type;
  980.             return $array_types[$type];
  981.         } else {
  982.             return $array_types;
  984.         }
  986.     }
  988.     // }}}
  990.     //  {{{ getLinkedPerson()
  992.     /** Tableau des relations pour les biographies
  993.      *
  994.      * @access  public
  995.      * @param string|int $type le type de champ
  996.      */
  997.     public function getLinkedPerson($idcontent, $type, $type_value = null, $infos_link = array())
  998.     {
  999.         $conn = $this->getEntityManager();
  1001.         if (empty($infos_link)) {
  1002.             $infos_link = $this->getRelationsArray($type);
  1003.         }
  1005.         $infos_linked_obj = $this->getLinkedObject($infos_link, $idcontent, $type, 'contents');
  1007.         return $infos_linked_obj;
  1009.     }
  1011.     // }}}
  1013.     //  {{{ getLinkedContact()
  1015.     /** Tableau des relations
  1016.      *
  1017.      * @access  public
  1018.      * @param string|int $type le type de champ
  1019.      */
  1020.     public function getLinkedContact($idcontent, $type, $type_value = null, $infos_link = array())
  1021.     {
  1022.         $conn = $this->getEntityManager();
  1024.         if (empty($infos_link)) {
  1025.             $infos_link = $this->getRelationsArray($type);
  1026.         }
  1028.         $infos_linked_obj = $this->getLinkedObject($infos_link, $idcontent, $type, 'contents');
  1030.         foreach ($infos_linked_obj as $k => $v) {
  1032.             // on veux également le logo
  1033.             $files = $conn->getRepository(Files::class);
  1034.             $logos = $files->getObjectFiles($v['idcontact'], 'contacts', 'class_logo_normal');
  1035.             if (empty($logos)) {
  1036.                 $logos = $files->getObjectFiles($v['idcontact'], 'contacts', 'class_logo_accueil');
  1037.             }
  1038.             if (!empty($logos)) {
  1039.                 $logos[0]['vignette'] = $this->getThumbnail($logos[0]['file'], 100, 'thumb');
  1040.                 $logos[0]['vignette_flou'] = $this->getThumbnail($logos[0]['file'], 100, 'thumb', ['blur' => true]);
  1041.                 $logos[0]['vignette_moyenne'] = $this->getThumbnail($logos[0]['file'], 200, 'thumb');
  1042.                 $logos[0]['vignette_moyenne_flou'] = $this->getThumbnail($logos[0]['file'], 200, 'thumb', ['blur' => true]);
  1044.                 $infos_linked_obj[$k]['logo'] = $logos[0];
  1045.             }
  1046.         }
  1048.         return $infos_linked_obj;
  1050.     }
  1052.     // }}}
  1054.     //  {{{ getAssociateObjects()
  1056.     /** Liste des objets associés au contenus par type à partir de l'id du contenu
  1057.      *
  1058.      * @access  public
  1059.      * @param string|int $type le type de champ
  1060.      */
  1061.     public function getAssociateObjects($idcontent, $object)
  1062.     {
  1064.         $sql = 'SELECT * FROM object_content WHERE 1 ';
  1066.         // préciser le type d'objet
  1067.         if (!empty($object)) {
  1068.             $sql .= ' AND object=\'' . $object . '\' ';
  1069.         }
  1071.         // préciser le contenu
  1072.         if (!empty($idcontent)) {
  1073.             if (is_array($idcontent)) {
  1074.                 $sql .= ' AND idcontent IN (' . join(',', $idcontent) . ') ';
  1075.             } else {
  1076.                 $sql .= ' AND idcontent=' . ((int)$idcontent) . ' ';
  1077.             }
  1078.         }
  1080.         return $this->queryAll($sql);
  1083.     }
  1085.     // }}}
  1087.     //  {{{ getListContents()
  1089.     /** Liste des contenus associés
  1090.      *
  1091.      * @access  public
  1092.      * @param string|int $type le type de champ
  1093.      */
  1094.     public function getListContents($params_sql = null, $params_display = array(), $debug = false)
  1095.     {
  1096.         $count_query = false;
  1097.         $sql_select = 'SELECT DISTINCT(ct.`idcontent`),ct.`title` ';
  1099.         // en plus
  1100.         if (!empty($params_sql['sql']['select'])) {
  1101.             $sql_select .= ',' . $params_sql['sql']['select'];
  1102.         }
  1104.         $sql_from = ' FROM contents ct ';
  1106.         $sql_where = ' WHERE 1 ';
  1108.         if (!empty($params_sql['special']['in'])) {
  1109.             if (is_array($params_sql['special']['in'])) {
  1110.                 $sql_where .= ' AND ct.idcontent IN (' . join(',', $params_sql['special']['in']) . ') ';
  1111.             } else {
  1112.                 $sql_where .= ' AND ct.idcontent IN (' . $params_sql['special']['in'] . ') ';
  1113.             }
  1114.         }
  1116.         // recherche par classifications
  1117.         if (!empty($params_sql['special']['by_classification'])) {
  1118.             $sql_from .= ' JOIN content_classification ccl ON ct.idcontent=ccl.idcontent ';
  1119.             $sql_where .= ' AND ccl.idclassification IN (' . join(',', $params_sql['special']['by_classification']) . ') ';
  1120.         }
  1121.         // on veut l'uilisateur
  1122.         if (!empty($params_sql['special']['get_extranetuser'])) {
  1123.             $sql_select .= ',e.login,e.idextranetuser';
  1124.             $sql_from .= ' JOIN extranetusers e ON ct.idextranetuser=e.idextranetuser ';
  1125.         }
  1126.         // recherche par spectacles
  1127.         if (!empty($params_sql['special']['idspectacle'])) {
  1128.             if (!is_array($params_sql['special']['idspectacle'])) {
  1129.                 $params_sql['special']['idspectacle'] = (array)$params_sql['special']['idspectacle'];
  1130.             }
  1131.             $sql_from .= ' JOIN object_content oc ON ct.`idcontent`=oc.`idcontent` ';
  1132.             $sql_where .= ' AND oc.`object`=\'spectacles\' AND oc.`idobject` IN (' . join(',', $params_sql['special']['idspectacle']) . ') ';
  1133.         }
  1135.         // on ligne ou pas ?
  1136.         if (!empty($params_sql['special']['get_extranetuser'])) {
  1137.             if (isset($params_sql['special']['publish']) && $params_sql['special']['publish'] != 2) {
  1138.                 $sql_where .= ' AND ct.publish=' . (int)$params_sql['special']['publish'];
  1139.             }
  1140.             if (isset($params_sql['special']['valid']) && $params_sql['special']['valid'] != 2) {
  1141.                 $sql_where .= ' AND ct.valid=' . (int)$params_sql['special']['valid'];
  1142.             }
  1143.         }
  1145.         // recherche par spectacle/contact
  1146.         if (!empty($params_sql['special']['get_critiques_idcontact'])) {
  1147.             if (!empty($params_sql['special']['get_critiques_idcontact_count'])) {
  1148.                 $count_query = true;
  1149.                 $sql_select = 'SELECT COUNT(DISTINCT(ct.`idcontent`)) AS total ';
  1150.             } else {
  1151.                 $sql_select = 'SELECT DISTINCT(ct.`idcontent`), ct.title as title, ct.*, e.`login`, e.`idextranetuser` ';
  1152.             }
  1154.             $sql_from = ' FROM contents ct
  1155.                 JOIN content_classification cc ON ct.`idcontent`=cc.`idcontent`
  1156.                 JOIN object_content oc ON ct.`idcontent`=oc.`idcontent`
  1157.                 JOIN spectacles s ON oc.`idobject`=s.`idspectacle`
  1158.                 JOIN schedules sc ON s.`idspectacle`=sc.`idspectacle`
  1159.                 JOIN extranetusers e ON ct.`idextranetuser`=e.`idextranetuser` ';
  1161.             $sql_where = ' WHERE s.`publish`=1 AND s.`valid`=1
  1162.                     AND ct.`publish`=1 AND ct.`valid`=1
  1163.                     AND cc.`idclassification`=101 ';
  1165.             if (!empty($params_sql['special']['get_critiques_idcontact_idspectacle'])) {
  1166.                 $sql_where .= '
  1167.                         AND (
  1168.                             sc.`idspectacle` IN (' . $this->arrayToIn($params_sql['special']['get_critiques_idcontact_idspectacle']) . ')
  1169.                             OR (
  1170.                                 sc.`idcontact`=' . $params_sql['special']['get_critiques_idcontact'] . '
  1171.                                 OR sc.`idcontact_festival`=' . $params_sql['special']['get_critiques_idcontact'] . '
  1172.                             )
  1173.                         )';
  1174.             } else {
  1175.                 $sql_where = ' WHERE s.`publish`=1 AND s.`valid`=1
  1176.                         AND ct.`publish`=1 AND ct.`valid`=1
  1177.                         AND cc.`idclassification`=101
  1178.                         AND (sc.`idcontact`=' . $params_sql['special']['get_critiques_idcontact'] . '
  1179.                         OR sc.`idcontact_festival`=' . $params_sql['special']['get_critiques_idcontact'] . ') ';
  1180.             }
  1182.             // en plus
  1183.             if (!empty($params_sql['sql']['where'])) {
  1184.                 $sql_where .= $params_sql['sql']['where'];
  1185.             }
  1187.             // classement des critiques anté
  1188.             $sql_order = ' ORDER BY ct.`date_article` DESC';
  1190.         }
  1192.         if (!empty($params_sql['special']['get_critiques_publisher'])) {
  1193.             if (!empty($params_sql['special']['get_critiques_publisher_count'])) {
  1194.                 $count_query = true;
  1195.                 $sql_select = 'SELECT COUNT(DISTINCT(ct.`idcontent`)) AS total ';
  1196.             } else {
  1197.                 $sql_select = 'SELECT DISTINCT(ct.`idcontent`), ct.title as title, ct.*, e.`login`, e.`idextranetuser` ';
  1198.             }
  1200.             $sql_from = ' FROM contents ct
  1201.                 JOIN content_classification cc ON ct.`idcontent`=cc.`idcontent`
  1202.                 JOIN object_content oc ON ct.`idcontent`=oc.`idcontent`
  1203.                 JOIN spectacles s ON oc.`idobject`=s.`idspectacle`
  1204.                 JOIN text_spectacle ts ON s.`idspectacle` = ts.idspectacle
  1205.                 JOIN texts t ON ts.idtext = t.idtext
  1206.                 JOIN schedules sc ON s.`idspectacle`=sc.`idspectacle`
  1207.                 JOIN extranetusers e ON ct.`idextranetuser`=e.`idextranetuser` ';
  1209.             $sql_where = ' WHERE s.`publish`=1 AND s.`valid`=1
  1210.                     AND ct.`publish`=1 AND ct.`valid`=1
  1211.                     AND cc.`idclassification`=101 ';
  1213.             $sql_where = ' WHERE s.`publish`=1 AND s.`valid`=1
  1214.                     AND ct.`publish`=1 AND ct.`valid`=1
  1215.                     AND cc.`idclassification`=101
  1216.                     AND t.`idcontact_publisher`=' . $params_sql['special']['get_critiques_publisher'] . ' ';
  1218.             // en plus
  1219.             if (!empty($params_sql['sql']['where'])) {
  1220.                 $sql_where .= $params_sql['sql']['where'];
  1221.             }
  1223.             // classement des critiques anté
  1224.             $sql_order = ' ORDER BY ct.`date_article` DESC';
  1226.         }
  1228.         // recherche dernières critques
  1229.         if (!empty($params_sql['special']['get_critiques'])) {
  1230.             $sql_select = 'SELECT DISTINCT(ct.`idcontent`), ct.title as title, ct.*, e.`login`, e.`idextranetuser` ';
  1231.             $sql_from = ' FROM contents ct
  1232.                 JOIN content_classification cc ON ct.`idcontent`=cc.`idcontent`
  1233.                 JOIN object_content oc ON ct.`idcontent`=oc.`idcontent`
  1234.                 JOIN spectacles s ON oc.`idobject`=s.`idspectacle`
  1235.                 JOIN schedules sc ON s.`idspectacle`=sc.`idspectacle`
  1236.                 JOIN extranetusers e ON ct.`idextranetuser`=e.`idextranetuser` ';
  1237.             $sql_where = ' WHERE s.`publish`=1 AND s.`valid`=1
  1238.                 AND ct.`publish`=1 AND ct.`valid`=1
  1239.                 AND cc.`idclassification`=101';
  1241.             // en plus
  1242.             if (!empty($params_sql['sql']['where'])) {
  1243.                 $sql_where .= $params_sql['sql']['where'];
  1244.             }
  1246.             // classement des critiques anté
  1247.             $sql_order = ' ORDER BY ct.`date_article` DESC';
  1249.         }
  1251.         if (!empty($params_sql['special']['prochains'])) {
  1252.             $dateend = strftime('%Y-%m-%d', strtotime(date('Y-m-d')) + $params_sql['special']['prochains'] * 24 * 3600);
  1253.             $sql_where .= ' AND (sc.date BETWEEN \'' . date('Y-m-d') . '\' AND \'' . $dateend . '\') ';
  1254.         }
  1256.         // recherche par spectacle/person/text
  1257.         if (!empty($params_sql['special']['get_critiques_idperson'])) {
  1258.             if (!empty($params_sql['special']['get_critiques_idperson']['count'])) {
  1259.                 $count_query = true;
  1260.                 $sql_select = 'SELECT COUNT(DISTINCT(ct.`idcontent`)) AS total ';
  1261.             } else {
  1262.                 $sql_select = 'SELECT DISTINCT(ct.`idcontent`), ct.title as title, ct.*, e.`login`, e.`idextranetuser` ';
  1263.             }
  1264.             $sql_from = ' FROM contents ct
  1265.                 JOIN content_classification cc ON ct.`idcontent`=cc.`idcontent`
  1266.                 JOIN object_content oc ON ct.`idcontent`=oc.`idcontent`
  1267.                 JOIN spectacles s ON oc.`idobject`=s.`idspectacle`
  1268.                 JOIN schedules sc ON s.`idspectacle`=sc.`idspectacle`
  1269.                 LEFT JOIN spectacle_person sp ON s.`idspectacle`=sp.`idspectacle`
  1270.                 LEFT JOIN text_spectacle ts ON s.`idspectacle`=ts.`idspectacle`
  1271.                 JOIN extranetusers e ON ct.`idextranetuser`=e.`idextranetuser` ';
  1273.             $sql_where = ' WHERE s.`publish`=1 AND s.`valid`=1
  1274.                 AND ct.`publish`=1 AND ct.`valid`=1
  1275.                 AND cc.`idclassification`=101
  1276.                 AND
  1277.                     (
  1278.                     sp.`idperson`=' . $params_sql['special']['get_critiques_idperson']['idperson'];
  1279.             if (!empty($params_sql['special']['get_critiques_idperson']['idtexts_person'])) {
  1280.                 $sql_where .= ' OR ts.`idtext` IN (' . $params_sql['special']['get_critiques_idperson']['idtexts_person'] . ')';
  1281.             }
  1282.             $sql_where .= ')';
  1284.             // en plus
  1285.             if (!empty($params_sql['sql']['where'])) {
  1286.                 $sql_where .= $params_sql['sql']['where'];
  1287.             }
  1288.         }
  1290.         // classement
  1291.         if (empty($params_sql['sql']['order']) && empty($sql_order)) {
  1292.             $sql_order = ' ORDER BY ct.dateinsert DESC';
  1293.         } elseif (!empty($params_sql['sql']['order'])) {
  1294.             $sql_order = ' ORDER BY ' . $params_sql['sql']['order'];
  1295.         }
  1297.         // en plus
  1298.         $sql_groupby = '';
  1299.         if (!empty($params_sql['sql']['groupby'])) {
  1300.             $sql_groupby .= ' GROUP BY ' . $params_sql['sql']['groupby'];
  1301.         }
  1303.         // limite
  1304.         if (empty($params_sql['sql']['limit'])) {
  1305.             $limit = ' LIMIT 0,10';
  1306.         } else {
  1307.             if ($params_sql['sql']['limit'] != 'all') {
  1308.                 if (is_array($params_sql['sql']['limit'])) {
  1309.                     $limit = ' LIMIT ' . $params_sql['sql']['limit'][0] . ',' . $params_sql['sql']['limit'][1];
  1310.                 } else {
  1311.                     if (strpos($params_sql['sql']['limit'], 'LIMIT') !== false) {
  1312.                         $limit = ' ' . $params_sql['sql']['limit'];
  1313.                     } else {
  1314.                         $limit = ' LIMIT ' . $params_sql['sql']['limit'];
  1315.                     }
  1316.                 }
  1317.             } else {
  1318.                 $limit = ' ';
  1319.             }
  1320.         }
  1322.         $sql = $sql_select . $sql_from . $sql_where . $sql_groupby . $sql_order . $limit;
  1324.         // paramètre de debug
  1325.         $dbg = (empty($params_sql['dbg'])) ? array() : $dbg = $params_sql['dbg'];
  1327.         if ($count_query) {
  1328.             return $this->queryOne($sql, $dbg);
  1329.         } else {
  1330.             $this->query($sql, $dbg);
  1331.             $ct = array();
  1333.             // debug
  1334.             $start_boucle = microtime(true);
  1336.             // mettre en forme chaque reponse
  1337.             while ($this->fetch()) {
  1338.                 $idcontent = $this->idcontent;
  1339.                 $cont = $this->getInfosContentRow($params_display, array('param_sql' => $params_sql));
  1340.                 $ct[$idcontent] = $cont;
  1341.             }
  1343.             // libère
  1344.             $this->free();
  1346.             // debug de la boucle
  1347.             if ($this->isTraceMode('list_object')) {
  1348.                 $this->setTraceInfos(array(
  1349.                     'execution_time_boucle' => (microtime(true) - $start_boucle),
  1350.                     'dbg' => $dbg,
  1351.                 ));
  1352.             }
  1354.             return $ct;
  1355.         }
  1357.     }
  1359.     // }}}
  1361.     //  {{{ getInfosContentRow()
  1363.     /** Infos standard sur un contenu
  1364.      *
  1365.      * Cette méthode peut-être utilisée dans les boucle while/fetch et récupère
  1366.      * la plus part des infos utiles dans les listes de résultats
  1367.      *
  1368.      * @access   public
  1369.      * @param array $format_vignette Format des vignettes
  1370.      * @return   array
  1371.      */
  1372.     public function getInfosContentRow($params_display = null, $params_more = array())
  1373.     {
  1374.         $cont = array();
  1375.         $idcontent = $this->idcontent;
  1377.         $cont['idcontent'] = $idcontent;
  1378.         $cont['title'] = $this->title;
  1380.         if (array_key_exists('shorten_title', $params_display) && $params_display['shorten_title']) {
  1381.             $cont['shorten_title'] = substr($this->title, 0, 50);
  1382.             if (strlen($this->title) >= 50) {
  1383.                 $cont['shorten_title'] = $cont['shorten_title'] . " ...";
  1384.             }
  1385.         }
  1387.         // récup aussi les classifications
  1388.         if (!empty($params_display['get_classifications'])) {
  1389.             $classifications = $this->getEntityManager()->getRepository(Classifications::class);
  1390.             $classifications_list = $classifications->getObjectClassification($this->__table, $idcontent, $this->getRelationsArray('content_classification'));
  1391.             $cont['classifications'] = $classifications_list;
  1392.         }
  1394.         // pour les critiques
  1395.         if (!empty($params_display['get_critiques'])) {
  1396.             $params_display['fields'] = array(
  1397.                 'title',
  1398.                 'deck',
  1399.                 'idextranetuser',
  1400.                 'login',
  1401.                 'dateinsert',
  1402.                 'date_article',
  1403.                 'writer',
  1404.                 'writer_group',
  1405.                 'writer_group_url',
  1406.                 'link'
  1407.             );
  1409.             $params_display['get_infos_spectacle'] = array(
  1410.                 'vignette' => [
  1411.                     'width' => $_ENV['VIGN_SPECTACLE_WIDTH'],
  1412.                     'height' => $_ENV['VIGN_SPECTACLE_HEIGHT'],
  1413.                     'direction' => 'crop'
  1414.                 ],
  1415.                 'stylemore' => [
  1416.                     'imagep' => 'width:70px;',
  1417.                     'descsp' => 'width:300px;'
  1418.                 ],
  1419.             );
  1421.             // recuperer les fichiers associes a ce contenu
  1422.             $datafile = $this->getAssociateFileContent($cont['idcontent']);
  1423.             if (!empty($datafile)) {
  1424.                 foreach ($datafile as $k => $v) {
  1425.                     if (!empty($v['is_image'])) {
  1426.                         // dimension des vignettes
  1427.                         $thumb_size = (!empty($params_display['get_critiques_vignette_large'])) ? 350 : 250;
  1429.                         //vignettes des critiques
  1430.                         $cont['vignette'] = $this->getThumbnail(
  1431.                             $v['file'],
  1432.                             $thumb_size,
  1433.                             'thumb'
  1434.                         );
  1436.                         //vignettes flous des critiques
  1437.                         $cont['vignette_flou'] = $this->getThumbnail(
  1438.                             $v['file'],
  1439.                             $thumb_size,
  1440.                             'thumb',
  1441.                             [
  1442.                                 'blur' => true,
  1443.                             ]
  1444.                         );
  1445.                     }
  1446.                 }
  1447.             }
  1448.         }
  1450.         if (!empty($params_display['fields'])) {
  1451.             foreach ($params_display['fields'] as $f => $v) {
  1452.                 if (isset($this->$v)) {
  1453.                     $cont[$v] = $this->$v;
  1454.                 }
  1455.             }
  1456.         }
  1458.         if (!empty($cont['dateinsert'])) {
  1459.             $cont['dateinsert_lng'] = $this->getFormeDate($cont['dateinsert'], "%A %d %B %Y", true);
  1460.         }
  1462.         if (!empty($cont['date_article'])) {
  1463.             $cont['date_article_lng'] = $this->getFormeDate($cont['date_article'], "%A %d %B %Y", true);
  1464.             $cont['date_article_lng_simple'] = $this->getFormeDate($cont['date_article'], "%a %d %b %Y", true);
  1465.         }
  1467.         // trouver les infos sur le spectacle associé
  1468.         if (!empty($params_display['get_infos_spectacle']) && !empty($this->idspectacle)) {
  1469.             $conn = $this->getEntityManager();
  1470.             $spectacles = $conn->getRepository(Spectacles::class);
  1471.             $cont['spectacles'] = $spectacles->getListSpectacles(array(
  1472.                 'params' => array(
  1473.                     'where' => ' AND s.idspectacle=' . $this->idspectacle
  1474.                 ),
  1475.                 'dbg' => array('spec' . $this->idspectacle, 'Spectacle ' . $this->idspectacle),
  1476.             ), $params_display['get_infos_spectacle']);
  1477.             // une seule url de spectacle
  1478.             if (!empty($cont['spectacles'])) {
  1479.                 foreach ($cont['spectacles'] as $s) {
  1480.                     $cont['spectacle']['url_clean'] = $s['url_clean'];
  1481.                 }
  1482.             }
  1483.         }
  1485.         return $cont;
  1486.     }
  1488.     // }}}
  1490.     //  {{{ getClassifications()
  1492.     /** récup les classifications d'un fichier
  1493.      *
  1494.      * @access   public
  1495.      * @param int $idcontent id du contenu
  1496.      * @return   array
  1497.      */
  1498.     public function getClassifications($idcontent)
  1499.     {
  1500.         $conn = $this->getEntityManager();
  1501.         $classifications = $conn->getRepository(Classifications::class);
  1502.         return $classifications->getObjectClassification($this->__table, $idcontent, $this->getRelationsArray('content_classification'));
  1503.     }
  1505.     // }}}
  1508.     // }}}
  1510.     //  {{{ getItemsList()
  1512.     /** récup les classifications d'un fichier
  1513.      *
  1514.      * @access   public
  1515.      * @param int $idcontent id du contenu
  1516.      * @return   array
  1517.      */
  1518.     public function getItemsList($idobject = null, $type, $src = null)
  1519.     {
  1520.         // trouver les groupe de menu
  1521.         if ($type == 'group_idclassification') {
  1522.             $sql = 'SELECT * FROM object_content oc
  1523.                     JOIN classifications cl ON oc.`idclassification`=cl.`idclassification`
  1524.                     WHERE oc.`object`=\'' . $src . '\'
  1525.                     AND oc.`idcontent`=' . $idobject;
  1526.             $results = $this->queryAll($sql);
  1527.             $itemslist = array();
  1528.             if (!empty($results)) {
  1529.                 foreach ($results as $r) {
  1530.                     $itemslist[$r['idclassification']]['id'] = $r['idclassification'];
  1531.                     $itemslist[$r['idclassification']]['view_name'] = $GLOBALS['context']['tr']->trans($r['classification']);
  1532.                 }
  1533.             }
  1534.             return $itemslist;
  1535.         }
  1536.         return $this->getItemsListTrait($idobject, $type, $src);
  1537.     }
  1539.     // }}}
  1541.     //  {{{ getApiFields()
  1543.     /** champs à renvoyer par l'API
  1544.      *
  1545.      * @access  public
  1546.      * @param array tableau de données
  1547.      */
  1548.     protected function getApiFields()
  1549.     {
  1551.         return array(
  1552.             'title' => 'title',
  1553.             'text' => 'text', // url complète
  1554.             'dateinsert' => 'insert_date',
  1555.         );
  1557.     }
  1559.     // }}}
  1561.     //  {{{ countContents()
  1563.     /** statistiques contenus
  1564.      *
  1565.      * @access  public
  1566.      */
  1567.     public function countContents($params = array())
  1568.     {
  1570.         // pour les spectacles d'une période
  1571.         if (!empty($params['periode'])) {
  1573.             $sql = 'SELECT COUNT(DISTINCT(c.`idcontent`))
  1574.                     FROM contents c
  1575.                         JOIN object_content oc ON c.`idcontent`=oc.`idcontent`
  1576.                         JOIN schedules sc ON sc.`idspectacle`=oc.`idobject`
  1577.                         JOIN content_classification cc ON c.`idcontent`=cc.`idcontent`
  1578.                         JOIN classifications cl ON cc.`idclassification`=cl.`idclassification`
  1579.                     WHERE oc.`object`=\'spectacles\'
  1580.                     AND sc.`date` BETWEEN \'' . $params['periode']['datestart'] . '\' AND \'' . $params['periode']['dateend'] . '\' ';
  1582.         } else {
  1584.             $sql = 'SELECT COUNT(DISTINCT(c.`idcontent`))
  1585.                      FROM contents c ';
  1587.             $sql .= ' JOIN content_classification cc ON c.`idcontent`=cc.`idcontent`
  1588.                       JOIN classifications cl ON cc.`idclassification`=cl.`idclassification` ';
  1590.             $sql .= ' WHERE 1 ';
  1592.         }
  1594.         $sql .= ' AND cl.`type`=\'contents\' ';
  1596.         if (!empty($params['classifications']) || !empty($params['idclassifications'])) {
  1598.             if (!empty($params['classifications'])) {
  1599.                 $sql .= ' AND cl.`classification` IN (' . $this->arrayToIn($params['classifications']) . ') ';
  1600.             }
  1601.             if (!empty($params['idclassifications'])) {
  1602.                 $sql .= ' AND cc.`idclassification` IN (' . $this->arrayToIn($params['idclassifications']) . ') ';
  1603.             }
  1605.         }
  1607.         $result = $this->queryOne($sql);
  1609.         return $result;
  1611.     }
  1613.     // }}}
  1615.     //  {{{ countSpectaclesWithContentsFromTexts()
  1617.     /** si il n'y a pas de contenus-pedagogiques sur un texte, vérifier que les mises en scène liées non pas elle un contenu
  1618.      *
  1619.      * @access  public
  1620.      */
  1621.     public function countSpectaclesWithContentsFromTexts($idtext, $idclassification)
  1622.     {
  1624.         $sql = 'SELECT COUNT(s.`idspectacle`) FROM spectacles s
  1625.                 JOIN text_spectacle ts  ON ts.`idspectacle`=s.`idspectacle`
  1626.                 JOIN object_content oc  ON oc.`idobject`=s.`idspectacle`
  1627.                 JOIN contents c ON c.`idcontent`=oc.`idcontent`
  1628.                 JOIN content_classification cc ON cc.`idcontent`=c.`idcontent`
  1629.                 WHERE c.publish=1
  1630.                 AND oc.object=\'spectacles\'
  1631.                 AND cc.idclassification=' . $idclassification . '
  1632.                 AND ts.idtext IN (' . $idtext . ')
  1633.                 AND s.`publish`=1 AND s.`valid`=1';
  1635.         return $this->queryOne($sql);
  1637.     }
  1639.     // }}}
  1640. }