vendor/theatre/core/src/Traits/TheatreTrait.php line 74

Open in your IDE?
  1. <?php
  3. namespace TheatreCore\Traits;
  5. use Doctrine\DBAL\Exception as DBALException;
  6. use Doctrine\DBAL\FetchMode;
  7. use Doctrine\ORM\Query;
  8. use Michelf\MarkdownExtra;
  9. use Psr\Log\LoggerInterface;
  10. use Symfony\Component\Cache\Adapter\AdapterInterface;
  11. use TheatreCore\Entity\Classifications;
  12. use TheatreCore\Entity\Extranetusers;
  13. use TheatreCore\Entity\Files;
  14. use TheatreCore\Entity\Multimedias;
  15. use TheatreCore\Entity\News;
  16. use TheatreCore\Entity\Playlists;
  17. use TheatreCore\Entity\Podcasts;
  18. use TheatreCore\Entity\Spectacles;
  19. use TheatreCore\Entity\TextAide;
  20. use TheatreCore\Entity\Texts;
  21. use App\Service\Cleantext;
  22. use App\Service\wiki2xhtml\wiki2xhtml;
  24. define('AUTOQUERY_INSERT', 1);
  25. define('AUTOQUERY_UPDATE', 2);
  27. trait TheatreTrait
  28. {
  29.     private $datas;
  30.     private $rows;
  31.     private $obj;
  32.     private $translator;
  33.     private $func;
  34.     private $count;
  35.     private $doctrine;
  36.     private $stats_base = 'statistiques';
  37.     private $countriesLoaded = [];
  38.     private ?LoggerInterface $logger = null;
  39.     private array $setFields = [];
  41.     public function setCount($count = true)
  42.     {
  43.         $this->count = $count;
  44.     }
  46.     public function getCount()
  47.     {
  48.         return $this->count;
  49.     }
  51.     function execute($sql)
  52.     {
  53.         $conn = $this->getEntityManager()->getConnection();
  54.         return $conn->exec($sql);
  55.     }
  57.     function queryOne($sql)
  58.     {
  59.         return $this->getEntityManager()->getConnection()->fetchOne($sql);
  60.     }
  62.     function queryCol($sql)
  63.     {
  64.         $conn = $this->getEntityManager()->getConnection();
  65.         $query = $conn->executeQuery($sql);
  67.         return $query->fetchFirstColumn();
  68.     }
  70.     function queryRow($sql)
  71.     {
  72.         $conn = $this->getEntityManager()->getConnection();
  74.         $query = $conn->executeQuery($sql);
  75.         return $query->fetch();
  76.     }
  78.     function loadResult($data)
  79.     {
  80.         if (!empty($data)) {
  81.             foreach ($data as $key => $value) {
  82.                 $this->$key = $value;
  83.             }
  84.         }
  85.     }
  87.     function query($sql)
  88.     {
  90.         $conn = $this->getEntityManager()->getConnection();
  92.         $this->rows = 0;
  93.         $this->obj = new $this->__table_object();
  95.         $query = $conn->executeQuery($sql);
  96.         $this->datas = $datas = $query->fetchAll();
  98.         return $datas;
  100.     }
  102.     public function numRows()
  103.     {
  104.         return count($this->datas);
  105.     }
  107.     function fetch()
  108.     {
  109.         $total = count($this->datas);
  111.         $this->currentRow = $line = $this->rows;
  113.         if ($total > $line) {
  114.             $this->rows++;
  116.             if (!empty($this->datas[$line])) {
  117.                 foreach ($this->datas[$line] as $key => $value) {
  118.                     $this->$key = $value;
  119.                 }
  121.                 return $this->datas[$line];
  122.             }
  123.         }
  125.         return false;
  126.     }
  128.     public function queryAll($sql, $params1 = null, $params2 = null, $params3 = null)
  129.     {
  130.         $this->rows = 0;
  131.         $conn = $this->getEntityManager()->getConnection();
  133.         $query = $conn->executeQuery($sql);
  135.         if ($params3) {
  136.             return $query->fetchAll(FetchMode::ASSOCIATIVE); //|\PDO::FETCH_COLUMN nécessaire pour TypesstructuresRepository->getTypeStructureList
  137.         } else {
  138.             return $query->fetchAll();
  139.         }
  140.     }
  142.     public function fetchRow()
  143.     {
  144.         $total = count($this->datas);
  146.         $line = $this->rows;
  148.         if ($total > $line) {
  149.             $this->rows++;
  151.             return $this->datas[$line];
  152.         }
  154.         return false;
  155.     }
  157.     function free()
  158.     {
  160.     }
  162.     public function escape($value)
  163.     {
  165.         if (is_array($value)) {
  166.             foreach ($value as $key => $item) {
  167.                 $value[$key] = addslashes($item);
  168.             }
  169.             return $value;
  170.         }
  172.         return addslashes($value);
  173.     }
  175.     public function get($value, $column = null)
  176.     {
  177.         if (is_null($column)) {
  178.             $query = $this->createQueryBuilder('u')
  179.                 ->select('u')
  180.                 ->where('u.' . $this->__idtable . ' =:value')->setParameter('value', $value);
  182.             $this->datas = $x = $query->getQuery()
  183.                 ->getOneOrNullResult(Query::HYDRATE_ARRAY);
  184.         } else {
  185.             $this->datas = $this->createQueryBuilder('u')
  186.                 ->select('u')
  187.                 ->where('u.' . $column . ' =:value')->setParameter('value', $value)
  188.                 ->getQuery()
  189.                 ->getOneOrNullResult(Query::HYDRATE_ARRAY);
  190.         }
  192.         return $this->datas;
  194.     }
  196.     public function autoExecute($__table, $setFields, $type, $where = null, LoggerInterface $logger = null)
  197.     {
  198.         $conn = $this->getEntityManager()->getConnection();
  200.         if ($type === AUTOQUERY_UPDATE) {
  201.             $sql = "UPDATE  `$__table` SET ";
  202.             $params = [];
  203.             $first = true;
  205.             foreach ($setFields as $k => $v) {
  206.                 if (!$first) {
  207.                     $sql .= ', ';
  208.                 }
  209.                 if (is_null($v) || (empty($v) && !is_numeric($v))) {
  210.                     $sql .= $k . " = :$k";
  211.                     $params[$k] = null;
  212.                 } else {
  213.                     $sql .= $k . " = :$k";
  214.                     $params[$k] = strip_tags($v);
  215.                 }
  217.                 $first = false;
  218.             }
  220.             if (!is_null($where)) {
  221.                 $sql .= " WHERE $where";
  222.             }
  224.             $stmt = $conn->prepare($sql);
  225.             $stmt->executeStatement($params);
  227.             return $conn->lastInsertId();
  228.         }
  229. //        else if($type == AUTOQUERY_INSERT){
  230. //
  231. //            $conn = $this->getEntityManager()->getConnection();
  232. //            $conn->insert($__table, $setFields);
  233. //
  234. //            return $conn;
  235. //        }
  236.     }
  238.     // test si la variable est en entier valide (attention, n'est pas is_int())
  239.     function my_is_int($x)
  240.     {
  241.         return (is_numeric($x) ? intval($x) == $x : false);
  242.     }
  244.     function noPunct($array)
  245.     {
  246.         if (is_array($array)) {
  247.             if (!empty($array)) {
  248.                 end($array);
  249.                 $k = key($array);
  250.                 $array[$k]['nopunct'] = true;
  251.                 return $array;
  252.             } else {
  253.                 return array();
  254.             }
  255.         } else {
  256.             return $array;
  257.         }
  258.     }
  260.     /*
  261.  *type de requete (mdb2 ou dbdo)
  262.  */
  263.     public $typefind;
  264.     public $queryfind;
  266.     /*
  267.      * verifier les droits ou pas ?
  268.      */
  269.     public $checkRights = false;
  271.     /*
  272.      * liste des valeurs d'object acceptées, voir setValidObjects()
  273.      */
  274.     private $object_accept = array();
  276.     /*
  277.      * publié ou pas
  278.      */
  279.     public $publish_status = 2;
  281.     /*
  282.      * infos pagination
  283.      */
  284.     public $paged_data = array();
  286.     /*
  287.      * requête courante
  288.      */
  289.     private $currentQuery;
  291.     private $currentRow;
  293.     public $db;
  295.     // constantes pour marquer les différents types d'id
  296.     public $IDNUM = 0; // identifiant numérique (28)
  297.     public $IDSTR = 1; // identifiant textuel  ('class_truc')
  299.     public function quote($value)
  300.     {
  301.         return '\'' . $value . '\'';
  302.     }
  304.     // {{{ objToArray()
  306.     public function getListSearchRelation()
  307.     {
  308.         $query = $this->createQueryBuilder('e');
  309.         $query->select('e');
  311.         return $query;
  312.     }
  314.     // }}}
  316.     // {{{ objToArray()
  318.     /** Redéfinition de DataObject::toArray()
  319.      *
  320.      *
  321.      * @access public
  322.      * @return array
  323.      */
  324.     public function objToArray($query = null)
  325.     {
  326.         $conn = $this->getEntityManager();
  328.         $values = [];
  329.         if (!is_null($query)) {
  330.             $values = $query->getSingleResult(Query::HYDRATE_ARRAY);
  331.             $this->loadResult($values);
  332.         }
  334.         return $values;
  335.     }
  337.     // }}}
  339.     //  {{{ setData()
  341.     /** Mettre a jour ou inserer les informations
  342.      *
  343.      * permet de mettre a jour globalement les informations ou de
  344.      * creer un nouvel enregistrement
  345.      *
  346.      * @see setUpdateFields
  347.      * @access private
  348.      */
  349.     public function setData($id = null, $last = false, $allRights = true, $where = null, LoggerInterface $logger = null)
  350.     {
  351.         $this->logger = $logger;
  352.         // ajouter des backquote
  353. //        $this->setOption('quote_identifier', true);
  355.         // desactiver la verification des droits
  356.         if ($allRights) {
  357.             $rights = array('insert' => 1, 'update' => 1);
  358.         }
  360.         // checker les droits
  361.         if (!$allRights || $this->isCheckRights()) {
  362.             $extranetusers = $this->getEntityManager()->getRepository(Extranetusers::class);
  363.             $rights = $extranetusers->getRights();
  364.         }
  366.         // si $id existe on update
  367.         if (!empty($id) || $where) {
  368.             // on doit avoir le droit d'update'
  369.             if (isset($rights) && $rights['update'] == 1) {
  370.                 // where simple ou complexe
  371.                 if (!$where) {
  372.                     $where = $this->__idtable . "='$id'";
  373.                 }
  374.                 $this->r = $this->autoExecute($this->__table, $this->setFields, AUTOQUERY_UPDATE, $where, $logger);
  376.             } else {
  377.                 throw new \Exception($GLOBALS['tr']->trans('no_right') . 'setData-update');
  378.             }
  380.             // sinon on insére
  381.         } else {
  382.             if (isset($rights) && $rights['insert'] == 1) {
  383.                 try {
  384.                     $conn = $this->getEntityManager()->getConnection();
  385.                     $conn->insert($this->__table, $this->setFields);
  386.                 } catch (DBALException $e) {
  387.                     $this->logError($e->getMessage());
  388.                     $this->logError($e->getTraceAsString());
  389.                 }
  390.             } else {
  391.                 $this->logError($GLOBALS['tr']->trans('no_right') . 'setData-insert');
  392.             }
  393.         }
  395.         if (is_null($id) || $id === '') {
  396.             if ((isset($conn))) {
  397.                 if ($conn->lastInsertId()) {
  398.                     return $conn->lastInsertId();
  399.                 }
  401.                 return true;
  402.             }
  404.             return false;
  405.         } else {
  406.             return $id;
  407.         }
  408.     }
  410.     private function logError(string $message)
  411.     {
  412.         if ($this->logger) {
  413.             $this->logger->error($message);
  414.         } else {
  415.             error_log($message);
  416.         }
  417.     }
  419.     // }}}
  421.     //  {{{ getSelectfields()
  423.     /** Passe les champs souhaités sous forme de chaine
  424.      *
  425.      * Récupère sous forme de string les champs qu'on souhaite pour une
  426.      * requête. Si selectfields n'est pas précisé on prendra tous les champs
  427.      * comme pour un SELECT étoile.
  428.      *
  429.      * @access   public
  430.      * @return   string
  431.      */
  432.     public function getSelectfields()
  433.     {
  434.         if (empty($this->selectfields)) {
  435.             $this->selectfields = $this->fields;
  436.         }
  438.         $field_string = '';
  439.         foreach ($this->selectfields as $field) {
  440.             if ($field_string) $field_string .= ', ';
  441.             $field_string .= $this->aliastable . '.' . $field;
  442.         }
  444.         return $field_string;
  445.     }
  447.     // }}}
  449.     //  {{{ selectFields()
  451.     /** Récupére les champs souhaités
  452.      *
  453.      * Récupére sous forme de array les champs qu'ont souhaite pour une
  454.      * requête. Si selectfields n'est pas précisé, on prendra tous les champs
  455.      * comme pour un SELECT étoile.
  456.      *
  457.      * @param array $fieldsext Les champs précisés dans un tableau
  458.      * @access   public
  459.      * @return   array
  460.      * @see      setUpdatefields()
  461.      * @see      getSelectfields()
  462.      */
  463.     public function selectFields($fieldsext = null)
  464.     {
  466.         if (!empty($fieldsext)) {
  467.             $this->selectfields = $fieldsext;
  468.         }
  470.     }
  472.     // }}}
  474.     //  {{{ setUpdatefields()
  476.     /** Précise les champs à updater ou insérer
  477.      *
  478.      * Précise dans un tableau les champs à updater ou à insérer. Le nom du champ
  479.      * et sa valeur nécessaire à la classe DB
  480.      *
  481.      * @param array $fieldsext Les champs précisés dans un tableau
  482.      * @access   public
  483.      * @return   array
  484.      */
  485.     public function setUpdatefields($fieldsext, $quote_identifier = false)
  486.     {
  488.         // ajouter les identifiers
  489.         if ($quote_identifier) {
  490.             foreach ($fieldsext as $k => $v) {
  491.                 $fieldsext['`' . $k . '`'] = $v;
  492.             }
  493.         }
  495.         $this->setFields = $fieldsext;
  497.     }
  499.     // }}}
  501.     //  {{{ setExec()
  503.     /** Executer ou non la requete
  504.      *
  505.      * On peux avoir simplement besoin de retourner la requete
  506.      * Pour une clause LIMIT ou un count
  507.      *
  508.      * Par defaut, on execute
  509.      *
  510.      * @param bool $exec execution
  511.      * @see specialQuery()
  512.      * @access public
  513.      */
  514.     public function setExec($exec = true)
  515.     {
  516.         $this->exec = $exec;
  517.     }
  519.     // }}}
  521.     //  {{{ specialQuery()
  523.     /** Requete MDB2 ou find de DBDO
  524.      *
  525.      * Permet de savoir si on est dans le cas d'une requete
  526.      * qui passe par MDB2 ou d'une requete qui passe par DB_Dataobject
  527.      * Pour le pager, les clauses limit, les count... c'est important de le savoir
  528.      *
  529.      * Si query est vide, ca signifie que tout est passe par DBDO
  530.      *
  531.      * @param string $query la requete
  532.      * @see find()
  533.      * @see findData()
  534.      * @see setOrderBy()
  535.      * @access public
  536.      * @see setExec()
  537.      */
  538.     public function specialQuery($query = null, $save_query = false)
  539.     {
  540.         if (!empty($query)) {
  541.             // definir au besoin un order de tri
  542.             if (isset($this->setOrder)) {
  543. //                $query .= ' ORDER BY '.$this->setOrder;
  544.                 $query->orderBy($this->setOrder, $this->setDirection);
  546.             }
  548.             $this->queryfind = $query;
  549.             if ($save_query) {
  550. //                $this->setCurrentQuery($query);
  551.             }
  552.             $this->typefind = 'mdb2';
  553.             //if($this->exec) {
  555. //            $query = $this->executeQuery($sql);
  556. //            $subQuery = $query->getQuery();
  557. //            $this->datas = $subQuery->getResult();
  559. //            $this->query($query);
  560.             //error_log('DEBUG - EXECUTE DANS THEATRE MDB2 : '.$query);
  561.             //}
  562.         } else {
  564.             //if(isset($this->exec)) {
  565.             // definir au besoin un order de tri
  566.             if (isset($this->setOrder)) {
  567.                 $this->orderBy($this->setOrder);
  568.             }
  569. //            $x = $this->findAll();
  570.             //error_log('DEBUG - EXECUTE DANS THEATRE DBDO');
  571.             //}
  572.             $this->typefind = 'dbdo';
  573.         }
  575.         return $this->datas;
  576.     }
  578.     // }}}
  580.     //  {{{ setOrderBy()
  582.     /** Definir un ordre de tri en dehors du pager
  583.      *
  584.      * @param string $order le tri
  585.      * @see specialQuery()
  586.      * @access public
  587.      */
  588.     public function setOrderBy($order = null, $direction = null)
  589.     {
  590.         if (!empty($order)) {
  591.             $this->setOrder = $order;
  592.         }
  594.         if (!empty($direction)) {
  595.             $this->setDirection = $direction;
  596.         }
  597.     }
  599.     // }}}
  601.     //  {{{ setCurrentQuery()
  603.     /** Enregistrer la requête proposée via specialQuery
  604.      *
  605.      * @param string $query la requête
  606.      * @see specialQuery()
  607.      * @access public
  608.      */
  609.     public function setCurrentQuery($query)
  610.     {
  611.         $this->currentQuery = $query;
  612.     }
  614.     // }}}
  616.     //  {{{ getCurrentQuery()
  618.     /** récupèrer la requête courante
  619.      *
  620.      * @see specialQuery()
  621.      * @access public
  622.      */
  623.     public function getCurrentQuery()
  624.     {
  625.         return $this->currentQuery;
  626.     }
  628.     // }}}
  630.     //  {{{ dbLimit()
  632.     /** Limitation du nombre de resultat
  633.      *
  634.      *
  635.      * @access public
  636.      */
  637.     public function dbLimit($limit, $offset = 0)
  638.     {
  639.         if (empty($offset)) {
  640.             $offset = 0;
  641.         }
  642.         return ' LIMIT ' . $offset . ',' . $limit;
  643.     }
  645.     // }}}
  647.     //  {{{ getPagination()
  649.     /** Récupère les élèments de navigation
  650.      *
  651.      *
  652.      * @access public
  653.      */
  654.     public function getPagination($replace_pattern = null)
  655.     {
  656.         if ($replace_pattern) {
  657.             //$pat = 'href="\/index\.php\?pageID\=([0-9]+)"';
  658.             $pat = 'href="([a-z,0-9,\.,\/]+)\?pageID\=([0-9]+)"';
  659.             //$this->paged_data['links'] = preg_replace('/'.$pat.'/','href="'.$replace_pattern.'?pageID=$2"',$this->paged_data['links']);
  660.             $this->paged_data['links'] = str_replace('evenements/view/index.php', '', $this->paged_data['links']);
  661.         }
  662.         return $this->paged_data;
  663.     }
  665.     // }}}
  667.     //  {{{ setCheckRights()
  669.     /** preciser si il faut verifier les droits ou pas
  670.      *
  671.      * Précise si il faudra checker les droits dans les methodes
  672.      *
  673.      * @param bool $right
  674.      * @access   public
  675.      * @return   bool
  676.      */
  677.     public function setCheckRights($right = false)
  678.     {
  680.         return $this->checkRights = $right;
  682.     }
  684.     // }}}
  686.     //  {{{ isCheckRights()
  688.     /** verifier si on doit utiliser les droits ou pas
  689.      *
  690.      * @access   public
  691.      * @return   bool
  692.      */
  693.     public function isCheckRights()
  694.     {
  696.         return $this->checkRights;
  698.     }
  700.     // }}}
  702.     //  {{{ setToArray()
  704.     /** Liste des enregistrements dans un tableau associatif
  705.      *
  706.      * Tableau associatif notament utilisé pour lister les informations sur les enregistrements
  707.      * Utile pour générer les tableaux HTML de listes des enregistrements
  708.      *
  709.      * @access  public
  710.      * @return  array
  711.      * @see     findData()
  712.      */
  713.     public function setToArray($spec = true)
  714.     {
  716.         // desactive si pager
  717.         if ($spec == true) {
  718.             $this->findData();
  719.         }
  721.         // declaration
  722.         $values = array();
  723.         $color = null;
  724.         $nb = 0;
  726.         while ($this->fetch()) {
  728.             // infos sur l'enregistrement
  729.             $values[$nb] = $this->getInfosObject();
  731.             // couleur de ligne alternative
  732.             $color = $this->colorAlternate($color);
  733.             $values[$nb]['colorline'] = $color;
  735.             $nb++;
  736.         }
  738.         return $values;
  739.     }
  741.     // }}}
  743.     //  {{{ deleteData()
  745.     /** Suppression
  746.      *
  747.      * Permet de supprimer l'enregistrement
  748.      *
  749.      * @access   public
  750.      * @param int $id Id de l'enregistrement principal
  751.      * @param string $table Nom de la table de relation
  752.      * @param bool $allRights Checker les droits
  753.      * @param bool $delete_relationa Faut-il supprimer également les relations (non FK) ?
  754.      * @param bool $log_deletion Loguer les suppressions
  755.      * @return   bool
  756.      */
  757.     public function deleteData($id, $table = null, $key = null, $allRights = true, $delete_relation = null, $log_deletion = null)
  758.     {
  760.         // ne pas checker les droits
  761.         if ($allRights) {
  762.             $rights = array('delete' => 1);
  763.         }
  765.         if ($this->setCheckRights() || !$allRights) {
  767.             $extranetusers = Theatre_Extranetusers::factory('extranetusers');
  768.             $rights = $extranetusers->getRights();
  769.         }
  771.         if (isset($rights) && $rights['delete'] == 1) {
  773.             if (!empty($table) && !empty($key)) {
  774.                 $req = 'DELETE FROM ' . $table . ' WHERE ' . $key . '=\'' . $id . '\'';
  775.             } else {
  776.                 $req = 'DELETE FROM ' . $this->__table . ' WHERE ' . $this->__idtable . '=\'' . $id . '\'';
  777.             }
  779.             $del = $this->execute($req);
  781.             // logguer les delete
  782.             $this->logDeletion($req);
  784.             if ($del) {
  786.                 // supprimer également les relations qui ne sont pas supprimées automatiquement via des foreigh keys
  787.                 if (!empty($delete_relation)) {
  789.                     // ont récup le tableau des relations
  790.                     $infos_links = $this->getRelationsArray('all');
  792.                     foreach ($infos_links as $k => $v) {
  794.                         // si marqué comme silent_delete_relation à true et use_constraint à false
  795.                         // on va construire la requête de suppression avec getLinkedObject
  796.                         if (!empty($v['silent_delete_relation']) && !empty($v['do_constraint'])) {
  798.                             // trouver les items liés
  799.                             $items = $this->getLinkedObject($v, $id, $k, $this->__table);
  801.                             if (!empty($items)) {
  803.                                 // si il s'agit d'une table 'by_object' ont doit supprimer dans join table mais pas des la table des destination
  804.                                 if (!empty($v['join_table']) &&
  805.                                     (strpos($v['join_table'], 'object_') !== false
  806.                                         || strrpos($v['join_table'], '_by_object') !== false)) {
  808.                                     // contient _by_object
  809.                                     if (strrpos($v['join_table'], '_by_object') !== false) {
  810.                                         $v['join_table'] = str_replace('_by_object', '', $v['join_table']);
  811.                                         $dest_table = $v['join_table'];
  812.                                     }
  814.                                     //echo 'supprimer '.$id.' '.$this->__table.' de la table '.$dest_table.' <br />';
  816.                                     // sinon, effacement classique dans la table de destination
  817.                                 } else {
  819.                                     // table ou l'on doit supprimer
  820.                                     $dest_table = $v['dest_table'];
  822.                                     $delete_items = array();
  823.                                     foreach ($items as $kb => $vb) {
  824.                                         $delete_items[] = $kb;
  825.                                     }
  827.                                     //echo 'supprimer '.join(',', $delete_items).' de la table '.$dest_table.' <br />';
  829.                                 }
  831.                             }
  832.                         }
  834.                     }
  836.                 }
  838.                 return true;
  839.             }
  841.         } else {
  842.             throw new Exception($GLOBALS['tr']->get('no_rights') . ' deleteData');
  843.         }
  845.     }
  847.     // }}}
  849.     //  {{{ getLinkedObject()
  851.     /** Liste des items liés
  852.      *
  853.      * Retourne un tableau associatif contenant la liste des items liés
  854.      *
  855.      * @access  public
  856.      * @param array $infos_link Tableau de description de la relation
  857.      * @param int $idobject Id de l'objet source
  858.      * @params  string $type nom de la relation
  859.      * @params  string $src nom de la table source pour laquelle on cherche une relation
  860.      * @params  array $params paramètres en plus
  861.      * @return  array
  862.      * @see     getRelationsArray()
  863.      */
  864.     public function getLinkedObject($infos_link, $idobject, $type, $src, $params = array())
  865.     {
  866.         // type => soit un champ (field), soit une table (object)
  867.         // si on veux utiliser une methode type_join=method
  869.         $dbjoin = $_ENV['TH_BDD'];
  870.         $dbsource = $_ENV['TH_BDD'];
  872.         $itemslist = array();
  874.         // via une méthode
  875.         if (!empty($infos_link['type_join']) && $infos_link['type_join'] == 'method') {
  876.             if (!empty($infos_link['method_params'])) {
  877.                 return $this->{$infos_link['method']}($idobject, $type, $infos_link['method_params']);
  878.             } else {
  879.                 return $this->{$infos_link['method']}($idobject, $type);
  880.             }
  881.         }
  883.         if (!empty($infos_link['type_join']) && ($infos_link['type_join'] == 'multiple' || $infos_link['type_join'] == 'simple')) {
  884.             // objet source (exemple : on veux les adaptation liées a un texte, l'objet source est 'texts')
  885.             $src = $dbdo = str_replace('_', '', ucwords($src, '_'));
  886.             $src_obj = $this->getEntityManager()->getRepository('TheatreCore\Entity\\' . ucfirst($src));
  888.             // table source si précisée
  889.             if (!empty($infos_link['src_table'])) {
  890.                 $src_table = $infos_link['src_table'];
  891.             } else {
  892.                 $src_table = $src_obj->__table;
  893.             }
  895.             // si on precise un champ index différent pour la source
  896.             if (!empty($infos_link['src_table_field'])) {
  897.                 $src_table_field = $infos_link['src_table_field'];
  898.             } else {
  899.                 $src_table_field = $src_obj->__idtable;
  900.             }
  902.             // => objet lié (pour l'exemple : texts de l'adaptation)
  904.             // table de destination si précisée
  905.             if (!empty($infos_link['dest_table'])) {
  906.                 $dest_obj = $this->getEntityManager()->getRepository('TheatreCore\Entity\\' . implode('', array_map(function ($m) {
  907.                         return ucfirst($m);
  908.                     }, explode('_', $infos_link['dest_table']))));
  909.                 $dest_table = $dest_obj->__table;
  910.             }
  912.             // si on precise un champ index différent pour la destination
  913.             if (!empty($infos_link['dest_table_field'])) {
  914.                 $dest_table_field = $infos_link['dest_table_field'];
  915.                 // si le champ de destination est idobject alors il faut object
  916.                 if ($dest_table_field == 'idobject') {
  917.                     $join_object_table_constraint = 'j1.object=\'' . $src_table . '\' ';
  918.                 }
  919.             } else {
  920.                 $dest_table_field = $dest_obj->__idtable;
  921.             }
  923.             // table de jointure
  924.             if (!empty($infos_link['join_table'])) {
  925.                 $join_table = $infos_link['join_table'];
  926.             }
  928.             // si on precise un champ de jointure différent
  929.             if (!empty($infos_link['join_field_src'])) {
  930.                 $join_field_src = $infos_link['join_field_src'];
  931.             } else {
  932.                 // sinon le même que celui de la table source
  933.                 $join_field_src = $src_table_field;
  934.             }
  936.             // si on precise un champ de jointure différent
  937.             if (!empty($infos_link['join_field_dest'])) {
  938.                 $join_field_dest = $infos_link['join_field_dest'];
  939.             } else {
  940.                 // sinon le même que celui de la table source
  941.                 $join_field_dest = $dest_table_field;
  942.             }
  944.             // contrainte sur la table de jointure (par exemple object_xxx)
  945.             /*if(!empty($infos_link['join_table_constraint'])) {
  946.                 $join_table_constraint = $infos_link['join_table_constraint'];
  947.             }*/
  949.             // si la table de jointure commence par object_ ou contient by_object, alors la contrainte du
  950.             // du champ object correspond au nom de la table source et idobject à l'identifiant
  951.             if (!empty($infos_link['join_table']) &&
  952.                 (strpos($infos_link['join_table'], 'object_') !== false || strrpos($infos_link['join_table'], '_by_object') !== false)) {
  954.                 // contient _by_object
  955.                 if (strrpos($infos_link['join_table'], '_by_object') !== false) {
  956.                     $infos_link['join_table'] = str_replace('_by_object', '', $infos_link['join_table']);
  957.                     $join_table = $infos_link['join_table'];
  958.                 }
  960.                 // si object a un nom différent de la table source
  961.                 if (!empty($infos_link['join_table_object'])) {
  962.                     $join_table_object = $infos_link['join_table_object'];
  963.                 } else {
  964.                     $join_table_object = $src_table;
  965.                 }
  967.                 // contrainte
  968.                 $join_object_table_constraint = 'j2.object=\'' . $join_table_object . '\' AND j2.idobject=' . (int)$idobject;
  969.                 $join_field_src = 'idobject';
  971.             }
  973.             // select invers (exemple : trouver les personnes lié à un multimedia depuis le multimédia, en passant par object_multimedia)
  974.             if (!empty($infos_link['join_from_object'])) {
  975.                 $join_field_src = $src_table_field; // idmultimedia
  976.                 $join_field_dest = 'idobject'; // sur object_multimedia => idobject
  977.                 $join_object_table_constraint = ' j2.object=\'' . $infos_link['dest_table'] . '\' ';
  978.             }
  980.             // ajouter l'alias sur les champs de 'destination'
  981.             foreach ($infos_link['fields'] as $f) {
  982.                 $fields_alias[] = 'j1.' . $f;
  983.             }
  985.             // ajouter l'alias sur les champs de la table de jointure
  986.             if (!empty($infos_link['fields_join_table'])) {
  987.                 foreach ($infos_link['fields_join_table'] as $f) {
  988.                     $fields_alias[] = 'j2.' . $f;
  989.                 }
  990.             }
  993.             // compter uniquement
  994.             if (!empty($params['count_only'])) {
  995.                 $select = 'COUNT(*)';
  996.             } else {
  997.                 $select = implode(',', $fields_alias);
  998.             }
  1000.             // début de la requête
  1001.             $sql = 'SELECT ' . $select . ' ';
  1003.             // ajouter la clé de la table source dans le select si diff de la table dest
  1004.             if (property_exists($src_obj, '__idtable') && !in_array($src_obj->__idtable, $infos_link['fields'])) {
  1005.                 if (!empty($infos_link['fields_dest_table'])) {
  1006.                     foreach ($infos_link['fields_dest_table'] as $f) {
  1007.                         $fields_alias[] = 'j3.' . $f;
  1008.                     }
  1009.                 } else {
  1010.                     $sql .= ',j3.' . $src_obj->__idtable . ' ';
  1011.                 }
  1012.             }
  1014.             // dans la cas d'une jointure avec 3 tables
  1015.             if ($infos_link['type_join'] == 'multiple') {
  1017.                 $sql .= 'FROM ' . $dbsource . '.' . $dest_table . ' j1, ' . $dbjoin . '.' . $join_table . ' j2, ' . $dbsource . '.' . $src_table . ' j3
  1018.                         WHERE j3.' . $src_table_field . '=j2.' . $join_field_src . '
  1019.                         AND j1.' . $dest_table_field . '=j2.' . $join_field_dest . '
  1020.                         AND j3.' . $src_table_field . '=' . (int)$idobject;
  1022.                 // requete avec jointure sur 3 tables
  1023.                 if (!empty($join_object_table_constraint)) {
  1024.                     $sql .= ' AND ' . $join_object_table_constraint;
  1025.                 }
  1027.             }
  1029.             // une jointure avec une table
  1030.             if ($infos_link['type_join'] == 'simple') {
  1032.                 // requete avec jointure sur 1 table
  1033.                 $sql .= 'FROM ' . $dbsource . '.' . $dest_table . ' j1, ' . $dbjoin . '.' . $src_table . ' j3
  1034.                         WHERE j1.' . $dest_table_field . '=j3.' . $join_field_src . '
  1035.                         AND j3.' . $src_table_field . '=' . (int)$idobject;
  1037.                 // requete avec jointure sur 3 tables
  1038.                 if (!empty($join_object_table_constraint)) {
  1039.                     $sql .= ' AND ' . $join_object_table_constraint;
  1040.                 }
  1042.             }
  1044.             // ajouter une contrainte sur la table de destination
  1045.             if (!empty($infos_link['constraint_dest'])) {
  1046.                 $sql .= ' AND j1.' . $infos_link['constraint_dest'];
  1047.             }
  1049.             // contrainte ou autre en plus
  1050.             if (!empty($infos_link['where'])) {
  1051.                 $sql .= ' ' . $infos_link['where'];
  1052.             }
  1053.             // contrainte ou autre en plus
  1054.             if (!empty($infos_link['sql_more'])) {
  1055.                 $sql .= ' ' . $infos_link['sql_more'];
  1056.             }
  1058.             // ajouter une contrainte sur la table du miliue par exemple idrole précis
  1060.             if (!empty($params['count_only'])) {
  1061.                 $nb_items = $this->queryOne($sql);
  1063.                 return $nb_items;
  1064.             }
  1066.             $itemslist = $this->getEntityManager()->getConnection()->fetchAllAssociativeIndexed($sql);
  1068.             // paramètres pour getObjecTtitle
  1069.             if (!empty($infos_link['title_params'])) {
  1070.                 $params = $infos_link['title_params'];
  1071.             } else {
  1072.                 $params = array();
  1073.             }
  1075.             if (!empty($itemslist)) {
  1077.                 $color = null;
  1079.                 // index principal
  1080.                 $idfield = $infos_link['fields'][0];
  1082.                 foreach ($itemslist as $key => $value) {
  1083.                     // remettre le idtruc dans le tableau
  1084.                     $value[$idfield] = $key;
  1085.                     $itemslist[$key][$idfield] = $key;
  1087.                     // noms pour des listes standard
  1088.                     $itemslist[$key]['id'] = $key;
  1089.                     if (method_exists($dest_obj, 'getObjectTitle')) {
  1090.                         $itemslist[$key]['view_name'] = $dest_obj->getObjectTitle($key, $value, $params);
  1091.                     }
  1093.                     // couleur alternative
  1094.                     $color = $this->colorAlternate($color);
  1095.                     $itemslist[$key]['colorline'] = $color;
  1096.                 }
  1097.             }
  1099.         }
  1101.         return $itemslist;
  1103.     }
  1105.     // }}}
  1107.     //  {{{ setRelationSelect()
  1109.     /** Enregistrement dans les table relationnelle
  1110.      *
  1111.      * Permet l'enregistrement multiple de valeur dans les tables
  1112.      * de relation
  1113.      *
  1114.      * @access   public
  1115.      * @param string $table Nom de la table de relation
  1116.      * @param string $key Clé dans le tableau
  1117.      * @param string $col Colonne
  1118.      * @param array $array_values Valeur à enregistrer
  1119.      * @param int $id Id de l'enregistrement principal
  1120.      * @return   bool
  1121.      */
  1122.     public function setRelationSelect($table, $key, $col, $array_values, $id, $allRights = true, $sup_key = array(), $save_order = array())
  1123.     {
  1125.         $dbco = $this->getEntityManager()->getConnection();
  1127.         if ($allRights) {
  1128.             $rights = array('update' => 1);
  1129.         }
  1131.         if ($this->isCheckRights() || !$allRights) {
  1132.             $extranetusers = $this->getEntityManager()->getRepository(Extranetusers::class);
  1133.             $rights = $extranetusers->getRights();
  1134.         }
  1136.         if (isset($rights) && $rights['update'] == 1) {
  1138.             // on supprime puis on insère (replace ne marche pas)
  1139.             $sql_del = 'DELETE FROM ' . $table . ' WHERE ' . $col . '=\'' . $id . '\'';
  1141.             // aussi le role
  1142.             if (!empty($sup_key)) {
  1143.                 foreach ($sup_key as $k => $v) {
  1144.                     $sql_del .= ' AND ' . htmlspecialchars($k) . '=' . $this->escape($v);
  1145.                 }
  1146.             }
  1148.             $del = $dbco->exec($sql_del);
  1150.             // si array_values est vide, c'est qu'on veux supprimer ?
  1151.             if (empty($array_values)) {
  1152.                 return true;
  1153.             }
  1155.             if (!is_array($array_values)) {
  1156.                 $array_values_stack = $array_values;
  1157.                 $array_values = array();
  1158.                 $array_values[] = $array_values_stack;
  1159.             }
  1161.             // on prepare l'insertion
  1162.             $sql = 'INSERT INTO ' . $table . ' (' . $key . ', ' . $col;
  1164.             // le role NON UTILISE ???
  1165.             if (!empty($sup_key)) {
  1166.                 foreach ($sup_key as $k => $v) {
  1167.                     $sql_keys[] = $k;
  1168.                     $sql_values[] = strip_tags($v);
  1169.                 }
  1170.             }
  1172.             // le classement
  1173.             if (!empty($save_order)) {
  1174.                 $sql_keys[] = $save_order['order_field'];
  1175.                 $sql_values[] = '?';
  1176.             }
  1178.             // ajout des clés en plus
  1179.             if (!empty($sql_keys)) {
  1180.                 $sql .= ', ' . join(',', $sql_keys);
  1181.             }
  1183.             $sql .= ') VALUES ( ?, ?';
  1185.             // ajout des valeurs en plus
  1186.             if (!empty($sql_values)) {
  1187.                 $sql .= ', ' . join(',', $sql_values);
  1188.             }
  1190.             $sql .= ')';
  1192.             $i = 1;
  1193.             foreach ($array_values as $key => $value) {
  1194.                 if ($save_order) {
  1195.                     $prep_values = array($value, $id, $i);
  1196.                     $res = $dbco->executeQuery($sql, $prep_values);
  1197.                 } else {
  1198.                     $prep_values = array($value, $id);
  1200.                     $res = $dbco->executeQuery($sql, $prep_values);
  1201.                 }
  1202.                 $i++;
  1203.             }
  1205.             if (!empty($res)) {
  1206.                 return $res;
  1207.             } else {
  1208.                 return false;
  1209.             }
  1210.         }
  1211.     }
  1213.     // }}}
  1215.     //  {{{ deleteDataRelation()
  1217.     /** Suppression
  1218.      *
  1219.      * Permet de supprimer l'enregistrement dans une relation
  1220.      *
  1221.      * @access   public
  1222.      * @param int $id Id de l'enregistrement principal
  1223.      * @param string $table Nom de la table de relation
  1224.      * @param string $key Clé dans la tableau
  1225.      * @return   bool
  1226.      */
  1227.     public function deleteDataRelation($table, $key, $id, $key_relation = null, $id_relation = null, $object = null, $objectvalue = null, $allRights = true)
  1228.     {
  1230.         if ($allRights) {
  1231.             $rights = array('delete' => 1);
  1232.         }
  1234.         if ($this->isCheckRights() || !$allRights) {
  1235.             $extranetusers = Theatre_Extranetusers::factory('extranetusers');
  1236.             $rights = $extranetusers->getRights();
  1237.         }
  1239.         if (isset($rights) && $rights['delete'] == 1) {
  1240.             $req = 'DELETE FROM ' . $table . '
  1241.                     WHERE ' . $key . '=\'' . $this->escape($id) . '\'';
  1243.             if (!empty($object)) {
  1244.                 $req .= ' AND ' . $object . '=\'' . $this->escape($objectvalue) . '\'';
  1246.                 if (!empty($key_relation)) {
  1247.                     $req .= ' AND ' . $key_relation . '=\'' . $this->escape($id_relation) . '\'';
  1248.                 }
  1249.             }
  1251.             $conn = $this->getEntityManager()->getConnection();
  1253.             //echo 'query : $req<br/>';
  1254.             //executer la requete
  1255.             $del = $conn->prepare($req);
  1256.             $del->execute();
  1258.             // logguer les delete
  1259.             $this->logDeletion($req);
  1261.             return true;
  1262.         } else {
  1263.             throw new \Exception($GLOBALS['tr']->get('no_right') . 'deleteDataRelation');
  1264.         }
  1266.     }
  1268.     // }}}
  1270.     //  {{{ getInforelation()
  1272.     /** Permet de récupérer les relations qui sont liées lors d'une suppression
  1273.      *
  1274.      * FIXME: à revoir totalement
  1275.      *
  1276.      * @access   public
  1277.      * @param string $table Relation a vérifier
  1278.      * @param string $id Clé dans la tableau
  1279.      * @return   array   $datadelete       Tableau des données
  1280.      */
  1281.     public function getInfoRelation($relation, $id, $retour = null)
  1282.     {
  1283.         //traductions
  1284.         $tr = $this->translator;
  1286.         //nombre d'enregistrements trouvés
  1287.         $nbdata = 0;
  1288.         $compteur = 0;
  1290.         //parcourir chaque requete
  1291.         foreach ($relation as $key => $value) {
  1293.             //compteur
  1294.             $compteur++;
  1296.             $lien = $value[3];
  1298.             //selection simple
  1299.             $req = 'SELECT DISTINCT(' . $value[2] . ') AS clevue,' . $value[0] . ' FROM ' . $key . ' WHERE ' . $value[1] . '=\'' . $id . '\'';
  1300.             if (!empty($value[6])) {
  1301.                 $req .= ' ' . $value[6];
  1302.             }
  1304.             $tab = $this->queryAll($req);
  1305.             if ($retour) {
  1306.                 return $tab;
  1307.             }
  1309.             if ($tab) {
  1310.                 //créer un tableau vide
  1311.                 $tabdata = array();
  1313.                 //mise en forme de la réponse
  1314.                 foreach ($tab as $cle => $valeur) {
  1316.                     //enregistrement trouvés
  1317.                     foreach ($valeur as $clevaleur => $valeurvaleur) {
  1318.                         //conserver la clé
  1319.                         if ('clevue' == $clevaleur) {
  1320.                             //stocker les valeurs dans le tableau
  1321.                             $cle = $valeurvaleur;
  1322.                         }
  1323.                         //conserver l'attribut à afficher
  1324.                         if ($value[0] == $clevaleur) {
  1325.                             //vérifier si on a une fonction liée pour l'affichage
  1326.                             if (!empty($value[5])) {
  1327.                                 $fonctionliee = $value[5];
  1328.                             }
  1329.                             //on veut utiliser une autre fonction pour récupérer le champ de l'objet à afficher
  1330.                             if (!empty($fonctionliee)) {
  1331.                                 //instancier un objet correspondant
  1332.                                 $object = $this->getEntityManager()->getRepository('TheatreCore\Entity\\' . ucfirst($value[4]));
  1333.                                 //déclencher la fonction souhaitée
  1334.                                 $affichage = $object->$fonctionliee($cle);
  1335.                                 //mettre notre nouvelle valeur
  1336.                                 $valeurvaleur = $affichage;
  1337.                                 //clé pour déclencher la bonne action dans le lien
  1338.                                 $key = $value[4];
  1339.                             }
  1341.                             //stocker les valeurs dans le tableau sous forme de lien ou pas
  1342.                             if ($lien) {
  1343.                                 $tabdata[] = array('link' => $key . '/edit/id/' . $cle, 'field' => $valeurvaleur);
  1344.                             } else {
  1345.                                 $tabdata[] = array('link' => '', 'field' => $valeurvaleur);
  1346.                             }
  1347.                             $nbdata++;
  1348.                             break;
  1349.                         }
  1350.                     }
  1351.                 }
  1352.                 //stocker le nouveau tableau (avec un nom unique donc utilisation du compteur)
  1353.                 $datadelete[$key . '_' . $compteur] = $tabdata;
  1354.                 $compteur++;
  1355.             }
  1357.         }
  1359.         //si on a des enregistrements, retourner le tableau, sinon retourner le tableau vidé
  1360.         if ($nbdata > 0) {
  1361.             $compteur = 0;
  1362.             //mettre en forme les donnees
  1363.             foreach ($datadelete as $key => $value) {
  1364.                 //enlever le _ et le chiffre ex : texts_3 devient texts et on recupere la traduction
  1365.                 $type = substr($key, 0, strrpos($key, '_'));
  1366.                 //echo 'key $key<br/>';
  1367.                 //mettre en forme les données si elles sont présentes
  1368.                 if (!empty($value)) {
  1369.                     $tabtraduction[$tr->trans('text_title_' . $type) . $compteur] = array($key => $value);
  1370.                 }
  1371.                 $compteur++;
  1372.             }
  1373.             return $tabtraduction;
  1374.         } else {
  1375.             return array();
  1376.         }
  1377.     }
  1379.     // }}}
  1381.     //  {{{ getRelationsArray()
  1383.     /** Tableau des relations
  1384.      *
  1385.      * Relations communes, sinon, redéfini dans la classe fille
  1386.      *
  1387.      * @access   public
  1388.      * @param string $type all/autre info sur une relation précise
  1389.      * @return   array   $array_types       Tableau des relations / de la relation
  1390.      */
  1391.     public function getRelationsArray($type)
  1392.     {
  1394.         $array_types = array(
  1395.             // bookmark_extranetuser idobject/object
  1396.             'bookmark_extranetuser' => array(// enregistrement bookmarké
  1397.                 'type_join' => 'multiple',
  1398.                 'dest_table' => 'extranetusers',
  1399.                 'join_table' => 'bookmark_extranetuser_by_object',
  1400.                 'fields' => array('idextranetuser', 'lastname', 'login', 'email'),
  1401.                 'description' => 'Utilisateur(s) ayant bookmarké cet enregistrement',
  1402.                 'silent_delete_relation' => true,
  1403.                 'do_constraint' => 'bookmark_extranetuser',
  1404.             ),
  1405.             // comments idobject/object
  1406.             'comments' => array(// commentaires sur l'enregistrement
  1407.                 'type_join' => 'simple',
  1408.                 'dest_table' => 'comments',
  1409.                 'dest_table_field' => 'idobject', // link également avec object
  1410.                 'fields' => array('idcomment', 'lastnamefirstname', 'comment', 'module'),
  1411.                 'description' => 'Commentaire(s) lié(s) à cet enregistrement',
  1412.                 'silent_delete_relation' => true,
  1413.                 'do_constraint' => true,
  1414.             ),
  1415.             // faqgroups idobject/object
  1416.             'faqgroups' => array(// faq sur cet enregistrement
  1417.                 'type_join' => 'simple',
  1418.                 'dest_table' => 'faqgroups',
  1419.                 'dest_table_field' => 'idobject', // link également avec object
  1420.                 'fields' => array('idfaqgroup', 'module', 'title'),
  1421.                 'description' => 'Faq(s) liée(s) à cet enregistrement',
  1422.                 'do_constraint' => true,
  1423.             ),
  1424.             // object_content idobject/object
  1425.             'object_content' => array(// contenus associé à cet enregistrement
  1426.                 'type_join' => 'multiple',
  1427.                 'dest_table' => 'contents',
  1428.                 'join_table' => 'object_content',
  1429.                 'fields' => array('idcontent', 'title', 'text'),
  1430.                 'description' => 'Contenu(s) associé(s) à l\'enregistrement (méthode 2)',
  1431.                 'do_constraint' => true,
  1432.             ),
  1433.             // object_file idobject/object
  1434.             'object_file' => array(// fichiers associés à cet enregistrement
  1435.                 'type_join' => 'multiple',
  1436.                 'dest_table' => 'files',
  1437.                 'join_table' => 'object_file',
  1438.                 'fields' => array('idfile', 'title', 'file'),
  1439.                 'description' => 'Fichier(s) associé(s) à l\'enregistrement',
  1440.                 'do_constraint' => true,
  1441.             ),
  1442.             // object_multimedia idobject/object
  1443.             'object_multimedia' => array(// multimedias associés à cet enregistrement
  1444.                 'type_join' => 'multiple',
  1445.                 'dest_table' => 'multimedias',
  1446.                 'join_table' => 'object_multimedia',
  1447.                 'fields' => array('idmultimedia', 'sujet_titre', 'description'),
  1448.                 'description' => 'Document(s) multimedia(s) associé(s) à cet enregistrement',
  1449.                 'do_constraint' => true,
  1450.             ),
  1451.             // quizgroups idobject/object
  1452.             'quizgroups' => array(// commentaires sur des contacts
  1453.                 'type_join' => 'simple',
  1454.                 'dest_table' => 'quizgroups',
  1455.                 'dest_table_field' => 'idobject', // link également avec object
  1456.                 'fields' => array('idquizgroup', 'module', 'description'),
  1457.                 'description' => 'Quiz(s) lié(s) à ce contact',
  1458.                 'do_constraint' => true,
  1459.             ),
  1460.             // user_action idobject/object (obligatoire)
  1461.             'user_action' => array(// action sur cette fiche
  1462.                 'type_join' => 'multiple',
  1463.                 'dest_table' => 'extranetusers',
  1464.                 'join_table' => 'user_action_by_object',
  1465.                 'fields' => array('idextranetuser', 'login', 'email'),
  1466.                 'description' => 'Utilisateur(s) ayant travaillé(s) ce contact',
  1467.                 'silent_delete_relation' => true,
  1468.                 'hide_relation' => true,
  1469.                 'do_constraint' => 'user_action',
  1470.             ),
  1471.             // stats idobject/object (obligatoire)
  1472.             /*'stats' => array(// statistiques sur cette fiche
  1473.                  'type_join' => 'multiple',
  1474.                  'dest_table' => 'stats',
  1475.                  'join_table' => 'stats_by_object',
  1476.                  'fields' => array('idstat','object','idobject'),
  1477.                  'description' => 'Statistique(s) sur cet objet',
  1478.                  'silent_delete_relation' => true,
  1479.                  'hide_relation' => true,
  1480.                  'do_constraint' => 'stats',
  1481.              ),
  1482.              // stats idobject/object (obligatoire)
  1483.             'statscumul' => array(// statistiques sur cette fiche
  1484.                  'type_join' => 'multiple',
  1485.                  'dest_table' => 'statscumul',
  1486.                  'join_table' => 'statscumul_by_object',
  1487.                  'fields' => array('idstat','object','idobject'),
  1488.                  'description' => 'Statistique(s) sur cet objet (cumul)',
  1489.                  'silent_delete_relation' => true,
  1490.                  'hide_relation' => true,
  1491.                  'do_constraint' => 'statscumul',
  1492.              ),*/
  1493.         );
  1495.         if ($type == 'all') {
  1496.             return $array_types;
  1497.         } else {
  1498.             return null;
  1499.         }
  1501.     }
  1503.     // }}}
  1505.     /** checker toutes les relations d'un objet
  1506.      *
  1507.      * @param int $idobject Id de l'objet
  1508.      * @param string $object Type d'objet
  1509.      * @param stringa $filtre Filtrer les éléments à ne pas afficher
  1510.      * @return      array
  1511.      * @access      public
  1512.      */
  1513.     public function checkAllRelations($idobject, $object, $filtre = null)
  1514.     {
  1516.         $linked_items = array();
  1518.         // on boucle sur le tableau des relations
  1519.         $infos_links = $this->getRelationsArray('all');
  1521.         foreach ($infos_links as $k => $v) {
  1522.             if (empty($v['hide_relation'])) {
  1524.                 // les items liés
  1525.                 $items = $this->getLinkedObject($v, $idobject, $k, $object);
  1527.                 if (!empty($items) and !empty($v['dest_table'])) {
  1529.                     $infos_linked = array(
  1530.                         'description' => $v['description'],
  1531.                         'object' => $v['dest_table'],
  1532.                     );
  1534.                     // pour le calendrier, on affiche seulement un message
  1535.                     if (!empty($v['only_message'])) {
  1536.                         $infos_linked['message'] = count($items);
  1537.                     } else {
  1538.                         $infos_linked['values'] = $items;
  1539.                     }
  1541.                     // ne pas afficher les liens d'é"ditions"'
  1542.                     if (!empty($v['no_edit_links'])) {
  1543.                         $infos_linked['no_edit_links'] = true;
  1544.                     }
  1545.                     // afficher les liens de destinationation
  1546.                     if (!empty($v['dest_table_field'])) {
  1547.                         $infos_linked['dest_table_field'] = $v['dest_table_field'];
  1548.                     }
  1550.                     // filtrer par silent_delete_relation
  1551.                     if (!empty($filtre)) {
  1552.                         // sépare ceux qui sont effacé sans préavis et les autres
  1553.                         if (!empty($v['silent_delete_relation'])) {
  1554.                             $linked_items['silent'][$k] = $infos_linked;
  1555.                         } else {
  1556.                             $linked_items['check'][$k] = $infos_linked;
  1557.                         }
  1558.                     } else {
  1559.                         $linked_items[$k] = $infos_linked;
  1560.                     }
  1562.                 }
  1563.             }
  1564.         }
  1566.         return $linked_items;
  1568.     }
  1570.     // }}}
  1572.     //  {{{ isOnline()
  1574.     /** En ligne ou hors ligne
  1575.      *
  1576.      * Permet de vérifier si un enregistrement est en ligne ou pas
  1577.      *
  1578.      * @param int $id Valeur du champ index pour l'enregistrement
  1579.      * @return      boolean
  1580.      * @access      public
  1581.      */
  1582.     public function isOnline($id)
  1583.     {
  1584.         return $this->publish != 0;
  1585.     }
  1587.     // }}}
  1589.     //  {{{ setStatus()
  1591.     /** Change le statut en ligne ou hors ligne
  1592.      *
  1593.      * La pluspart du temps, mets à yes ou no le champ 'publish'
  1594.      *
  1595.      * @param int $id Valeur du champ index pour l'enregistrement
  1596.      * @return      boolean
  1597.      * @access      public
  1598.      */
  1599.     public function setStatus($id = null, $status = 1, $field = null, $allRights = true)
  1600.     {
  1601.         // on a les droits de changer le status ?
  1602.         if ($allRights) {
  1603.             $rights = array('isadmin' => 1);
  1604.         }
  1606.         if ($this->setCheckRights() || !$allRights) {
  1607.             $extranetusers = Theatre_Extranetusers::factory('extranetusers');
  1608.             $rights = $extranetusers->getRights();
  1609.         }
  1611.         if (isset($rights) && $rights['isadmin'] == 1) {
  1613.             if (empty($id)) {
  1614.                 $id = $this->id;
  1615.             }
  1617.             if (empty($field)) {
  1618.                 $field = 'publish';
  1619.             }
  1621.             // champ à mettre à jour
  1622.             $this->selectAdd();
  1623.             $this->selectAdd($field);
  1624.             $this->get($id);
  1625.             $this->$field = $status;
  1627.             return $this->update();
  1629.         } else {
  1630.             throw new \Exception($GLOBALS['tr']->get('no_rights') . ' setStatus');
  1631.         }
  1633.     }
  1635.     // }}}
  1637.     //  {{{ setPublishStatus()
  1639.     /** Définir si on veut les contenus publiés ou pas
  1640.      *
  1641.      * Par défaut => tous
  1642.      *
  1643.      * @access   public
  1644.      * @param int $publish 1 = publie, 0 = non publie, 2 = tous
  1645.      */
  1646.     public function setPublishStatus($publish_status = 2)
  1647.     {
  1648.         $this->publish_status = $publish_status;
  1649.     }
  1651.     // }}}
  1653.     //  {{{ getCountry()
  1655.     /** Récupére le nom d'un pays
  1656.      *
  1657.      *
  1658.      * @access   public
  1659.      * @param string $code Le code du pays
  1660.      * @return   string
  1661.      */
  1662.     public function getNameCountry($code = null)
  1663.     {
  1664.         if ($code) {
  1665.             if (!empty($this->countriesLoaded[$code])) {
  1666.                 return $this->countriesLoaded[$code];
  1667.             }
  1669.             $country = $this->queryOne('SELECT fr FROM countries WHERE id=\'' . $code . '\'');
  1670.             $this->countriesLoaded[$code] = $country;
  1671.             return $country;
  1672.         }
  1673.     }
  1675.     // }}}
  1677.     // {{{ getCachedList()
  1679.     /** Méthode générique pour les listes, avec mise en cache
  1680.      *
  1681.      *
  1682.      * @param string $name nom de la liste
  1683.      * @param string $req la requête pour obtenir la liste
  1684.      * @param boolean $order utilisé form_def
  1685.      * @param string $form_def clé langterms pour la valeur par défaut (tête de liste)
  1686.      * @access protected
  1687.      * @return array    la liste
  1688.      */
  1689.     protected function getCachedList($name, $req, $order = true, $form_def = null, $clear = true)
  1690.     {
  1691.         // cache
  1692. //        require_once PATH_LIBS.'Cache/Theatre_cache.php';
  1694. //        $optCache = array(
  1695. //            'cacheDir' => PATH_TMP.'other/',
  1696. //            'lifeTime' => 3600*24,
  1697. //            'fileNameProtection' => false,
  1698. //        );
  1699. //        $c = new Theatre_cache($optCache);
  1701.         $id = $name . '_fr' . ((int)$order);
  1703.         // vider le cache si on le demande ou si cache désacvtiver avec USE_CACHE
  1704. //        if($this->canUpdateCache($name) || !USE_CACHE) {
  1705. //            $c->remove($id);
  1706. //        }
  1708.         // il y a le cache
  1709. //        if ($data = $c->get($id)) {
  1710. //            return unserialize($data);
  1711. //        }
  1713.         // pas en cache, on execute la requête
  1714.         $list = $this->queryAll($req, array(), null, true);
  1716.         //Placeolder obselète.
  1717. //        if($order && $form_def) {
  1718. //            array_unshift($list, $this->translator->trans($form_def));
  1719. //        }
  1721.         if ($clear) {
  1722.             foreach ($list as $key => $value) {
  1723.                 if (is_array($value)) {
  1724.                     $list[$key] = reset($value);
  1725.                 } else {
  1726.                     $list[$key] = $value;
  1727.                 }
  1728.             }
  1729.         }
  1731.         $list = array_flip($list);
  1733.         // sauvegarde la liste dans le cache
  1734. //        $c->save(serialize($list));
  1736.         return $list;
  1737.     }
  1739.     // }}}
  1741.     // {{{ getCachedListForCountries()
  1743.     /** Méthode générique pour les listes, avec mise en cache
  1744.      * Modifiée car ne fonctionnait comme souhaité pas pour la liste des pays
  1745.      *
  1746.      *
  1747.      * @param string $name nom de la liste
  1748.      * @param string $req la requête pour obtenir la liste
  1749.      * @param boolean $order utilisé form_def
  1750.      * @param string $form_def clé langterms pour la valeur par défaut (tête de liste)
  1751.      * @access protected
  1752.      * @return array    la liste
  1753.      */
  1754.     protected function getCachedListForCountries($name, $req, $order = true, $form_def = null, $clear = true)
  1755.     {
  1757.         $id = $name . '_fr' . ((int)$order);
  1759.         // pas en cache, on execute la requête
  1760.         $list = $this->queryAll($req, array(), null, true);
  1761.         $listToReturn = [];
  1762.         if ($clear) {
  1763.             foreach ($list as $key => $value) {
  1764.                 if (is_array($value)) {
  1765.                     $listToReturn[reset($value)] = $value['id'];
  1766.                 }
  1767.             }
  1768.         }
  1770.         return $listToReturn;
  1771.     }
  1773.     // }}}
  1775.     //  {{{ getCountryList()
  1777.     /** Récupére la liste des pays
  1778.      *
  1779.      * Récupére tous les pays pour les listes
  1780.      * déroulantes par exemple (mis en cache)
  1781.      *
  1782.      * @access   public
  1783.      * @return   array
  1784.      * @see      getCountry()
  1785.      */
  1786.     public function getCountryList($order = true)
  1787.     {
  1788.         $name = 'country_list';
  1789. //        $req = 'SELECT id,' . $GLOBALS['lng'] . ' FROM countries ORDER BY orderby,' . $GLOBALS['lng'];
  1790.         $req = 'SELECT ' . $GLOBALS['lng'] . ', id FROM countries ORDER BY orderby,' . $GLOBALS['lng'];
  1791.         $form_def = 'form_def_country';
  1792.         return $this->getCachedListForCountries($name, $req, $order, $form_def);
  1793.     }
  1795.     // }}}
  1797.     //  {{{ getContinentList()
  1799.     /** Récupére la liste des continents
  1800.      *
  1801.      * Récupére tous les continents pour les listes
  1802.      * déroulantes par exemple
  1803.      *
  1804.      * @access   public
  1805.      * @return   array
  1806.      * @see      getCountry()
  1807.      */
  1808.     public function getContinentList($order = false)
  1809.     {
  1810.         $name = 'continent_list';
  1811.         $req = 'SELECT id,fr FROM continents';
  1812.         $form_def = null;
  1813.         return $this->getCachedList($name, $req, $order, $form_def);
  1814.     }
  1816.     // }}}
  1818.     //  {{{ getLanguageList()
  1820.     /** Récupére toutes les langues
  1821.      *
  1822.      * Récupére toutes les langues pour les listes
  1823.      * déroulantes par exemple
  1824.      *
  1825.      * @access   public
  1826.      * @return   array
  1827.      * @see      getLanguage()
  1828.      */
  1829.     public function getLanguageList($order = true)
  1830.     {
  1831.         $name = 'language_list';
  1832.         $req = 'SELECT id,fr FROM languages ORDER BY orderby,fr';
  1833.         $form_def = 'form_def_language';
  1834.         return $this->getCachedList($name, $req, $order, $form_def);
  1835.     }
  1837.     // }}}
  1839.     //  {{{ getItemsList()
  1841.     /** Récupération des items dans les champs relation_select
  1842.      *
  1843.      * @access public
  1844.      * @param  $idobject Identifiant de l'objet
  1845.      * @param  $type Type de données à récupérer
  1846.      * @return string
  1847.      */
  1848.     public function getItemsList($idobject = null, $type, $src = null)
  1849.     {
  1851.         $infos_link = $this->getRelationsArray($type);
  1853.         // retourne le tableau des items liés
  1854.         if (!empty($infos_link)) {
  1855.             $itemslist = $this->getLinkedObject($infos_link, $idobject, $infos_link['type'], $this->__table);
  1856.             return $itemslist;
  1857.         }
  1859.         return 'Aucune fonction de recherche pour le type <strong>' . $type . '</strong> dans la méthode !';
  1861.     }
  1863.     // }}}
  1865.     //  {{{ getLanguage()
  1867.     /** Récupére le nom d'une langue
  1868.      *
  1869.      *
  1870.      * @access   public
  1871.      * @param string $code Le code de la langue
  1872.      * @return   string
  1873.      */
  1874.     public function getNameLanguage($code = null, $lng = null)
  1875.     {
  1876.         // renvoyer dans la langue
  1877.         if ($lng) {
  1878.             $field = $lng;
  1879.         } else {
  1880.             $field = $GLOBALS['lng'];
  1881.         }
  1883.         if ($code) {
  1884.             return $this->queryOne('SELECT ' . $field . ' FROM languages WHERE id=\'' . $code . '\'');
  1885.         }
  1887.     }
  1889.     // }}}
  1891.     //  {{{ colorAlternate()
  1893.     /** Alternance des couleurs
  1894.      *
  1895.      * permet d'alterner les couleurs dans les les tableaux de données
  1896.      *
  1897.      * @access   public
  1898.      * @param    $color  La couleur en cours
  1899.      * @return   string
  1900.      */
  1901.     public function colorAlternate($color)
  1902.     {
  1904.         if (!isset($color) || $color == 'two') {
  1905.             return 'one';
  1906.         } else {
  1907.             return 'two';
  1908.         }
  1910.     }
  1912.     // }}}
  1914.     //  {{{ cutSentence()
  1916.     /** Coupe une phrase
  1917.      *
  1918.      * coupe un phrase et colle les petits points
  1919.      *
  1920.      * @access   public
  1921.      * @param string $texte le texte a couper
  1922.      * @param int $nbcar le nombre de cacractère
  1923.      * @return   string
  1924.      */
  1925.     public function cutSentence($texte, $nbcar = null, $simple = null)
  1926.     {
  1928.         // taille
  1929.         $taille_texte = strlen($texte);
  1931.         if ($simple) {
  1932.             $new_texte = mb_substr($texte, 0, $nbcar);
  1933.             if ($taille_texte > strlen($new_texte)) {
  1934.                 return $new_texte . '...';
  1935.             } else {
  1936.                 return $new_texte;
  1937.             }
  1938.         }
  1940.         if ($taille_texte > $nbcar && (0 != $nbcar)) {
  1942.             $Tmp_Tb = explode(' ', $texte);
  1943.             $Tmp_Count = 0;
  1944.             $Tmp_O = '';;
  1946.             foreach ($Tmp_Tb as $key) {
  1947.                 if (strlen($Tmp_O) >= $nbcar) break;
  1948.                 $Tmp_O .= $key . ' ';
  1949.             }
  1951.             $Tmp_O = substr($Tmp_O, 0, strlen($Tmp_O) - 1);
  1952.             if (count($Tmp_Tb) > 1)
  1954.                 $Tmp_O .= '...';
  1956.         } else {
  1957.             $Tmp_O = $texte;
  1958.         }
  1960.         return $Tmp_O;
  1961.     }
  1963.     // }}}
  1965.     //  {{{ getFormeDate()
  1967.     /** Mise en forme de la date pour entree ou sortie
  1968.      *
  1969.      *
  1970.      * @access   public
  1971.      * @param string $dateentree date en entree
  1972.      * @param string $sortie format de sortie
  1973.      * @return   string
  1974.      */
  1975.     public function getFormeDate($dateentree, $sortie = 'Y-m-d', $st = false)
  1976.     {
  1978.         // si il y a des / = format FR
  1979.         if (gettype($dateentree) == 'string') {
  1980.             $exp = explode('/', $dateentree);
  1981.             if (count($exp) > 1) {
  1982.                 $dateentree = $exp[2] . '-' . $exp[1] . '-' . $exp[0];
  1983.             }
  1984.             if ($st) {
  1985.                 setLocale(LC_TIME, "fr_FR.utf8");
  1986.                 /* @Deprecated in php 8.1 */
  1987.                 return strftime($sortie, strtotime($dateentree));
  1988.             } else {
  1989.                 return date($sortie, strtotime($dateentree));
  1990.             }
  1991.         } else if (!empty($dateentree)) {
  1993.             $fmt = datefmt_create(
  1994.                 'fr_FR',
  1995.                 \IntlDateFormatter::FULL,
  1996.                 \IntlDateFormatter::FULL,
  1997.                 'Europe/Paris',
  1998.                 \IntlDateFormatter::GREGORIAN,
  1999.                 "EEEE d MMMM y"
  2000.             );
  2002.             return $fmt->format($dateentree);
  2003.         }
  2004.     }
  2006.     // }}}
  2008.     //  {{{ getYear()
  2010.     /** Retourne l'année pour une date donnée
  2011.      *
  2012.      * @access   public
  2013.      * @param string $date date
  2014.      * @param string $fmt format (date()) 'Y' par défaut
  2015.      * @return   string|boolean  false si erreur, l'annee sinon
  2016.      */
  2017.     public function getYear($date = null, $fmt = 'Y')
  2018.     {
  2019.         if (!empty($date)) {
  2020.             $timestamp = strtotime($date);
  2021.             if ($timestamp !== false) {
  2022.                 $year = date($fmt, $timestamp);
  2023.                 if ((int)$year !== 0) return $year;
  2024.             }
  2025.         }
  2027.         return false;
  2028.     }
  2030.     // }}}
  2032.     //  {{{ getThumbnail()
  2034.     /** Crée les images redimensionnee
  2035.      *
  2036.      * Cree des images a la taille voulue et les mets dans le reprertoire de la taille en question
  2037.      * cree le rep si il n'existe pas, renvoi l'image simplement si elle exsiste
  2038.      *
  2039.      * @access   public
  2040.      * @param imgfile string Image originale
  2041.      * @return   array
  2042.      * @see      Theatre_Images::getThumbnail
  2043.      *
  2044.      */
  2045.     public function getThumbnail($imgfile, $thumb_size = 100, $direction = 'normal', $params = array())
  2046.     {
  2047.         return $this->images->getThumbnail($imgfile, $thumb_size, $direction, $params);
  2049.     }
  2051.     // }}}
  2053.     //  {{{ checkAccess()
  2055.     /** Verifier l'acces pour la partie public
  2056.      *
  2057.      * @access   public
  2058.      * @return   string
  2059.      */
  2060.     public function checkAccess($sql, $tabdroits)
  2061.     {
  2062.         // verifier la langue
  2063.         if ((IS_LANGUAGE || !empty($this->checkLanguage))
  2064.             && !empty($tabdroits['language'])) {
  2065.             $sql .= ' AND ' . $tabdroits['language'] . '=\'' . $GLOBALS['lng'] . '\'';
  2066.         }
  2068.         // verifier la presence en ligne
  2069.         if ($_ENV['CHECK_IF_ONLINE'] && !empty($tabdroits['publish'])) {
  2070.             $sql .= ' AND ' . $tabdroits['publish'] . '=1';
  2071.         }
  2073.         return $sql;
  2074.     }
  2076.     // }}}
  2078.     //  {{{ checkLanguage()
  2080.     /** Verifier la langue
  2081.      *
  2082.      * @access   public
  2083.      * @return   string
  2084.      */
  2085.     public function setCheckLanguage($val = true)
  2086.     {
  2087.         // verifier la langue
  2088.         $this->checkLanguage = $val;
  2089.     }
  2091.     // }}}
  2093.     //  {{{ wikiTransform()
  2095.     /** Transformer les champs wiki en html
  2096.      *
  2097.      * @access   public
  2098.      * @param string $str chaine au format wiki
  2099.      * @return   string
  2100.      */
  2101.     public function wikiTransform($str, $markdown = false)
  2102.     {
  2103.         if ($markdown) {
  2104.             $parser = new MarkdownExtra();
  2105.             return $parser->transform($str);
  2106.         }
  2108.         $wiki = new wiki2xhtml();
  2109.         return $wiki->transform($str);
  2110.     }
  2112.     // }}}
  2114.     //  {{{ getUrlClean()
  2116.     /** Retourne l"url clean d'un objet
  2117.      *
  2118.      * @access   public
  2119.      * @return bool
  2120.      */
  2121.     public function getUrlClean($idobject, $object)
  2122.     {
  2124.         $idx = 'id' . substr($object, 0, -1);
  2125.         return $this->queryOne('SELECT url_clean FROM ' . $object . ' WHERE ' . $idx . '=\'' . $idobject . '\'');
  2127.     }
  2129.     // }}}
  2131.     //  {{{ getIdByUrl()
  2133.     /** Retourne l'id d'un objet à partir de son url
  2134.      *
  2135.      * @access   public
  2136.      * @param string $url_clean L'URL
  2137.      * @return false|int
  2138.      */
  2139.     public function getIdByUrl($url_clean, $strict = true, $return_array = false, $operator = '=')
  2140.     {
  2141.         // recherche strict = pâs de résultat aprochant = un seul résultat ou rien
  2142.         if ($strict) {
  2143.             // multimedias
  2144.             if ($this->__table == 'multimedias') {
  2145.                 $sql_id = 'SELECT DISTINCT(`' . $this->__idtable . '`)  as id, url_clean
  2146.                            FROM ' . $this->__table . '
  2147.                            WHERE url_clean' . $operator . '\'' . $this->escape($url_clean) . '\'
  2148.                            OR code=\'' . $this->escape($url_clean) . '\' ';
  2149.             } else {
  2150.                 $sql_id = 'SELECT DISTINCT(`' . $this->__idtable . '`)  as id, url_clean
  2151.                            FROM ' . $this->__table . '
  2152.                            WHERE url_clean' . $operator . '\'' . $this->escape($url_clean) . '\' ';
  2153.             }
  2155.             if ($return_array) {
  2156.                 $id = $this->queryAll($sql_id);
  2158.                 return $id;
  2159.             } else {
  2160.                 $id = $this->queryOne($sql_id);
  2162.                 if ($id && $id > 0) {
  2163.                     return $id;
  2164.                 }
  2166.                 return false;
  2167.             }
  2169.             // recherche pouvant renvoyer plusieurs résultats
  2170.         } else {
  2172.             // convertit l'URL dans un bon format comme dans la base
  2173.             if (!isset($this->ct)) {
  2174.                 $ct = new Cleantext($this->getEntityManager());
  2175.                 $this->ct = $ct;
  2176.             }
  2178.             // recherche prénom/nom ou nom/prénom
  2179.             if ($this->__table == 'persons') {
  2181.                 $urls = explode(' ', $url_clean);
  2183.                 if (count($urls) == 2) {
  2184.                     $sql_ids = 'SELECT DISTINCT(`' . $this->__idtable . '`) as id, url_clean
  2185.                                FROM ' . $this->__table . '
  2186.                                WHERE
  2187.                                url_clean LIKE \'%' . $this->escape($ct->str2URL($urls[0] . '-' . $urls[1])) . '%\'
  2188.                                OR url_clean LIKE \'%' . $this->escape($ct->str2URL($urls[1] . '-' . $urls[0])) . '%\' ';
  2189.                 } else {
  2190.                     $sql_ids = 'SELECT DISTINCT(`' . $this->__idtable . '`) as id, url_clean
  2191.                                FROM ' . $this->__table . '
  2192.                                WHERE url_clean LIKE \'%' . $this->escape($ct->str2URL($url_clean)) . '%\' ';
  2193.                 }
  2195.             } else {
  2196.                 $sql_ids = 'SELECT DISTINCT(`' . $this->__idtable . '`) as id, url_clean
  2197.                            FROM ' . $this->__table . '
  2198.                            WHERE url_clean LIKE \'%' . $this->escape($ct->str2URL($url_clean)) . '%\' ';
  2199.             }
  2201.             $ids = $this->queryAll($sql_ids);
  2203.             if (!empty($ids)) {
  2204.                 return $ids;
  2205.             }
  2207.             return array();
  2209.         }
  2211.     }
  2213.     // }}}
  2215.     //  {{{ canUpdateCache()
  2217.     /** Peux t'on vider le cache ?
  2218.      *
  2219.      * @access   public
  2220.      * @return bool
  2221.      */
  2222.     public function canUpdateCache($type_cache = 'all')
  2223.     {
  2225.         if (isset($_GET['calcul'])
  2226.             && (isset($_COOKIE['delcache']) || isset($_SESSION['extranet']))
  2227.             && (isset($_GET['type_cache']) &&
  2228.                 ($_GET['type_cache'] == 'all' || $_GET['type_cache'] == $type_cache))
  2229.         ) {
  2230.             // A FAIRE : ecrire les caches qui sont vide dans un logs ?
  2231.             return true;
  2232.         }
  2234.         return false;
  2235.     }
  2237.     // }}}
  2239.     //  {{{ setDebugView()
  2241.     /** Enregistrer des informatons des debugages
  2242.      *
  2243.      * @access protected
  2244.      * @return bool
  2245.      */
  2246.     protected function setDebugView($debug, $methode)
  2247.     {
  2248.         $this->debug_view[] = $debug;
  2249.     }
  2251.     // }}}
  2253.     //  {{{ getDebugView()
  2255.     /** Consulter les informations de debugage
  2256.      *
  2257.      * @access public
  2258.      * @return bool
  2259.      */
  2260.     public function getDebugView($active = true)
  2261.     {
  2262.         if (isset($this->debug_view)) {
  2263.             return $this->debug_view;
  2264.         }
  2265.     }
  2267.     // }}}
  2269.     //  {{{ getObjectsList()
  2271.     /** Liste des valeurs acceptables du champ object
  2272.      *
  2273.      *
  2274.      * @access public
  2275.      * @param array $list liste optionnelle des valeurs acceptées
  2276.      * @return array
  2277.      * @see setValidObjects()
  2278.      */
  2279.     public function getObjectsList($list = null)
  2280.     {
  2281.         if (!empty($list)) {
  2282.             $this->setValidObjects($list);
  2283.         }
  2285.         $sql = 'SHOW COLUMNS FROM ' . $this->__table . ' WHERE Field = \'object\'';
  2287.         $res = $this->queryAll($sql);
  2289.         $tmp_object_values = array();
  2290.         if (isset($res[0]['Type'])) {
  2291.             $tmp_object_values = explode(',', substr($res[0]['Type'], 5, -1));
  2292.         }
  2293.         $possible_object_values = array();
  2294.         foreach ($tmp_object_values as $v) {
  2295.             $v = trim($v, '\''); // suppression des '' autour des valeurs
  2296.             if (empty($this->object_accept) || in_array($v, $this->object_accept)) {
  2297.                 $possible_object_values[$v] = ucfirst($v);
  2298.             }
  2299.         }
  2301.         return $possible_object_values;
  2302.     }
  2304.     // }}}
  2306.     //  {{{ setValidObjects()
  2308.     /** Définie les valeurs acceptables pour le champ object
  2309.      *
  2310.      *
  2311.      * @access public
  2312.      * @param array $list tableau des valeurs
  2313.      * @return array
  2314.      * @see getObjectsList()
  2315.      */
  2317.     public function setValidObjects($list = null)
  2318.     {
  2319.         if (empty($list) || !is_array($list)) {
  2320.             $this->object_accept = array();
  2321.             return;
  2322.         }
  2324.         $this->object_accept = $list;
  2325.     }
  2327.     // }}}
  2329.     // {{{ splitKeywords()
  2331.     /** Sépare les mots clés en deux listes: une contenant les nombres, et une autre contenant tout
  2332.      *
  2333.      *
  2334.      * @param string $keywords la chaine contenant les mots clés
  2335.      * @param string $separator le séparateur à utiliser (par défaut l'espace)
  2336.      * @access public
  2337.      * @return array|bool retourne un tableau contenant un ou deux sous-tableaux indexés par $this->IDNUM et $this->IDSTR
  2338.      */
  2339.     public function splitKeywords($keywords, $separator = ' ')
  2340.     {
  2341.         $list = array();
  2343.         if (!empty($keywords)) {
  2344.             $keywords_list = explode($separator, trim($keywords));
  2346.             if (!empty($keywords_list)) {
  2347.                 foreach ($keywords_list as $kw) {
  2348.                     if ($this->my_is_int($kw)) {
  2349.                         $list[$this->IDNUM][] = (int)$kw;
  2350.                     }
  2351.                     $kw = trim($kw);
  2352.                     if ($kw) {
  2353.                         $list[$this->IDSTR][] = $this->escape($kw);
  2354.                     }
  2355.                 }
  2356.             }
  2357.         }
  2359.         return $list;
  2360.     }
  2362.     // }}}
  2364.     //  {{{ getMultimediaList()
  2366.     /** Liste des multimedias associés à l'objet, pour les boites ajax_relation
  2367.      *
  2368.      *
  2369.      * @access  public
  2370.      * @param int $idobject identifiant de l'objet
  2371.      * @param string $type type recherché
  2372.      * @param boolean $only_published seulement les multimédias publiés (par défaut: false)
  2373.      * @return  array
  2374.      */
  2375.     public function getMultimediaList($idobject, $type, $only_published = false)
  2376.     {
  2377.         $infos = array();
  2379.         $query = 'SELECT m.idmultimedia, m.sujet_titre, m.publish FROM multimedias m, object_multimedia om
  2380.                   WHERE m.idmultimedia=om.idmultimedia';
  2382.         switch ($type) {
  2383.             case 'multimedia_content':
  2384.                 // on a deja l'id ?
  2385.                 if (empty($idobject)) {
  2386.                     $idobject = $this->idcontent;
  2387.                 }
  2389.                 $query .= ' AND om.object=\'contents\'';
  2390.                 break;
  2391.             case 'spectacle_trailer':
  2392.                 // on a deja l'id ?
  2393.                 if (empty($idobject)) {
  2394.                     $idobject = $this->idspectacle;
  2395.                 }
  2397.                 $query .= ' AND om.object=\'spectacles\'
  2398.                             AND om.idrole=24';
  2399.                 break;
  2400.             case 'text_trailer':
  2401.                 // on a deja l'id ?
  2402.                 if (empty($idobject)) {
  2403.                     $idobject = $this->idtext;
  2404.                 }
  2406.                 $query .= ' AND om.object=\'texts\'
  2407.                             AND om.idrole=24';
  2408.                 break;
  2410.             default:
  2411.                 error_log(__FUNCTION__ . ': Type inconnu:' . $type);
  2412.                 return false;
  2413.         }
  2415.         $query .= ' AND om.idobject=' . ((int)$idobject);
  2417.         if ($only_published) {
  2418.             $query .= ' AND m.publish=1';
  2419.         }
  2421.         $p = $this->query($query);
  2423.         foreach ($p as $r) {
  2424.             $key = $r['idmultimedia'];
  2425.             $infos[$key] = array('sujet_titre' => $r['sujet_titre']);
  2426.             $infos[$key]['view_name'] = &$infos[$key]['sujet_titre'];
  2427.             $infos[$key]['title'] = $infos[$key]['sujet_titre'] . ' (' . $key . ')';
  2428.             if (empty($r['publish'])) {
  2429.                 $infos[$key]['class'] = 'unpublished';
  2430.                 $infos[$key]['title'] .= ' - non publié';
  2431.             }
  2432.         }
  2434. //        $p->free();
  2436.         // retourner les infos
  2437.         return $infos;
  2438.     }
  2440.     // }}}
  2443.     //  {{{ getObjectsCarrerDetails()
  2445.     /** Message permettant de récupérer tous les détails des spectacles etc.
  2446.      *
  2447.      * @access   public
  2448.      * @param int $idobject Identifiant de l'item
  2449.      * @param string $object Type de contenu
  2450.      * @return   string
  2451.      */
  2452.     public function getObjectsCarrerDetails($idobject = null, $object = 'spectacles', ?AdapterInterface $cache = null)
  2453.     {
  2454. //        101 CRITIQUES
  2455. //        125 EDUC
  2457.         $totalVideos = $this->getEntityManager()->getRepository(Multimedias::class)->getMultimediasBy($object, $idobject, null, 'count');
  2458.         $totalAudios = $this->getEntityManager()->getRepository(Podcasts::class)->countPodcasts($object, $idobject, 'franceinter');
  2459.         $telechargements = $this->getEntityManager()->getRepository(Files::class)->countObjectFiles(
  2460.             $idobject, $object,
  2461.             $this->getEntityManager()->getRepository(Classifications::class)->getClassificationList('files', $object, null, array(1), 'get_value'),
  2462.             array(
  2463.                 'valid' => 1,
  2464.                 'publish' => 1,
  2465.                 'force_mode' => 'file',
  2466.             )
  2467.         );
  2469. //        $infos['ensavoirplus'] = 0;
  2471.         if ($object == 'persons') {
  2473.             // les objets
  2474.             $spectacles = $this->getEntityManager()->getRepository(Spectacles::class);
  2475.             $texts = $this->getEntityManager()->getRepository(Texts::class);
  2477.             $idpectacles = $texts->getTextsPersons($idobject);
  2479.             $sql_all_spectacles = 'SELECT DISTINCT s.`idspectacle`
  2480.                                FROM spectacles s
  2481.                                LEFT JOIN spectacle_person sp ON sp.`idspectacle`=s.`idspectacle`
  2482.                                LEFT JOIN text_spectacle ts ON ts.`idspectacle`=s.`idspectacle`
  2483.                                WHERE s.`publish`=1 AND s.`valid`=1
  2484.                                AND (sp.`idperson`=' . $idobject;
  2486.             // les textes de la personne
  2487.             if (!empty($idpectacles)) {
  2488.                 $sql_all_spectacles .= ' OR ts.`idtext` IN (' . implode(',', $idpectacles) . ' ) ';
  2489.             }
  2491.             // spectacles publiés
  2492.             $sql_all_spectacles .= ')';
  2494.             if ($cache) {
  2495.                 $cacheItem = $cache->getItem("theatreTrait_getObjectsCarrerDetails_{$idobject}_" . implode('-', $idpectacles));
  2496.                 if (!$cacheItem->isHit()) {
  2497.                     $res = $texts->queryAll($sql_all_spectacles);
  2499.                     $cacheItem->set($res)
  2500.                         ->expiresAt((new \DateTime('now'))->add(\DateInterval::createFromDateString('7 hours')));
  2501.                     $cache->save($cacheItem);
  2502.                 }
  2504.                 $ids_spectacles = $cacheItem->get();
  2505.             } else {
  2506.                 $ids_spectacles = $texts->queryAll($sql_all_spectacles);
  2507.             }
  2509.             $ids_spectacles = array_map('current', $ids_spectacles);
  2511.             $nb_educ = null;
  2513.             $idtexts_person = $this->getEntityManager()->getRepository(Texts::class)->getTextsPersons($idobject, 'all', 'all', true);
  2515.             // les textes de la personne avec un contenu éduc
  2516.             if (!empty($idtexts_person)) {
  2518.                 $list_texts = $texts->getListTexts(array(
  2519.                     'special' => array(
  2520.                         'idclassification' => array(125), // classification educ
  2521.                         'idtext' => $idtexts_person, // textes de la personne
  2522.                         'join' => true, // texte pas forcément publié
  2523.                     ),
  2524.                     'dbg' => array('list_texts', 'Liste des textes à contenus pédagogiques')
  2525.                 ));
  2526.                 if (!empty($list_texts)) {
  2527.                     foreach ($list_texts as $k => $v) {
  2528.                         $list_texts[$k]['url_clean_more'] = 'contenus-pedagogiques/';
  2529.                     }
  2530.                 }
  2531.                 $nb_educ += count($list_texts);
  2532.             }
  2534.             // les spectacles de la personne avec un contenu éduc
  2535.             if (!empty($ids_spectacle_all)) {
  2536.                 $list_spectacles = $spectacles->getListSpectacles(array(
  2537.                         'special' => array(
  2538.                             'idspectacles' => array('IN', $ids_spectacles), // les spectacles associés à la personne
  2539.                             'idclassification' => array(125), // avec un contenu pédagogique 125
  2540.                             'tri_plus_proches' => true,
  2541.                         ),
  2542.                         'dbg' => array('list_spectacles', 'Liste des spectacles avec contenus pédagogiques')
  2543.                     )
  2544.                 );
  2545.                 $nb_educ += count($list_spectacles);
  2546.             }
  2549.             // les spectacles de la personne avec des pièces démontées
  2550.             if (!empty($ids_spectacle_all)) {
  2551.                 $pieces_demontes = $spectacles->getListSpectacles(array(
  2552.                     'special' => array(
  2553.                         'idspectacles' => array('IN', $ids_spectacles), // les spectacles associés à la personne
  2554.                         'idclassification' => array(82), // avec un contenu pièce démontée (82)
  2555.                         'tri_plus_proches' => true,
  2556.                     ),
  2557.                     'dbg' => array('list_spectacles', 'Liste des spectacles avec une pièce démontée')
  2558.                 ));
  2560.                 $nb_educ += count($pieces_demontes);
  2561.             }
  2563.             // minutes pédagogiques => recherche directe sur la personne ou via les spectacles
  2564.             if (!empty($this->ids_spectacle_all)) {
  2565.                 $multimedias = $this->getEntityManager()->getRepository(Multimedias::class);
  2567.                 // recherche de base
  2568.                 $params_query_minutes = array(
  2569.                     'affiche' => array(
  2570.                         'datestart' => '1999-01-01',
  2571.                         'dateend' => '2030-01-01',
  2572.                     ),
  2573.                     'object' => array(array('spectacles', $ids_spectacles)),
  2574.                     'idclassification' => 145,
  2575.                     'limit' => array(0, 100),
  2576.                     'dbg' => array('minutes', 'Vidéos de minutes pédagogiques'),
  2577.                 );
  2579.                 $nb_educ += count($this->context['view']->list_minutes);
  2580.             }
  2582.             // texte par l'auteur => recherche des textes de l'auteur qui ont une playlist de ce type
  2583.             // recherche des playlists qui ont la classification par l'auteur et qui ont le texte de l'auteur
  2584.             if (!empty($ids_spectacles)) {
  2585.                 $playlists = $this->getEntityManager()->getRepository(Playlists::class);
  2587.                 $nb_educ += $playlists->countListPlaylists(array(
  2588.                     'special' => array(
  2589.                         'idclassifications' => 144, // class_texte_parauteur //
  2590.                         'idtext' => $ids_spectacles, // les texts de la personne
  2591.                     ),
  2592.                     'dbg' => array('list_playlists', 'Playlist texte par l\'auteur'),
  2593.                 ));
  2595.             }
  2597.             $news = $this->getEntityManager()->getRepository(News::class);
  2598.             $params_prochains_evenements = [
  2599.                 'special' => array(
  2600.                     'publish_valid' => true,
  2601.                     'prochains' => true,
  2602.                     'by_object' => array('idperson' => $idobject),
  2603.                 ),
  2604.             ];
  2605.             $prochains_evenements = $news->countNews($params_prochains_evenements);
  2608.             if (!empty($ids_spectacles)) {
  2609.                 $sql_count_critique = 'SELECT COUNT(DISTINCT(ct.`idcontent`))
  2610.                     FROM spectacles s
  2611.                     JOIN object_content oc ON s.`idspectacle`=oc.`idobject`
  2612.                     JOIN contents ct ON oc.`idcontent`=ct.`idcontent`
  2613.                     JOIN content_classification cc ON ct.`idcontent`=cc.`idcontent`
  2614.                     WHERE s.`publish`=1 AND s.`valid`=1
  2615.                     AND ct.`publish`=1 AND ct.`valid`=1
  2616.                     AND cc.`idclassification`=101
  2617.                     AND s.`idspectacle` IN (' . join(',', $ids_spectacles) . ') ';
  2619.                 $nb_critiques = $texts->queryOne($sql_count_critique);
  2620.             } else {
  2621.                 $nb_critiques = 0;
  2622.             }
  2624.             //Prix et distinctions - Aides et soutiens - Sélections
  2625.             $totalAides = 0;
  2626.             $params_aides = array(
  2627.                 'special' => array(
  2628.                     'aides' => array(
  2629.                         'type_aides' => [2, 3, 1, 4],
  2630.                     ),
  2631.                 ),
  2632.                 'idtext' => explode(',', $idtexts_person),
  2633.                 'get_texts_with_aides' => true,
  2634.                 'group_by_aide_type_aide_text' => true,
  2635.             );
  2636.             $totalAides = $this->getEntityManager()->getRepository(TextAide::class)->countListTextAide($params_aides);
  2639.             $arrays['biographies'] = ['idclassification' => 15];
  2640.             $arrays['ensavoirplus'] = ['idclassification' => 6];
  2641.             $arrays['textes'] = count($idpectacles);
  2642.             $arrays['spectacles'] = count($ids_spectacles);
  2643.             $arrays['videos'] = $totalVideos;
  2644.             $arrays['audios'] = $totalAudios;
  2645.             $arrays['critiques'] = $nb_critiques;
  2646.             $arrays['educ'] = $nb_educ;
  2647.             $arrays['evenements'] = $prochains_evenements;
  2648.         } else {
  2649.             $arrays = array(
  2650.                 'ensavoirplus' => ['idclassification' => 6],
  2651.                 'videos' => $totalVideos,
  2652.                 'audios' => $totalAudios,
  2653.                 'educ' => ['idclassification' => 125], //class_contenu_educ
  2654.                 'critiques' => ['idclassification' => 101],
  2655.                 'telechargements' => $telechargements
  2656.             );
  2657.         }
  2660.         $sql = 'SELECT COUNT(oc.idcontent)
  2661.                             FROM object_content oc, contents c, content_classification cc
  2662.                             WHERE oc.idcontent=c.idcontent
  2663.                             AND cc.idcontent=c.idcontent
  2664.                             AND c.publish=1
  2665.                             AND oc.object=\'' . $object . '\'
  2666.                             AND oc.idobject=' . $idobject;
  2668.         foreach ($arrays as $key => $value) {
  2669.             if (is_array($value) && !empty($value['idclassification'])) {
  2670.                 $sql_copy = $sql;
  2672.                 $sql_copy .= ' AND cc.idclassification=' . $value['idclassification'] . ' LIMIT 1';
  2674.                 $infos[$key] = $this->queryOne($sql_copy);
  2675.             } else {
  2676.                 $infos[$key] = $value;
  2677.             }
  2678.         }
  2680.         if ($infos['ensavoirplus'] < 2) {
  2681.             $infos['ensavoirplus'] = false;
  2682.         }
  2684.         if (isset($totalAides)) {
  2685.             $infos['ensavoirplus'] += $totalAides;
  2686.         }
  2688.         return $infos;
  2689.     }
  2691.     // }}}
  2694.     //  {{{ getObjectTitleSimple()
  2696.     /** Infos de l'un item recherché
  2697.      *
  2698.      * Affichage standard du titre de l'objet ou retourne des infos "simple"
  2699.      *
  2700.      * Deux grand type de cas :
  2701.      *      - on n'a les infos et on veux juste formater le titre = infos passée dans infos_object
  2702.      *      - on n'a pas les infos alors on exécute une requête pour les obtenir
  2703.      *
  2704.      * Au final on renvoi un titre formaté
  2705.      *
  2706.      * @access public
  2707.      * @param int $idobject Identifiant de l'item
  2708.      * @param array $infos_object Informations pour construire le titre
  2709.      * @param array $params Paramétres supplémentaires
  2710.      * @return string
  2711.      */
  2712.     public function getObjectTitleSimple($idobject = null, $infos_object = array(), $params = array())
  2713.     {
  2715.         // les champs à sélectionner
  2716.         if (empty($params['fields'])) {
  2717.             $fields = array($this->__idtable);
  2718.         } else {
  2719.             $fields = $params['fields'];
  2720.         }
  2722.         // le champ "d'affichage" si rien = le premier de la liste fields
  2723.         if (empty($params['required_field'])) {
  2724.             $required_field = $fields[0];
  2725.         } else {
  2726.             $required_field = $params['required_field'];
  2727.         }
  2729.         // si on n'a pas les infos
  2730.         if (empty($infos_object)) {
  2731.             //charger les infos que si necessaire
  2732.             if (empty($this->$required_field)) {
  2733.                 if (empty($params['sql'])) {
  2734.                     $sql = 'SELECT ' . implode(',', $fields) . '
  2735.                             FROM ' . $this->__table . '
  2736.                             WHERE ' . $this->__idtable . '=' . (int)$idobject;
  2737.                 } else {
  2738.                     $sql = $params['sql'];
  2739.                 }
  2740.                 $data = $this->queryRow($sql);
  2741.             }
  2743.             // mettre dans le tableau soir les données en cours (this) soir le résultat
  2744.             foreach ($fields as $k => $v) {
  2745.                 if (empty($data[$v]) && empty($this->$v)) {
  2746.                     $infos_object[$v] = '';
  2747.                 } else {
  2748.                     if (!empty($data[$v])) {
  2749.                         $infos_object[$v] = trim($data[$v]);
  2750.                     }
  2751.                     if (!empty($this->$v)) {
  2752.                         if (!is_array($this->$v)) {
  2753.                             $infos_object[$v] = trim($this->$v);
  2754.                         } else {
  2755.                             $infos_object[$v] = $this->$v;
  2756.                         }
  2758.                     }
  2759.                 }
  2760.             }
  2762.         } else { // on a les infos, c'est plus simple
  2764.             foreach ($fields as $k => $v) {
  2765.                 if (empty($infos_object[$v])) {
  2766.                     $infos_object[$v] = '';
  2767.                 } else {
  2768.                     $infos_object[$v] = trim($infos_object[$v]);
  2769.                 }
  2770.             }
  2772.         }
  2774.         //retour
  2775.         return $infos_object;
  2777.     }
  2779.     // }}}
  2781.     //  {{{ query()
  2783.     /** Redéfinir query pour le debug
  2784.      *
  2785.      *
  2786.      * @access   public
  2787.      * @param string $sql La requete SQL
  2788.      * @param array $dbg Les infos pour le debugage
  2789.      */
  2790. //    public function query($sql,$dbg=array())
  2791. //    {
  2792. //        $start_dbg_time = microtime(true);
  2793. //        parent::query($sql);
  2794. //        $exec_dbg_time = microtime(true) - $start_dbg_time;
  2795. //
  2796. //        // afficher directement le debug
  2797. //        if(!empty($_REQUEST['dbg_sql_object'])) {
  2798. //            if(!empty($_REQUEST['sql']) && !empty($dbg)
  2799. //                && ($dbg[0]==$_REQUEST['sql'] || $_REQUEST['sql']=='all')) {
  2800. //                // infos dans la globale
  2801. //                $GLOBALS['dbg_infos'][$dbg[0]] = array(
  2802. //                    'execution_time_query' => $exec_dbg_time,
  2803. //                    'sql_query' => $sql,
  2804. //                    'dbg' => $dbg,
  2805. //                );
  2806. //            }
  2807. //        }
  2808. //    }
  2810.     // }}}
  2812.     //  {{{ queryOne()
  2814. //    /** Redéfinir queryOne pour le debug
  2815. //     *
  2816. //     *
  2817. //     * @access   public
  2818. //     * @param    string  $sql La requete SQL
  2819. //     * @param    array  $dbg Les infos pour le debugage
  2820. //     */
  2821. //    public function queryOne($sql,$dbg=array())
  2822. //    {
  2823. //        $start_dbg_time = microtime(true);
  2824. //        $res = $this->queryOne($sql);
  2825. //        $exec_dbg_time = microtime(true) - $start_dbg_time;
  2826. //
  2827. //        // afficher directement le debug
  2828. //        if(!empty($_REQUEST['dbg_sql_object'])) {
  2829. //            if(!empty($_REQUEST['sql']) && !empty($dbg)
  2830. //                && ($dbg[0]==$_REQUEST['sql'] || $_REQUEST['sql']=='all')) {
  2831. //                // infos dans la globale
  2832. //                $GLOBALS['dbg_infos'][$dbg[0]] = array(
  2833. //                    'execution_time_query' => $exec_dbg_time,
  2834. //                    'sql_query' => $sql,
  2835. //                    'dbg' => $dbg,
  2836. //                );
  2837. //            }
  2838. //        }
  2839. //
  2840. //        return $res;
  2841. //
  2842. //    }
  2843. //
  2844. //    // }}}
  2846.     //  {{{ isTraceMode()
  2848.     /** Tracer ou pas ?
  2849.      *
  2850.      *
  2851.      * @access   public
  2852.      * @param string  Faut-il tracer des executions ?
  2853.      */
  2854.     public function isTraceMode($trace_mode)
  2855.     {
  2856.         if (!empty($_REQUEST[$trace_mode])) {
  2857.             return true;
  2858.         } else {
  2859.             return false;
  2860.         }
  2861.     }
  2863.     // }}}
  2865.     //  {{{ setTraceInfos()
  2867.     /** Enregistrer les paramètres de trace
  2868.      *
  2869.      *
  2870.      * @access   public
  2871.      * @param array $trace_infos Les paramètres
  2872.      */
  2873.     public function setTraceInfos($trace_infos)
  2874.     {
  2875.         $GLOBALS['dbg_infos'][] = $trace_infos;
  2876.     }
  2878.     // }}}
  2880.     //  {{{ getSQLObject()
  2882.     /** Construire une requete SQL
  2883.      *
  2884.      *
  2885.      * @access   public
  2886.      * @param array $query Paramètres de la requête
  2887.      * @return   string
  2888.      */
  2889.     public function getSQLObject($query)
  2890.     {
  2892.         // sans cache sql
  2893.         if (!empty($_REQUEST['sql_no_cache'])) {
  2894.             $sql_no_cache = 'SQL_NO_CACHE';
  2895.         } else {
  2896.             $sql_no_cache = null;
  2897.         }
  2899.         $empty_select = ', ';
  2901.         // select
  2902.         if (empty($query['count_only'])) {
  2903.             if (!empty($query['distinct'])) {
  2904.                 if ($query['distinct'] == 'no') {
  2905.                     $sql['select'] = 'SELECT ' . $sql_no_cache . ' ' . $this->__table . '.' . $this->__idtable;
  2906.                 } elseif ($query['distinct'] == 'no_primary') {
  2907.                     $sql['select'] = 'SELECT ' . $sql_no_cache . ' ';
  2908.                     $empty_select = '';
  2909.                 }
  2910.             } else {
  2911.                 $sql['select'] = 'SELECT ' . $sql_no_cache . ' DISTINCT(' . $this->__table . '.' . $this->__idtable . ')';
  2912.             }
  2913.         } else {
  2914.             if (!empty($query['count_disctint_by'])) {
  2915.                 foreach ($query['count_disctint_by'] as $k => $v) {
  2916.                     $sql['select'] = 'SELECT ' . $sql_no_cache . ' COUNT(DISTINCT(`' . $k . '`.`' . $v . '`)) as total ';
  2917.                 }
  2918.             } else {
  2919.                 if (property_exists($this, '__idtable')) {
  2920.                     $sql['select'] = 'SELECT ' . $sql_no_cache . ' COUNT(DISTINCT(' . $this->__table . '.' . $this->__idtable . ')) as total ';
  2921.                 } else {
  2922.                     $sql['select'] = 'SELECT ' . $sql_no_cache . ' COUNT(*) as total ';
  2923.                 }
  2924.             }
  2925.         }
  2927.         // la partie select
  2928.         if (!empty($query['select'])) {
  2929.             foreach ($query['select'] as $s) {
  2930.                 // la valeur est un tableau array('test' => 'essai')
  2931.                 if (is_array($s)) {
  2932.                     foreach ($s as $t => $f) {
  2933.                         $fields = explode(',', $f);
  2934.                         if (count($fields) > 1) {
  2935.                             foreach ($fields as $fb) {
  2936.                                 if ($fb == '*') {
  2937.                                     $select[] = $t . '.' . $fb;
  2938.                                 } else {
  2939.                                     $select[] = $t . '.`' . $fb . '`';
  2940.                                 }
  2941.                             }
  2942.                         } else {
  2943.                             if ($f == '*') {
  2944.                                 $select[] = $t . '.' . $f;
  2945.                             } else {
  2946.                                 $select[] = $t . '.`' . $f . '`';
  2947.                             }
  2948.                         }
  2949.                         // si la table n'est pas dans les 'from', on l'ajoute
  2950.                         if (!in_array($t, $query['from'])) {
  2951.                             $query['from'][$t] = $t;
  2952.                         }
  2953.                     }
  2954.                 } else {
  2955.                     $select[] = $s;
  2956.                 }
  2957.             }
  2959.             $sql['select'] .= $empty_select . join(',', $select);
  2961.         }
  2963.         if (!empty($query['select_more'])) {
  2964.             $sql['select'] .= $query['select_more'];
  2965.         }
  2967.         if (!empty($query['sum'])) {
  2968.             $sql['select'] = 'SELECT ' . $sql_no_cache . ' SUM(`' . $query['sum'][0] . '`.`' . $query['sum'][1] . '`) ';
  2969.         }
  2971.         if (!empty($query['left_join'])) {
  2972.             foreach ($query['left_join'] as $k => $v) {
  2973.                 $join = ' `' . $k . '` ';
  2974.                 if (in_array($k, $query['from'])) {
  2975.                     unset($query['from'][$k]);
  2976.                 }
  2977.                 foreach ($v as $kb => $vb) {
  2978.                     $join .= ' LEFT JOIN `' . $kb . '` ON ' . key($vb) . '=' . $vb[key($vb)] . ' ';
  2979.                     foreach ($query['from'] as $kq => $vq) {
  2980.                         if ($vq == $kb) {
  2981.                             unset($query['from'][$kq]);
  2982.                         }
  2983.                     }
  2984.                 }
  2985.                 $joins[] = $join;
  2986.             }
  2987.             $froms[] = join("\n", $joins);
  2988.         }
  2990.         // la partie from
  2991.         if (!empty($query['from'])) {
  2992.             foreach ($query['from'] as $k => $v) {
  2993.                 $froms[] = ' `' . $v . '` ';
  2994.             }
  2995.         }
  2997.         // les joins
  2998.         $sql['from'] = 'FROM ' . join(",\n", $froms);
  3000.         // where standard
  3001.         if (!empty($query['where'])) {
  3002.             foreach ($query['where'] as $w) {
  3003.                 // c'est un array
  3004.                 if (is_array($w)) {
  3005.                     // AND par défaut
  3006.                     if (empty($w[3])) {
  3007.                         $where_string = ' AND ';
  3008.                     } else {
  3009.                         $where_string = $w[3] . ' '; // précision sur la condition
  3010.                     }
  3011.                     $where_string .= $w[0] . '.`' . $w[1] . '`';
  3012.                     // c'est un tableau
  3013.                     if (is_array($w[2])) {
  3014.                         if (!empty($w[4])) { // précise si IN / NOT IN ou BETWEEN
  3015.                             $where_string .= ' ' . $w[4] . ' ';
  3016.                         } else {
  3017.                             $where_string .= ' IN ';
  3018.                         }
  3019.                         // si BETWEEN différent de IN
  3020.                         if (!empty($w[4]) && $w[4] == 'BETWEEN') {
  3021.                             $where_string .= '\'' . $this->escape($w[2][0]) . '\' AND \'' . $this->escape($w[2][1]) . '\'';
  3022.                         } else {
  3023.                             if (!empty($w[2]) && is_array($w[2])) {
  3024.                                 $ww = array();
  3025.                                 foreach ($w[2] as $s) {
  3026.                                     if ($this->my_is_int($s)) {
  3027.                                         $ww[] = $s;
  3028.                                     } else {
  3029.                                         if (is_array($s)) {
  3030.                                             $ww[] = '\'' . implode(',', $this->escape($s)) . '\'';
  3031.                                         } else {
  3032.                                             $ww[] = '\'' . $this->escape($s) . '\'';
  3033.                                         }
  3034.                                     }
  3035.                                 }
  3036.                                 $where_string .= '(' . join(',', $ww) . ')';
  3037.                             }
  3038.                         }
  3039.                     } else {
  3040.                         if (!empty($w[4])) {
  3041.                             $condition = $w[4];
  3042.                         } else {
  3043.                             $condition = '=';
  3044.                         }
  3045.                         if ($this->my_is_int($w[2])) {
  3046.                             $where_string .= $condition . $w[2];
  3047.                         } else {
  3048.                             if ($w[2] == 'ISNULL') {
  3049.                                 $where_string .= ' IS NULL';
  3050.                             } elseif ($w[2] == 'ISNOTNULL') {
  3051.                                 $where_string .= ' IS NOT NULL';
  3052.                             } else {
  3053.                                 $where_string .= $condition . '\'' . $w[2] . '\'';
  3054.                             }
  3055.                         }
  3056.                     }
  3057.                     $where_suite[] = $where_string;
  3058.                 } else {
  3059.                     $where_suite[] = $w;
  3060.                 }
  3061.             }
  3063.             $sql['where'] = ' WHERE 1 ' . join(' ', $where_suite);
  3065.             if (!empty($query['where_more'])) {
  3066.                 $sql['where'] .= $query['where_more'];
  3067.             }
  3069.             // jointure
  3070.             if (!empty($query['join'])) {
  3071.                 foreach ($query['join'] as $k => $v) {
  3072.                     $join[] = $v[0] . '=' . $v[1];
  3073.                 }
  3074.                 $sql['where'] .= ' AND ' . join(' AND ', $join);
  3075.             }
  3077.         }
  3079.         if (empty($query['count_only']) && empty($query['sum'])) {
  3081.             // la partie groupby
  3082.             if (empty($query['group'])) {
  3083.                 $sql['group'] = 'GROUP BY ' . $this->__table . '.' . $this->__idtable;
  3084.             } elseif ($query['group'] == 'no') {
  3085.                 $sql['group'] = ' ';
  3086.             } else {
  3087.                 foreach ($query['group'] as $k => $v) {
  3088.                     if (is_array($v)) {
  3089.                         $group[] = $k . '.`' . $v . '`';
  3090.                     } else {
  3091.                         $group[] = $k . '.`' . $v . '`';
  3092.                     }
  3093.                 }
  3094.                 $sql['group'] = ' GROUP BY ' . join(',', $group);
  3095.             }
  3096.         }
  3098.         if (!empty($query['having'])) {
  3099.             foreach ($query['having'] as $w) {
  3100.                 // c'est un array
  3101.                 if (is_array($w)) {
  3102.                     // AND par défaut
  3103.                     if (empty($w[3])) {
  3104.                         $having_string = 'AND ';
  3105.                     } else {
  3106.                         $having_string = $w[3] . ' '; // précision sur la condition
  3107.                     }
  3108.                     $having_string .= $w[0] . '.`' . $w[1] . '`';
  3109.                     // c'est un tableau
  3110.                     if (is_array($w[2])) {
  3111.                         if (!empty($w[4])) { // précise si IN / NOT IN ou BETWEEN
  3112.                             $having_string .= ' ' . $w[4] . ' ';
  3113.                         } else {
  3114.                             $having_string .= ' IN ';
  3115.                         }
  3116.                         // si BETWEEN différent de IN
  3117.                         if (!empty($w[4]) && $w[4] == 'BETWEEN') {
  3118.                             $having_string .= '\'' . $this->escape($w[2][0]) . '\' AND \'' . $this->escape($w[2][1]) . '\'';
  3119.                         } else {
  3120.                             if (!empty($w[2]) && is_array($w[2])) {
  3121.                                 $ww = array();
  3122.                                 foreach ($w[2] as $s) {
  3123.                                     if ($this->my_is_int($s)) {
  3124.                                         $ww[] = $s;
  3125.                                     } else {
  3126.                                         $ww[] = '\'' . $this->escape($s) . '\'';
  3127.                                     }
  3128.                                 }
  3129.                                 $having_string .= '(' . join(',', $ww) . ')';
  3130.                             }
  3131.                         }
  3132.                     } else {
  3133.                         if (!empty($w[4])) {
  3134.                             $condition = $w[4];
  3135.                         } else {
  3136.                             $condition = '=';
  3137.                         }
  3138.                         if ($this->my_is_int($w[2])) {
  3139.                             $having_string .= $condition . $w[2];
  3140.                         } else {
  3141.                             if ($w[2] == 'ISNULL') {
  3142.                                 $having_string .= ' IS NULL';
  3143.                             } elseif ($w[2] == 'ISNOTNULL') {
  3144.                                 $having_string .= ' IS NOT NULL';
  3145.                             } else {
  3146.                                 $having_string .= $condition . '\'' . $this->escape($w[2]) . '\'';
  3147.                             }
  3148.                         }
  3149.                     }
  3150.                     $having_suite[] = $having_string;
  3151.                 } else {
  3152.                     $having_suite[] = $w;
  3153.                 }
  3154.             }
  3156.             $sql['having'] = ' HAVING 1 ' . join(' ', $having_suite);
  3159.         }
  3161.         if (empty($query['count_only']) && empty($query['sum'])) {
  3163.             // classement par défaut
  3164.             if (empty($query['order'])) {
  3165.                 //$sql['order'] = 'ORDER BY '.$this->__table'.'.$this->__idtable;
  3166.                 $default_order = 'dateinsert';
  3167.                 $sql['order'] = 'ORDER BY ' . $this->__table . '.' . $default_order;
  3168.             } else {
  3169.                 foreach ($query['order'] as $k => $v) {
  3170.                     if (is_array($v)) {
  3171.                         // si le troisème élément de $v est un tableau => classement par FIELD
  3172.                         if (!empty($v[2]) && is_array($v[2])) {
  3173.                             $order[] = 'FIELD(' . $v[0] . '.`' . $v[1] . '`,' . join(',', $v[2]) . ')';
  3174.                             $is_field_order = true;
  3175.                         } else {
  3176.                             foreach ($v as $t => $f) {
  3177.                                 $order[] = $t . '.`' . $f . '`';
  3178.                             }
  3179.                         }
  3180.                     } else {
  3181.                         $order[] = $v;
  3182.                     }
  3183.                 }
  3184.                 $sql['order'] = 'ORDER BY ' . join(',', $order);
  3185.             }
  3187.             // si anciens, direction DESC
  3188.             if (!empty($query['anciens'])) {
  3189.                 $sql['direction'] = 'DESC';
  3190.             } else {
  3191.                 // direction définie
  3192.                 if (!empty($query['direction'])) {
  3193.                     // pas de direction
  3194.                     if ($query['direction'] != 'no') {
  3195.                         $sql['direction'] = $query['direction'];
  3196.                     } else {
  3197.                         $sql['direction'] = ' ';
  3198.                     }
  3199.                 } else {
  3200.                     if (empty($is_field_order)) {
  3201.                         $sql['direction'] = 'DESC';
  3202.                     } else {
  3203.                         $sql['direction'] = ' ';
  3204.                     }
  3205.                 }
  3206.             }
  3208.             // classement aléatoire
  3209.             if (!empty($query['random'])) {
  3210.                 $sql['order'] = 'ORDER BY RAND() ' . $query['random'];
  3211.             }
  3213.             // pas de classement
  3214.             if (!empty($query['no_order'])) {
  3215.                 $sql['order'] = '';
  3216.             }
  3218.         }
  3220.         // limite des résultats
  3221.         if (empty($query['limit'])) {
  3222.             $sql['limit'] = 'LIMIT 0,10';
  3223.         } else {
  3224.             if ($query['limit'][0] !== 'all') {
  3225.                 $sql['limit'] = 'LIMIT ' . join(',', $query['limit']);
  3226.             } else {
  3227.                 $sql['limit'] = null;
  3228.             }
  3229.         }
  3230.         // requête forcée sans le groupement, le tri et les limites
  3231.         if (!empty($query['force_query'])) {
  3232.             $sql = array();
  3233.             $sql['query'] = $query['force_query'];
  3234.         }
  3237.         // afficher directement le debug
  3238.         if ($this->isTraceMode('get_sql_object')) {
  3239.             if (!empty($_REQUEST['sql']) && !empty($query['dbg'])
  3240.                 && ($query['dbg'][0] == $_REQUEST['sql'] || $_REQUEST['sql'] == 'all')) {
  3241.                 // infos dans la globale
  3242.                 $GLOBALS['dbg_infos'][$query['dbg'][0]] = array(
  3243.                     'sql_query' => join(" \n", $sql),
  3244.                     'dbg' => $query['dbg'],
  3245.                 );
  3246.             }
  3247.         }
  3250.         return join(" \n", $sql);
  3252.     }
  3254.     // }}}
  3256.     // {{{ addSQLParams()
  3258.     /** Ajouter des paramètres à la requete
  3259.      *
  3260.      *
  3261.      * @param mixed $vignette_format format pour les vignettes (true pour défaut, tableau sinon)
  3262.      * @param string $language langue des vidéos (par défaut fr)
  3263.      * @param int|array $type limite au type spécifié (entier ou tableau d'entiers)
  3264.      * @access public
  3265.      * @return array
  3266.      */
  3267.     public function addSQLParams($param, &$query, $query_more)
  3268.     {
  3269.         // juste une string
  3270.         if (!is_array($query_more)) {
  3271.             $query[$param] = $query_more;
  3272.         } else {
  3273.             $use_merge = false;
  3274.             if ($use_merge) {
  3275.                 $query[$param] = array_merge($query[$param], $query_more);
  3276.             } else {
  3277.                 foreach ($query_more as $k => $v) {
  3278.                     if ($param == 'from' && in_array($v, $query['from'])) {
  3279.                         continue;
  3280.                     }
  3281.                     if (!$this->my_is_int($k)) {
  3282.                         if ($param == 'join') {
  3283.                             $query[$param][] = array($k, $v);
  3284.                         } else {
  3285.                             $query[$param][$k] = $v;
  3286.                         }
  3287.                     } else {
  3288.                         $query[$param][] = $v;
  3289.                     }
  3290.                 }
  3291.             }
  3292.         }
  3293.     }
  3295.     // }}}
  3297.     // {{{ mergeSQLParams()
  3299.     /**  Ajouter/supprimer des paramètres pour getListSpectacles
  3300.      *
  3301.      * @param array $params_sql tableau orginal
  3302.      * @param array $params_sql tableau complété
  3303.      * @return array
  3304.      */
  3305.     public function mergeSQLParams($params_sql, $params_sql_more)
  3306.     {
  3307.         // ajouter des paramètres
  3308.         unset($params_sql['params']['limit']);
  3309.         unset($params_sql['special']['plus_proche']);
  3310.         $params_sql = array_merge_recursive($params_sql, $params_sql_more);
  3311.         return $params_sql;
  3312.     }
  3314.     // }}}
  3316.     //  {{{ transformFieldsData()
  3318.     /** génére la version pour la diffusion API
  3319.      *
  3320.      * @access  public
  3321.      * @param array $fields tableau des champs
  3322.      * @param array $data tableau de données
  3323.      * @return array
  3324.      */
  3325.     public function transformFieldsData($fields, $data, $url)
  3326.     {
  3328.         // si les champs sont un tableau et les données un tableau supérieur à 1
  3329.         // alors on doit parcourir les données et mettre en relation les champs
  3330.         //$m = array();
  3332.         if (is_array($fields) && count($data) > 1) {
  3334.             foreach ($data as $k => $v) {
  3335.                 // dans le cas ou $data n'est pas un tableau
  3336.                 foreach ($fields as $f => $w) {
  3338.                     // pour convertir les clés exemple alldirectors->directors
  3339.                     if (strpos($f, '->') !== false) {
  3340.                         $t = explode('->', $f);
  3341.                         $f = $t[0];
  3342.                         $kk = $t[1];
  3343.                     } else {
  3344.                         $kk = $f;
  3345.                     }
  3347.                     if (!empty($data[$f])) {
  3348.                         // si l'occurence de data est un tableau => plusieurs données (exemple : directors)
  3349.                         if (is_array($data[$f])) {
  3350.                             foreach ($data[$f] as $kb => $vb) {
  3351.                                 $m[$kk][$kb] = $this->transformFieldsData($w, $vb, $url);
  3352.                             }
  3353.                         } else { // sinon, la valeur
  3355.                             // la valeur
  3356.                             $value = $data[$f];
  3357.                             $key = $w;
  3359.                             // si il y a un dièse dans la clé renommée (exemple permanent_url), on doit executer une regexp
  3360.                             $dieses = explode('#', $w);
  3362.                             if (is_array($dieses) && count($dieses) == 3) {
  3363.                                 $pattern = '/' . $dieses[1] . '/i';
  3364.                                 $remplacement = $dieses[2];
  3365.                                 $key = $dieses[0];
  3366.                                 $value = preg_replace($pattern, $remplacement, $value, 1);
  3367.                             }
  3369.                             // si c'est une URL, on doit ajouter l'URL
  3370.                             if (strpos($f, 'url_') !== false || strpos($w, '_url') !== false) {
  3371.                                 $value = $url . $value;
  3372.                             }
  3374.                             $m[$key] = $value;
  3376.                         }
  3377.                     }
  3378.                 }
  3379.             }
  3381.         }
  3383.         return $m;
  3385.     }
  3387.     // }}}
  3389.     //  {{{ getApiTab()
  3391.     /** génére la version pour la diffusion API
  3392.      *
  3393.      * @access  public
  3394.      * @param array $data tableau de données
  3395.      * @return array
  3396.      */
  3397.     public function getApiTab($data, $url = 'URL_THNET', $params_options = array())
  3398.     {
  3400.         //return $this->transformFieldsData($this->getApiFields(),$data,$url);
  3401.         //return $data;
  3403.         // on parcours les champs
  3404.         foreach ($this->getApiFields() as $field_key => $field_value) {
  3406.             // on doit convertir field_key
  3407.             if (strpos($field_key, '->') !== false) {
  3408.                 $t = explode('->', $field_key);
  3409.                 $field_key = $t[0];
  3410.                 $final_field_key = $t[1];
  3411.             } else {
  3412.                 $final_field_key = $field_key;
  3413.             }
  3415.             if (array_key_exists($field_key, $data)) {
  3417.                 if (is_array($field_value)) {
  3418.                     // niveau alldirectors => on parcours alldirectors dans fields
  3419.                     foreach ($field_value as $field_key_b => $field_value_b) {
  3421.                         // on doit convertir field_key
  3422.                         if (strpos($field_key_b, '->') !== false) {
  3423.                             $t = explode('->', $field_key_b);
  3424.                             $field_key_b = $t[0];
  3425.                             $final_field_key_b = $t[1];
  3426.                         } else {
  3427.                             $final_field_key_b = $field_key_b;
  3428.                         }
  3430.                         // on parcours alldirectors dans data
  3431.                         if(is_array($data[$field_key])){
  3432.                             foreach ($data[$field_key] as $data_key => $data_value) {
  3434.                                 // on doit convertir field_key
  3435.                                 if (strpos($data_key, '->') !== false) {
  3436.                                     $t = explode('->', $data_key);
  3437.                                     $data_key = $t[0];
  3438.                                     $final_data_key = $t[1];
  3439.                                 } else {
  3440.                                     $final_data_key = $data_key;
  3441.                                 }
  3443.                                 // on parcours chaque enregistremebt de alldirectors dans data
  3444.                                 foreach ($data_value as $data_key_b => $data_value_b) {
  3446.                                     // on doit convertir field_key
  3447.                                     if (strpos($data_key_b, '->') !== false) {
  3448.                                         $t = explode('->', $data_key_b);
  3449.                                         $data_key_b = $t[0];
  3450.                                         $final_data_key_b = $t[1];
  3451.                                     } else {
  3452.                                         $final_data_key_b = $data_key_b;
  3453.                                     }
  3455.                                     if ($data_key_b == $field_key_b) {
  3456.                                         // niveau ecoles
  3457.                                         if (is_array($data_value_b)) {
  3459.                                             if ($field_key_b == 'roles') {
  3460.                                                 $data_api[$final_field_key][$final_data_key][$field_key_b] = $data_value_b;
  3461.                                             } else {
  3463.                                                 // parcours du tableau ecoles de fields
  3464.                                                 foreach ($field_value_b as $field_key_c => $field_value_c) {
  3466.                                                     // on doit convertir field_key
  3467.                                                     if (strpos($field_key_c, '->') !== false) {
  3468.                                                         $t = explode('->', $field_key_c);
  3469.                                                         $field_key_c = $t[0];
  3470.                                                         $final_field_key_c = $t[1];
  3471.                                                     } else {
  3472.                                                         $final_field_key_c = $field_key_c;
  3473.                                                     }
  3475.                                                     // parcours du tableau ecoles de data
  3476.                                                     foreach ($data_value_b as $data_key_c => $data_value_c) {
  3478.                                                         // on doit convertir field_key
  3479.                                                         if (strpos($data_key_c, '->') !== false) {
  3480.                                                             $t = explode('->', $data_key_c);
  3481.                                                             $data_key_c = $t[0];
  3482.                                                             $final_data_key_c = $t[1];
  3483.                                                         } else {
  3484.                                                             $final_data_key_c = $data_key_c;
  3485.                                                         }
  3487.                                                         // parcours de chaque champ du tableau ecoles de data
  3488.                                                         foreach ($data_value_c as $data_key_d => $data_value_d) {
  3489.                                                             if ($data_key_d == $field_key_c) {
  3490.                                                                 //echo $final_field_key." ".$final_data_key." ".$final_field_key_b." ".$final_data_key_c." ".$final_field_key_c."\n";
  3492.                                                                 // la valeur
  3493.                                                                 $value = $data_value_d;
  3494.                                                                 $key = $field_value_c;
  3496.                                                                 // si il y a un dièse dans la clé renommée (exemple permanent_url), on doit executer une regexp
  3497.                                                                 $dieses = explode('#', $field_value_c);
  3499.                                                                 if (is_array($dieses) && count($dieses) == 3) {
  3500.                                                                     $pattern = '/' . $dieses[1] . '/i';
  3501.                                                                     $remplacement = $dieses[2];
  3502.                                                                     $key = $dieses[0];
  3503.                                                                     $value = preg_replace($pattern, $remplacement, $value, 1);
  3504.                                                                 }
  3506.                                                                 // si c'est une URL, on doit ajouter l'URL
  3507.                                                                 if (strpos($key, 'url') !== false) {
  3508.                                                                     //$value = $url.$value;
  3509.                                                                     // si permanent_url, ajouter aussi object
  3510.                                                                     $data_api[$final_field_key][$final_data_key][$final_field_key_b][$final_data_key_c]['object'] = $data_value_d;
  3511.                                                                 }
  3513.                                                                 $data_api[$final_field_key][$final_data_key][$final_field_key_b][$final_data_key_c][$key] = $value;
  3515.                                                             }
  3516.                                                         }
  3517.                                                     }
  3519.                                                 } // fin test si roles
  3520.                                             }
  3521.                                             // fin du niveau ecole
  3522.                                             // niveau personnes
  3523.                                         } else {
  3525.                                             // la valeur
  3526.                                             $value = $data_value_b;
  3527.                                             $key = $field_value_b;
  3529.                                             // si il y a un dièse dans la clé renommée (exemple permanent_url), on doit executer une regexp
  3530.                                             $dieses = explode('#', $field_value_b);
  3532.                                             if (is_array($dieses) && count($dieses) == 3) {
  3533.                                                 $pattern = '/' . $dieses[1] . '/i';
  3534.                                                 $remplacement = $dieses[2];
  3535.                                                 $key = $dieses[0];
  3536.                                                 $value = preg_replace($pattern, $remplacement, $value, 1);
  3537.                                             }
  3539.                                             // si c'est une URL, on doit ajouter l'URL
  3540.                                             if (strpos($key, 'url') !== false) {
  3541.                                                 //$value = $url.$value;
  3542.                                                 // si permanent_url, ajouter aussi object
  3543.                                                 $data_api[$final_field_key][$final_data_key]['object'] = $data_value_b;
  3544.                                             }
  3546.                                             $data_api[$final_field_key][$final_data_key][$key] = $value;
  3547.                                         }
  3548.                                     }
  3549.                                 }
  3550.                             }
  3551.                             //if(array_key_exists($field_key_b,$data)) {
  3552.                         }
  3553.                     }
  3554.                 } else {
  3556.                     // la valeur
  3557.                     $value = $data[$final_field_key];
  3558.                     $key = $field_value;
  3560.                     if ($key == "published") {
  3561.                         if ($value == true) {
  3562.                             $value = "1";
  3563.                         } else if ($value == false) {
  3564.                             $value = "0";
  3565.                         }
  3566.                     }
  3568.                     if ($key == "insert_date") {
  3569.                         if ($value instanceof \DateTime) {
  3570.                             $value= $value->format('Y-m-d H:i:s');
  3571.                         }
  3572.                     }
  3574.                     // si il y a un dièse dans la clé renommée (exemple permanent_url), on doit executer une regexp
  3575.                     $dieses = explode('#', $field_value);
  3577.                     if (is_array($dieses) && count($dieses) == 3) {
  3578.                         $pattern = '/' . $dieses[1] . '/i';
  3579.                         $remplacement = $dieses[2];
  3580.                         $key = $dieses[0];
  3581.                         $value = preg_replace($pattern, $remplacement, $value, 1);
  3582.                     }
  3584.                     // si c'est une URL, on doit ajouter l'URL
  3585.                     if (strpos($key, 'url') !== false) {
  3586.                         //$value = $url.$value;
  3587.                         // si permanent_url, ajouter aussi object
  3588.                         $data_api['object'] = $data[$final_field_key];
  3589.                     }
  3591.                     // niveau premier
  3592.                     $data_api[$key] = $value;
  3594.                 }
  3595.             }
  3597.         }
  3599.         return $data_api;
  3601.     }
  3603.     // }}}
  3605.     //  {{{ logDeletion()
  3607.     /** Loguer les supressions
  3608.      *
  3609.      * @access  public
  3610.      * @param array $info Le log
  3611.      * @return array
  3612.      */
  3613.     public function logDeletion($info)
  3614.     {
  3615.         /**
  3616.          * @TODO Ajouter un logger
  3617.          */
  3618.         // utilisateur connu ?
  3619. //        if($GLOBALS['sessionTheatre']->is_set('idextranetuser')) {
  3620. //            $login = Theatre::factory('extranetusers')->getValue('login',$GLOBALS['sessionTheatre']->getValue('idextranetuser'));
  3621. //        } else {
  3622. //            $login = 'Unknown';
  3623. //        }
  3624. //
  3625. //        // on connait le contexte
  3626. //        if(!empty($_SERVER['REQUEST_URI'])) {
  3627. //            $request_uri = $_SERVER['REQUEST_URI'];
  3628. //        } else {
  3629. //            $request_uri = 'url inconnue';
  3630. //        }
  3631. //
  3632. //        // PEAR::Log
  3633. //        require_once PATH_PEAR.'/Log.php';
  3635.         // dans un fichier
  3636. //        if(LOG_DELETE) {
  3637. //            dump('log dans un fichier à revoir');
  3638. //            @touch(LOG_DELETE);
  3639. //            $loggerFile = &Log::singleton('file', LOG_DELETE, 'DELETE');
  3640. //            $err = $login.'['.$request_uri.'] => '.$info;
  3641. //            $loggerFile->log($err);
  3642. //        }
  3644.     }
  3646.     // }}}
  3648.     //  {{{ arrayToIn()
  3650.     /** Transformer les entrées en contenu pour IN sql
  3651.      *
  3652.      * @access  public
  3653.      * @param array $params L'entrée
  3654.      * @return array
  3655.      */
  3656.     public function arrayToIn($params)
  3657.     {
  3658.         if (!is_array($params)) {
  3659.             $params = (array)$params;
  3660.         }
  3662.         foreach ($params as $k => $v) {
  3663.             if (is_string($v)) {
  3664.                 $out[$k] = '\'' . $this->escape($v) . '\'';
  3665.             } else {
  3666.                 $out[$k] = $v;
  3667.             }
  3668.         }
  3670.         return join(',', $out);
  3672.     }
  3674.     // }}}
  3676.     // generer un code aleatoire
  3677.     function codeAlea($taille = 30, $uniqid = false)
  3678.     {
  3679.         if ($uniqid) {
  3680.             return md5(uniqid(mt_rand(), true));
  3681.         }
  3682.         static $cars = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPRQSTUVWXYZ0123456789';
  3683.         $mdp = '';
  3684.         for ($i = 0; $i < $taille; $i++) {
  3685.             $mdp .= $cars[rand(0, 61)];
  3686.         }
  3687.         return $mdp;
  3688.     }
  3690.     // retourne la date courante au format timestamp
  3691.     function now()
  3692.     {
  3693.         return date('Y-m-d H:i:s');
  3694.     }
  3696. }