vendor/theatre/core/src/Repository/FilesRepository.php line 974

Open in your IDE?
  1. <?php
  3. namespace TheatreCore\Repository;
  5. use Doctrine\ORM\Query;
  6. use Symfony\Component\DependencyInjection\ParameterBag\ParameterBagInterface;
  7. use TheatreCore\Classes\Date\DateTime;
  8. use TheatreCore\Classes\Images\Images;
  9. use TheatreCore\Entity\Bigregions;
  10. use TheatreCore\Entity\Classifications;
  11. use TheatreCore\Entity\Files;
  12. use TheatreCore\Entity\ObjectFile;
  13. use TheatreCore\Entity\Spectacles;
  14. use TheatreCore\Entity\Typesfiles;
  15. use TheatreCore\Traits\TheatreTrait;
  16. use Doctrine\Bundle\DoctrineBundle\Repository\ServiceEntityRepository;
  17. use Doctrine\Persistence\ManagerRegistry;
  18. use Symfony\Contracts\Translation\TranslatorInterface;
  19. use App\Service\Functions;
  21. /**
  22.  * FilesRepository
  23.  *
  24.  * This class was generated by the Doctrine ORM. Add your own custom
  25.  * repository methods below.
  26.  */
  27. class FilesRepository extends ServiceEntityRepository
  28. {
  29.     use TheatreTrait {
  30.         getItemsList as protected getItemsListTrait;
  31.     }
  33.     public const UMASK = 0002;
  34.     public const FILE_MODE = 0664;
  35.     public const DIR_MODE = 0775;
  37.     private $em;
  38.     public $__table;
  39.     public $__table_object;
  40.     public $__idtable;
  42.     private $bagInterface;
  44.     public function __construct(ManagerRegistry $registry, TranslatorInterface $tr, Images $images, Functions $func, ParameterBagInterface $bagInterface)
  45.     {
  46.         parent::__construct($registry, Files::class);
  47.         $this->__table = $this->getClassMetadata()->getTableName();
  48.         $this->__table_object = $this->getClassMetadata()->name;
  49.         $this->__idtable = $this->getClassMetadata()->getSingleIdentifierFieldName();
  51.         $this->bagInterface = $bagInterface;
  53.         $this->translator = $tr;
  54.         $this->images = $images;
  56.         $this->func = $func;
  57.     }
  59.     //  {{{ findData()
  61.     /** Recherche des fichiers
  62.      *
  63.      * Permet de rechercher des fichiers en fonction de certains critères :
  64.      * la première lettre, un bout du nom, le type de multimedia, si il est en ligne ou pas
  65.      *
  66.      * @access  public
  67.      * @see     Theatre::find()
  68.      */
  69.     public function findData($publish = null, $keywords = null, $idobject = null, $object = null)
  70.     {
  72.         $con = $this->getEntityManager();
  73.         $query = $con->getRepository(Files::class)->createQueryBuilder('e');
  74.         $query->join('e.idclassification', 'cl');
  75.         $query->select('e');
  78. //        $query = '
  79. //            SELECT DISTINCT(f.idfile),f.*,tf.*
  80. //            FROM files f
  81. //                JOIN object_file of ON of.`idfile`=f.`idfile`
  82. //                JOIN file_classification fc ON f.`idfile`=fc.`idfile`
  83. //                JOIN classifications cl ON cl.`idclassification`=fc.`idclassification`
  84. //                JOIN typesfiles tf ON tf.`idtype`=f.`idtype`
  85. //            WHERE 1 ';
  88.         // parametre
  89.         if (isset($_REQUEST['idbooklet']) && !empty($_REQUEST['idbooklet'])) {
  90.             $idbooklet = $_REQUEST['idbooklet'];
  91.         }
  93.         if (isset($_REQUEST['idtypestructure']) && !empty($_REQUEST['idtypestructure']) && strlen($_REQUEST['idtypestructure']) < 5) {
  94.             $idtypestructure = $_REQUEST['idtypestructure'];
  95.         }
  97.         if (isset($_REQUEST['idclassification']) && !empty($_REQUEST['idclassification']) && my_is_int($_REQUEST['idclassification'])) {
  98.             $idclassification = $_REQUEST['idclassification'];
  99.         }
  101.         if (isset($_REQUEST['saison']) && !empty($_REQUEST['saison']) && strlen($_REQUEST['saison']) == 9) {
  102.             $saison = explode('-', $_REQUEST['saison']);
  103.             $date_start = $saison[0] . '-09-01';
  104.             $date_end = $saison[1] . '-08-31';
  105.         }
  107.         if (isset($_REQUEST['keywords']) && $_REQUEST['keywords'] != 'nom' && !empty($_REQUEST['keywords'])) {
  108.             $keywords = $_REQUEST['keywords'];
  109.         }
  111.         if (isset($_REQUEST['publish']) && !empty($_REQUEST['publish'])) {
  112.             $publish = $_REQUEST['publish'];
  113.         }
  115.         if (isset($_REQUEST['valid']) && !empty($_REQUEST['valid'])) {
  116.             $valid = $_REQUEST['valid'];
  117.         }
  119.         //recherche stricte par id
  120.         if (!empty($idfile)) {
  121. //            $query .= 'AND  f.`idfile`='.(int)$idbooklet;
  122.             $query->andWhere('f.`idfile`=' . (int)$idbooklet);
  123.         }
  124. //
  125. //        // mots cles
  126.         if (!empty($keywords)) {
  127. //            $query .= ' AND f.`title` LIKE \'%'.$this->escape($keywords).'%\'';
  128.             $query->andWhere(' f.`title` LIKE \'%' . $this->escape($keywords) . '%\'');
  129.         }
  130. //
  131. //        // saison
  132.         if (!empty($date_start) && !empty($date_end)) {
  133. //            $query .= ' AND f.`date_start`=\''.$date_start.'\' AND f.`date_end`=\''.$date_end.'\' ';
  134.             $query->andWhere(' f.`datestart`=\'' . $date_start . '\' AND f.`dateend`=\'' . $date_end . '\' ');
  135.         }
  137.         // saison
  138.         if (!empty($idclassification)) {
  139. //            $query .= ' AND fc.`idclassification`='.$idclassification.' ';
  140.             $query->andWhere(' fc.`idclassification`=' . $idclassification . ' ');
  142.         }
  144.         // selectionne les fiches hors ligne
  145.         if (!empty($publish) && $publish == 'no') {
  146. //            $query .= ' AND f.`publish`=0';
  147.             $query->andWhere(' f.`publish`=0');
  148.         }
  150.         // selectionne les fiches non validé
  151.         if (!empty($valid) && $valid == 'no') {
  152. //            $query .= ' AND f.`valid`=0';
  153.             $query->andWhere('f.`valid`=0');
  154.         }
  156.         // selectionne les fiches non validé proposé avec une classification publique
  157.         if (isset($_REQUEST['to_publish'])) {
  158. //            $query .= ' AND f.`publish`=0 AND cl.`is_public`=1';
  159.             $query->andWhere('e.publish=0 AND cl.isPublic=1');
  161.         }
  162.         if (isset($_REQUEST['to_valid'])) {
  163. //            $query .= ' AND f.`valid`=0 AND cl.`is_public`=1';
  164.             $query->andWhere('e.valid=0 AND cl.isPublic=1');
  166.         }
  169.         if ($this->getCount()) {
  170.             $query->select('COUNT(e.idfile)');
  172.             $this->setCount(false);
  174.             return $query;
  175.         }
  177.         // on lance la recherche
  178.         $this->specialQuery($query);
  180.     }
  182.     // }}}
  184.     //  {{{ setToArray()
  186.     /** Liste des multimedias dans un tableau associatif
  187.      *
  188.      * Tableau associatif notament utilisé pour lister les informations sur les multimedias
  189.      * Utile pour générer les tableaux HTML de listes de multimedias
  190.      *
  191.      * @access  public
  192.      * @return  array
  193.      * @see     findData()
  194.      */
  195.     public function setToArray($spec = true)
  196.     {
  198.         if ($spec == true) {
  199.             $this->findData();
  200.         }
  202.         $values = array();
  203.         $color = null;
  204.         $nb = 0;
  206.         while ($this->fetch()) {
  208.             // valeurs de l'enregistrement
  209.             $values[$nb] = $this->getInfosFile($this->idfile);
  211.             // couleur de ligne alternative
  212.             $color = $this->colorAlternate($color);
  213.             $values[$nb]['colorline'] = $color;
  214.             $values[$nb]['id'] = $this->idfile;
  216.             $nb++;
  217.         }
  219.         return $values;
  220.     }
  222.     // }}}
  224.     //  {{{ orderByDefaut()
  226.     /** Classement par défaut
  227.      *
  228.      * Défini le tri par défaut pour les requêtes de type SELECT
  229.      *
  230.      * @access public
  231.      * @return string
  232.      */
  233.     public function orderByDefaut($order = null)
  234.     {
  236.         // tri par défaut
  237.         if (empty($order)) {
  238.             $order = 'dateinsert';
  239.         }
  241.         return $order;
  243.     }
  245.     // }}}
  247.     //  {{{ getInfosFile()
  249.     /** Infos sur un fichier
  250.      *
  251.      * @access   public
  252.      * @param int $idfile id de l'objet
  253.      * @return   array
  254.      */
  255.     public function getInfosFile($idfile = null, $params_data = array(), $params_display = array())
  256.     {
  258.         $infos = array();
  260.         ////////////// infos de la table
  261.         if (!isset($this->idfile) || empty($this->idfile)) {
  262.             if (!empty($idfile)) {
  263.                 $sql = 'SELECT f.*, tf.titre, tf.extension, tf.mime_type, tf.inclus
  264.                         FROM ' . $this->__table . ' f, typesfiles tf
  265.                         WHERE f.idtype=tf.idtype AND f.idfile=' . (int)$idfile;
  266.                 $infos = $this->queryRow($sql);
  267.                 if (empty($infos)) {
  268.                     return array();
  269.                 }
  270.             }
  271.         } else if (!empty($this->datas[$this->currentRow])) {
  272.             $infos = $this->datas[$this->currentRow];
  273.         } else {
  274.             $idfile = $this->idfile;
  275.             $infos = $this->objToArray();
  276.             $query = $this->createQueryBuilder('e')
  277.                 ->leftJoin('e.idtype', 'it')
  278.                 ->select('e')
  279.                 ->addSelect('partial it.{idtype,extension}')
  280.                 ->andWhere('e.idfile = :file')->setParameter(':file', $this->idfile)
  281.                 ->getQuery();
  282.             $infos = $query->getResult();
  283.             $infos = $query->getSingleResult(Query::HYDRATE_ARRAY);
  284.         }
  286.         // selectionne aussi la/les classification(s)
  287.         $classifications_list = $this->getClassifications($idfile);
  289.         if (!empty($classifications_list)) {
  290.             $infos['classifications'] = $classifications_list;
  291.         }
  293.         // ajouter le chemin complet
  294.         if (!empty($infos)) {
  295.             if (!empty($infos['idtype']['extension'])) {
  296.                 $extension = $infos['idtype']['extension'];
  297.             } else {
  298.                 $extension = $infos['extension'];
  299.             }
  301.             $infos['filepath'] = $_ENV['URL_DIRECTORYUPLOAD'] . strtolower($extension) . '/' . $infos['file'];
  302.         }
  304.         // générer la vignette PDF
  305.         if (!empty($infos['idfile'])) {
  307.             $images = $this->images;
  308.             if (!empty($infos['idtype']['extension'])) {
  309.                 $extension = $infos['idtype']['extension'];
  310.             } else {
  311.                 $extension = $infos['extension'];
  312.             }
  314.             $infos['vignette'] = $_ENV['URL_DIRECTORYUPLOAD'] . $extension . '/' . $images->pdf2thumbnail($infos['file'], $_ENV['PATH_DIRECTORYUPLOAD'] . $extension . '/');
  316.             $infos['pdf'] = $_ENV['URL_DIRECTORYUPLOAD'] . $extension . '/' . $infos['file'];
  318.         }
  320.         // le nom de la structure
  321.         if (!empty($infos['organisation'])) {
  322.             $infos['contacts']['organisation'] = $infos['organisation'];
  323.             $infos['nameview'] = $infos['organisation'] . ' / ' . $infos['title'];
  324.         }
  325.         // suite
  326.         foreach (array('url_clean', 'nom_suite', 'city') as $f) {
  327.             if (!empty($infos[$f])) {
  328.                 $infos['contacts'][$f] = $infos[$f];
  329.             }
  330.         }
  332.         // valid ?
  333.         if (!empty($infos['valid']) && $infos['valid'] == 1) {
  334.             $infos['valid'] = true;
  335.         }
  337.         // la saison
  338.         if (!empty($infos['date_start']) && !empty($infos['date_end'])) {
  339.             $infos['dateStart'] = new \DateTime($infos['date_start']);
  340.             $infos['dateEnd'] = new \DateTime($infos['date_end']);
  341.         }
  343.         if (!empty($infos['dateStart']) && !empty($infos['dateEnd'])) {
  344.             $date_start_array = $infos['dateStart']->format('Y');
  345.             $date_end_array = $infos['dateEnd']->format('Y');
  346. //            $date_start_array = explode('-', $infos['dateStart']);
  347. //            $date_end_array = explode('-', $infos['dateEnd']);
  348.             $infos['saison'] = $date_start_array . '-' . $date_end_array;
  349.             // saison en cours ?
  350.             if ($infos['saison'] == DateTime::getLastSaison()) {
  351.                 $infos['current_saison'] = true;
  352.             }
  353.         }
  355.         //retourner le contenu
  356.         return $infos;
  357.     }
  359.     // }}}
  361.     //  {{{ uploadObjectFile()
  363.     /** Copier en upload et dans la base de données un fichier
  364.      *
  365.      *
  366.      * @access   public
  367.      * @param string $file objet $_FILES[]
  368.      * @param string|array $file_classification le nom/classification du fichier à copier sans extension (ex : biofile)
  369.      * @param string $objet le type d'objet à insérer (personnes, spectacles...)
  370.      * @param string $idobject id de l'utilisateur pour le nom de son répertoire
  371.      * @param array $filedata toutes les données associées au fichier : titre, description...
  372.      * @param string $idfile (id du fichier à modifier si on est en mode modification)
  373.      * @param object $finfo instance d'un objet FileInfo (optionnel)
  374.      * @return   int|bool  false si erreur, id du fichier si ok
  375.      */
  376.     public function uploadObjectFile($file, $file_classification, $object, $idobject, $filedata, $idfile = null, $finfo = null, $extra = array())
  377.     {
  378.         $conn = $this->getEntityManager();
  380.         if ($this->my_is_int($file_classification)) {
  381.             $file_classification = array($file_classification);
  382.         }
  384.         if (empty($file_classification)) return false;
  386.         // champs en option
  387.         $fields = array(
  388.             'title',
  389.             'idextranetuser',
  390.             'range',
  391.             'description',
  392.             'copyright',
  393.             'language',
  394.             'idcontent',
  395.             'idfile_original',
  396.             'watermark',
  397.             'date_start',
  398.             'date_end',
  399.             'publishing_date',
  400.             'is_editable',
  401.             'publish',
  402.             'valid'
  403.         );
  405.         $date = new \DateTime();
  407.         // pour la saison
  408.         if (!empty($filedata['saison'])) {
  409.             // transformer la saison en date_start / date_end
  410.             $saison_array = explode('-', $filedata['saison']);
  411. //            $filedata['date_start'] = $saison_array[0].'-09-01';
  412. //            $filedata['date_end'] = $saison_array[1].'-08-31';
  413.         }
  415.         if (!empty($filedata['publishing_date']) && !$filedata['publishing_date'] instanceof \DateTime && strpos('/', $filedata['publishing_date']) !== false) {
  416.             $publishing_date = explode('/', $filedata['publishing_date']);
  417.             $filedata['publishing_date'] = $date->setDate($publishing_date[2], $publishing_date[1], $publishing_date[0]);
  418.         }
  420.         //répertoire des fichiers (répertoire d'upload)
  421.         $directoryupload = $_ENV['PATH_DIRECTORYUPLOAD'];
  423.         //objet dans la table OBJECT_FILE
  424.         $obj_objectfile = $conn->getRepository(ObjectFile::class);
  426.         //on a chargé un nouveau fichier que ce soit en modification ou en insertion
  427.         if (is_array($file)
  428.             || (is_object($file) && $file->isSubmitted() && !empty($file->getData()))) {
  430.             static $list_types_mime = null;
  432.             if (is_null($list_types_mime)) {
  433.                 // récupére les infos id,mime,extension
  434.                 $sql_mime = 'SELECT mime_type,idtype,extension FROM typesfiles WHERE upload=\'oui\'';
  435.                 $list_types_mime = $this->queryAll($sql_mime, array(), null, true);
  436.                 if (empty($list_types_mime)) {
  437.                     throw new \Exception('chargement impossible des Types Mimes autorisés');
  438.                 }
  439.             }
  441.             // voir si c'est un fichier uploade ou juste un fichier sur le serveur
  442.             if (is_object($file) && $file->isSubmitted()) {
  443.                 //récupérer le type mime du fichier uploadé
  444.                 $typemime = $file->getData();
  445.                 //$typemime = $typemime['type'];
  446.                 $typemime = $this->func->finfo_file_simple($finfo, $typemime->getPathName());
  447.                 $is_objectfile = true;
  448.             } else {
  449.                 // recuperer le type mime du fichier sur le serveur
  450.                 $typemime = $this->func->finfo_file_simple($finfo, $file['file']);
  451.                 $is_simplefile = true;
  452.             }
  453.         
  454.             $inListTypeMime = false;
  455.             $inListTypeMimeInfo = [];
  456.             foreach($list_types_mime as $key => $element)  {
  457.                 if(in_array($typemime, $element)) {
  458.                     $inListTypeMime = true;
  459.                     $inListTypeMimeInfo = $element;
  460.                     break;
  461.                 }
  462.             }
  464.             // récupére l'id du type MIME et l'extension qui correspondent
  465.             if ($inListTypeMime == true) {
  466.                 $idtypefile = $inListTypeMimeInfo['idtype'];
  467.                 $extension = $inListTypeMimeInfo['extension'];
  468.             } else {
  469.                 return false;
  470.             }
  472.             // chgt umask
  473.             $oldumask = umask();
  474.             if (self::UMASK) {
  475.                 umask(self::UMASK);
  476.             }
  478.             //répertoire des données (repertoire d'upload + extension)
  479.             $directoryupload .= $extension;
  481.             // vérifier si le dossier existe, sinon le créer
  482.             if (!file_exists($directoryupload)) {
  483.                 mkdir($directoryupload, self::DIR_MODE, true);
  484.             }
  486.             //// uploader le fichier ou le copier
  488.             // nom unique et chemin du nouveau fichier
  489.             do {
  490.                 $nomfichier = uniqid('f-' . substr(md5($object . $idobject), 0, 3) . '-') . '.' . $extension;
  491.                 $newfile = $directoryupload . '/' . $nomfichier;
  492.             } while (file_exists($newfile));
  494.             if (isset($is_objectfile)) {
  495.                 $file = $file->getData();
  496.                 $uploadok = $file->move($directoryupload, $nomfichier);
  497.             } else {
  498.                 $uploadok = copy($file['file'], $newfile);
  499.             }
  501.             //mettre les bons droits (lecture) pour ce fichier
  502.             if ($uploadok) {
  503.                 chmod($newfile, self::FILE_MODE);
  504.             }
  506.             //erreur lors de l'upload du fichier
  507.             if (empty($uploadok)) {
  508.                 throw new \Exception('erreur lors de la mise-en-ligne du fichier');
  509.             }
  511.             // champ ImageDescription ?
  512.             /*$exif = exif_read_data($newfile);
  513.             print_r($exif);
  514.             exit;*/
  516.             // on souhaite un copyright ?
  517.             $extension_img = array('jpg', 'png', 'gif');
  518.             if (!empty($filedata['watermark']) && !empty($filedata['copyright']) && in_array($extension, $extension_img)) {
  519.                 $images = $this->images;
  520.                 $images->setWatermark($newfile, null, array('text' => $filedata['copyright']));
  521.             }
  523.             // supprimer l'ancien fichier et la relation en enlevant le fichier en dur dans le cas d'une modification !
  524.             if (!empty($idfile)) {
  525.                 $this->deleteFile($idfile, $object, $idobject, true);
  526.             }
  528.             // commencer la transaction
  530.             $error = null;
  532.             $conn->beginTransaction();
  534.             $new_file = new Files();
  536.             //mise en forme des données
  537.             $idType = $conn->getRepository(Typesfiles::class)->find($idtypefile);
  538.             $new_file->setIdtype($idType);
  539.             $new_file->setFile($nomfichier);
  540.             $new_file->setDateStart(new \DateTime('now'));
  542.             // test les champs
  543.             foreach ($fields as $f) {
  544.                 if (!empty($filedata[$f])) {
  545.                     $field = implode('', array_map(function ($m) {
  546.                         return ucfirst($m);
  547.                     }, explode('_', $f)));
  549.                     $new_file->{'set' . ucfirst($field)}($filedata[$f]);
  550.                 }
  551.             }
  553.             $conn->persist($new_file);
  554.             $conn->flush();
  556.             $conn->commit();
  558.             $idfileinsere = $new_file->getIdfile();
  560.             //on insère un nouveau document dans la table file que ce soit une modif ou un insert !
  561.             try {
  562.                 $idfileinsere = $new_file->getIdfile();
  563.             } catch (\Exception $e) {
  564.                 $error = $e->getError();
  565.                 if ($this->in_transaction) {
  566.                     $this->rollback();
  567.                 }
  568.             }
  570.             // ajout des classifications
  571.             if (empty($error)) {
  572.                 try {
  573.                     $this->setRelationSelect('file_classification', 'idclassification', 'idfile', $file_classification, $idfileinsere);
  574.                 } catch (\Exception $e) {
  575.                     $error = $e->getError();
  576.                     if ($this->in_transaction) {  // annuler la transaction
  577.                         $this->rollback();
  578.                     }
  579.                 }
  580.             }
  582.             if (empty($error)) {
  584.                 //mise en forme des données
  586.                 $conn->beginTransaction();
  588.                 $objectFile = new ObjectFile();
  589.                 $objectFile->setIdobject($idobject);
  590.                 $objectFile->setObject($object);
  591.                 $objectFile->setIdfile($new_file);
  593.                 // on ajoute la liaison avec l'objet
  594.                 try {
  595.                     $conn->persist($objectFile);
  596.                     $conn->flush();
  598.                 } catch (\Exception $e) {
  599.                     $error = $e->getError();
  600.                     if ($this->in_transaction) {
  601.                         $this->rollback();
  602.                     }
  603.                 }
  605.                 if (empty($error)) {
  606. //                    if ($this->in_transaction) {
  607.                     $conn->commit();
  608. //                    }
  609.                 }
  612.             }
  614.             if (empty($error)) {
  616.                 // est-ce qu'on a des liaisons en plus ?
  617.                 if (!empty($extra['more_linked_object'])) {
  619.                     foreach ($extra['more_linked_object'] as $k => $v) {
  621.                         //mise en forme des données
  622.                         $values = array(
  623.                             'idobject' => $k,
  624.                             'object' => $v,
  625.                             'idfile' => $idfileinsere
  626.                         );
  628.                         // champ a mettre a jour
  629.                         $obj_objectfile->setUpdateFields($values);
  631.                         // on ajoute la liaison avec l'objet
  632.                         try {
  633.                             $idobjectfile = $obj_objectfile->setData(null, true);
  634.                         } catch (\Exception $e) {
  635.                             $error = $e->getError();
  636.                             if ($this->in_transaction) {
  637.                                 $this->rollback();
  638.                             }
  639.                         }
  641.                         if (empty($error)) {
  642.                             if ($this->in_transaction) {
  643.                                 $this->commit();
  644.                             }
  645.                         }
  647.                     }
  649.                 }
  651.             }
  653.             if (!empty($error)) {
  654.                 // en cas d'erreur lors de l'insertion en bdd, on supprime le fichier uploadé
  655.                 @unlink($newfile);
  656.             }
  658.             // restauration umask
  659.             umask($oldumask);
  661.         } else { //on a pas chargé de nouveau fichier, on fait juste une modification des datas
  663.             //si on a un $idfile c'est que l'on est en modification
  664.             if (!empty($idfile)) {
  666.                 // il faut récupérer les infos de l'ancien fichier
  667.                 $taboldfile = $this->queryRow('SELECT * FROM files WHERE files.idfile=' . (int)$idfile);
  669.                 // commencer la transaction
  670.                 $error = null;
  672.                 // tableau pour insertion dans la table files
  673.                 $values = array(
  674.                     'idtype' => $taboldfile['idtype'],
  675.                     'file' => $taboldfile['file'],
  676.                     'dateupdate' => $this->func->now()
  677.                 );
  679.                 // test les champs
  680.                 foreach ($fields as $f) {
  681.                     if (!empty($filedata[$f])) {
  682.                         $values[$f] = $filedata[$f];
  683.                     }
  684.                 }
  686.                 if (!empty($values['idextranetuser'])) {
  687.                     $values['idextranetuser'] = $values['idextranetuser']->getIdextranetuser();
  688.                 }
  690.                 if (!empty($values['date_start'])) {
  691.                     $values['date_start'] = $values['date_start']->format('Y-m-d');
  692.                 }
  694.                 if (!empty($values['date_end'])) {
  695.                     $values['date_end'] = $values['date_end']->format('Y-m-d');
  696.                 }
  698.                 if (!empty($values['publishing_date'])) {
  699.                     $values['publishing_date'] = $values['publishing_date']->format('Y-m-d');
  700.                 }
  702.                 // publie ou pas
  703.                 if (!empty($filedata['publish'])) {
  704.                     $values['publish'] = $filedata['publish'];
  705.                 } else {
  706.                     $values['publish'] = 0;
  707.                 }
  709.                 // validé ou pas
  710.                 if (!empty($filedata['valid'])) {
  711.                     $values['valid'] = $filedata['valid'];
  712.                 } else {
  713.                     $values['valid'] = 0;
  714.                 }
  716.                 // champ a mettre a jour
  717.                 $this->setUpdateFields($values);
  719.                 // on update
  720.                 try {
  721.                     $res = $this->setData($idfile, true);
  722.                 } catch (\Exception $e) {
  723.                     $error = $e->getError();
  724. //                    if ($this->in_transaction) {
  725. //                        $this->rollback();
  726. //                    }
  727.                 }
  729.                 // ajout des classifications
  730.                 if (empty($error)) {
  731.                     try {
  732.                         $this->setRelationSelect('file_classification', 'idclassification', 'idfile', $file_classification, $idfile);
  733.                     } catch (\Exception $e) {
  734.                         $error = $e->getError();
  735. //                        if($this->in_transaction) {  // annuler la transaction
  736. //                            $this->rollback();
  737. //                        }
  738.                     }
  739.                 }
  741.                 if (empty($error)) {
  742. //                    if ($this->in_transaction) {
  743. //                        $this->commit();
  744. //                    }
  745.                 }
  747.                 // est-ce qu'on a des liaisons en plus ?
  748.                 if (!empty($extra['more_linked_object'])) {
  750.                     // supprimer les anciens et ajouter les nouveaux
  751.                     $sql = 'DELETE
  752.                             FROM object_file
  753.                             WHERE idfile=' . $idfile . '
  754.                             AND idobject!=' . $idobject . '
  755.                             AND object!=\'' . $object . '\' ';
  757.                     $this->exec($sql);
  759.                     foreach ($extra['more_linked_object'] as $k => $v) {
  761.                         //mise en forme des données
  762.                         $values = array(
  763.                             'idobject' => $k,
  764.                             'object' => $v,
  765.                             'idfile' => $idfile
  766.                         );
  768.                         // champ a mettre a jour
  769.                         $obj_objectfile->setUpdateFields($values);
  771.                         // on ajoute la liaison avec l'objet
  772.                         try {
  773.                             $idobjectfile = $obj_objectfile->setData(null, true);
  774.                         } catch (\Exception $e) {
  775.                             $error = $e->getError();
  776.                             if ($this->in_transaction) {
  777.                                 $this->rollback();
  778.                             }
  779.                         }
  781.                         if (empty($error)) {
  782.                             if ($this->in_transaction) {
  783.                                 $this->commit();
  784.                             }
  785.                         }
  787.                     }
  789.                 }
  791.                 
  792.                 $idfileinsere = $idfile;
  794.             }
  796.         }
  798.         // retourner l'idobject du fichier créé dans la table file
  799.         return $idfileinsere;
  801.     }
  803.     // }}}
  805.     //  {{{ isUseObjectFile()
  807.     /** Vérifier si un fichier est utilisé par un autre contenu
  808.      *
  809.      *
  810.      * @access   public
  811.      * @param int $idfile id du fichier à vérifier
  812.      * @return   bool
  813.      */
  814.     public function isUseObjectFile($idfile)
  815.     {
  817.         // on compte le nb d'utilisation
  818.         $total = $this->queryOne('SELECT COUNT(DISTINCT(idobject)) AS total FROM object_file WHERE object_file.idfile=' . $idfile);
  820.         //on a au moins 2 enregistrements liés
  821.         if ($total > 1) {
  822.             return true;
  823.         }
  825.         return false;
  826.     }
  828.     // }}}
  830.     //  {{{ deleteFile()
  832.     /** Supprimer un fichier sur le serveur
  833.      *
  834.      *
  835.      * @access   public
  836.      * @param string $id id du fichier à supprimer
  837.      * @param string $object type de fichier à supprimer (ex : persons, contacts...)
  838.      * @param string $idobject id de la personne qui possède le fichier
  839.      */
  840.     public function deleteFile($id, $object, $idobject, $delfile)
  841.     {
  842.         //repertoire de l'utilisateur (répertoire d'upload + object + id personne)
  843.         $directoryupload = $_ENV['PATH_DIRECTORYUPLOAD'];
  845.         //le fichier n'est pas utilisé, on peut le supprimer
  846.         if (!$this->isUseObjectFile($id)) {
  848.             //récupérer les infos du fichier
  849. //            $this->selectAdd();
  850. //            $this->selectAdd('idtype,file');
  851.             $data = $this->find($id);
  852.             $type = $data->getIdtype()->getExtension();
  854.             //répertoire
  855.             if (is_object($type)) {
  856.                 $filedelete = $directoryupload . $type->extension . '/' . $data->getFile();
  857.             } else {
  858.                 $filedelete = null;
  859.             }
  861.             //supprimer le fichier sur le disque
  862.             if (file_exists($filedelete) && $delfile) {
  863.                 // supprimer le fichier principal
  864.                 @unlink($filedelete);
  865.                 // supprimer aussi les vignettes
  866.                 $this->deleteVignettes($id, $object, $idobject);
  867.             }
  869.             //supprimer l'enregistrement en lui même (table file)
  870.             $this->deleteData($id);
  871.         }
  873.         //dans touts les cas, supprimer l'enregistrement dans la relation object_file
  874.         $this->deleteDataRelation('object_file', 'idfile', $id, 'idobject', $idobject, 'object', $object);
  876.     }
  878.     // }}}
  880.     //  {{{ deleteSimpleFile()
  882.     /** Supprimer un fichier simple sur le serveur
  883.      *
  884.      *
  885.      * @access   public
  886.      * @param string $id id du fichier à supprimer
  887.      */
  888.     public function deleteSimpleFile($idfile)
  889.     {
  890.         //repertoire de l'utilisateur (répertoire d'upload + object + id personne)
  891.         $directoryupload = PATH_DIRECTORYUPLOAD;
  893.         $infos = $this->getInfosFile($idfile);
  895.         //répertoire
  896.         $filedelete = $directoryupload . $infos['extension'] . '/' . $infos['file'];
  898.         // si c'est un pdf,
  899.         if ($infos['extension'] == 'pdf') {
  900.             $files = glob($filedelete . '-*.jpg');
  901.             if (!empty($files) && is_array($files)) {
  902.                 foreach ($files as $f) {
  903.                     @unlink($f);
  904.                 }
  905.             }
  906.         }
  908.         //supprimer le fichier sur le disque
  909.         if (file_exists($filedelete)) {
  910.             // supprimer le fichier principal
  911.             @unlink($filedelete);
  912.             // supprimer aussi les vignettes
  913.             $this->deleteVignettes($idfile);
  914.             //supprimer l'enregistrement en lui même (table file)
  915.             $this->deleteData($idfile);
  916.         }
  918.         return true;
  920.     }
  922.     // }}}
  923.     //  {{{ countObjectFiles()
  925.     /** Compter les fichiers lies a un objet
  926.      *
  927.      *
  928.      * @access   public
  929.      * @param string $idobject id de l'objet lié
  930.      * @param string $object le type d'objet (personnes, spectacles...)
  931.      * @param string|int|array $idclassification le rechercher par type de classification
  932.      * @return   array
  933.      * @see Theatre_Classifications::getAssociate())
  934.      */
  935.     public function countObjectFiles($idobject, $object = 'contents', $idclassification = null, $extra = array())
  936.     {
  937.         $extra['count_only'] = true;
  938.         return $this->getObjectFiles($idobject, $object, $idclassification, $extra);
  939.     }
  941.     // }}}
  943.     //  {{{ getObjectFiles()
  945.     /** Retourner les fichiers lies a un objet
  946.      *
  947.      *
  948.      * @access   public
  949.      * @param string $idobject id de l'objet lié
  950.      * @param string $object le type d'objet (personnes, spectacles...)
  951.      * @param string|int|array $idclassification le rechercher par type de classification
  952.      * @return   array
  953.      * @see Theatre_Classifications::getAssociate())
  954.      */
  955.     public function getObjectFiles($idobject, $object = 'contents', $idclassification = null, $extra = array())
  956.     {
  958.         if (isset($extra['count_only']) && $extra['count_only']) {
  959.             $fields = array();
  960.         } else {
  961.             $fields = '*';
  962.         }
  964.         $extra['mode'] = 'file';
  966.         if (!empty($classification) && ($classification == 21 || $classification == 'class_affiche_spec')) {
  967.             // une seule affiche par spectacle !
  968.             $extra['limit'] = '1';
  969.         }
  971.         $classifications = $this->getEntityManager()->getRepository(Classifications::class);
  972.         $classifications->setPublishStatus($this->publish_status);
  974.         $tabfile = $classifications->getAssociate($idobject, $object, $idclassification, $fields, $extra);
  976.         if (!empty($extra['count_only'])) {
  977.             return $tabfile;
  978.         }
  980.         //retourner les données du fichier sous forme de tableau
  981.         if (!empty($tabfile)) {
  983.             $images = $this->images;
  985.             $new_tabfile = array();
  986.             $images_extensions = array('jpg', 'png', 'gif');
  988.             foreach ($tabfile as $k => $v) {
  990.                 if (empty($v['idfile'])) {
  991.                     dump('revoir cette ligne là 938');
  992.                     break;
  993.                 }
  994.                 $idfile = $v['idfile'];
  996.                 // grouper par idfile
  997.                 foreach ($new_tabfile as $kf => $f) {
  998.                     if ($f['idfile'] == $idfile) {
  999.                         $new_tabfile[$kf]['classification_array'] = array(
  1000.                             $new_tabfile[$kf]['classification'],
  1001.                             $classifications->getObjectTitle($v['idclassification']),
  1002.                         );
  1003.                         $stop = true;
  1004.                     }
  1005.                 }
  1007.                 if (!empty($stop)) {
  1008.                     break;
  1009.                 }
  1011.                 $new_tabfile[$k] = $v;
  1013.                 $new_tabfile[$k]['classification'] = $classifications->getObjectTitle($v['idclassification']);
  1014.                 $new_tabfile[$k]['logo'] = strtolower($v['extension']) . '.png';
  1016.                 $new_tabfile[$k]['publishing_date'] = $v['publishing_date'];
  1018.                 if (!empty($v['date_start']) && $v['date_start'] != '0000-00-00 00:00:00' && !empty($v['date_end']) && $v['date_end'] != '0000-00-00 00:00:00') {
  1019.                     $date_start_array = explode('-', $v['date_start']);
  1020.                     $date_end_array = explode('-', $v['date_end']);
  1021.                     $new_tabfile[$k]['saison'] = $date_start_array[0] . '-' . $date_end_array[0];
  1022.                     // saison en cours ?
  1023.                     if ($new_tabfile[$k]['saison'] == DateTime::getLastSaison()) {
  1024.                         $new_tabfile[$k]['current_saison'] = true;
  1025.                     }
  1026.                 }
  1027.                 if (!empty($v['publishing_date']) && $v['publishing_date'] != '0000-00-00') {
  1028.                     $new_tabfile[$k]['publishing_date_str'] = $this->getFormeDate($v['publishing_date'], '%d/%m/%Y', true);
  1029.                     $new_tabfile[$k]['publishing_date_str_full'] = $this->getFormeDate($v['publishing_date'], '%d %B %Y', true);
  1030.                 }
  1031.                 $new_tabfile[$k]['dateinsert_str'] = $this->getFormeDate($v['dateinsert'], '%d/%m/%Y', true);
  1032.                 $new_tabfile[$k]['dateinsert_str_full'] = $this->getFormeDate($v['dateinsert'], '%d %B %Y', true);
  1034.                 // on veut également savoir si ce doc est associé à d'autres choses (par exemple : spectacles)
  1035.                 if (!empty($extra['get_objects'])) {
  1036.                     $new_tabfile[$k]['objects'] = $this->getObjects($v['idfile'], array('idobject' => $idobject));
  1037.                 }
  1039.                 if (!empty($extra['get_others'])) {
  1041.                     $sql = 'SELECT *
  1042.                             FROM object_file
  1043.                             WHERE idfile=' . $v['idfile'] . '
  1044.                             AND idobject!=' . $idobject;
  1045.                     $others = $this->queryAll($sql);
  1047.                     if (!empty($others)) {
  1049.                         $others_tab = array();
  1051.                         foreach ($others as $other) {
  1052.                             if ($other['object'] != $object) {
  1053.                                 $others_tab[$other['object']][$other['idobject']] = $other['idobject'];
  1054.                             }
  1055.                         }
  1056.                     }
  1058.                     if (!empty($others_tab['spectacles'])) {
  1059.                         $params_sql_spectacle = array(
  1060.                             'special' => array(
  1061.                                 'idspectacle' => $others_tab['spectacles'],
  1062.                                 'publish' => 'all',
  1063.                                 'join' => true, // jointure gauche avec schedules
  1064.                                 'plus_proche' => true,
  1065.                             ),
  1066.                             'params' => array(
  1067.                                 'order' => 's.dateinsert DESC',
  1068.                                 'limit' => array(0, 100),
  1069.                                 'where' => ' AND statut!=4',
  1070.                             ),
  1071.                             'dbg' => array('spectacles_list', 'Liste des spectacles'),
  1072.                         );
  1073.                         // affichage
  1074.                         $params_display = array(
  1075.                             'stylemore' => array('imagep' => 'width:65px', 'descsp' => 'width:310px;'),
  1076.                         );
  1077.                         $new_tabfile[$k]['others'][$other['object']] = $this->getEntityManager()->getRepository(Spectacles::class)->getListSpectacles($params_sql_spectacle, $params_display);
  1078.                     }
  1080.                 }
  1082.                 // si c'est une image, on le precise
  1083.                 if (in_array($v['extension'], $images_extensions)) {
  1084.                     $new_tabfile[$k]['is_image'] = true;
  1085.                 }
  1086.                 // idem pour du son
  1087.                 if ($v['extension'] == 'mp3') {
  1088.                     $new_tabfile[$k]['is_sound'] = true;
  1089.                 }
  1091.                 if ($v['extension'] == 'pdf') {
  1092.                     if (empty($extra['vignette_width'])) {
  1093.                         $extra['vignette_width'] = 120;
  1094.                     }
  1095.                     $new_tabfile[$k]['vignette'] = $_ENV['URL_DIRECTORYUPLOAD'] . $v['extension'] . '/' . $images->pdf2thumbnail($v['file'], $_ENV['PATH_DIRECTORYUPLOAD'] . $v['extension'] . '/', $extra['vignette_width']);
  1096.                 }
  1098.                 if (!empty($v['language'])) {
  1099.                     $new_tabfile[$k]['language_str'] = $this->translator->trans($v['language']);
  1100.                 }
  1102.                 $new_tabfile[$k]['url_file_path'] = $_ENV['URL_DIRECTORYUPLOAD'] . $v['extension'] . '/' . $v['file'];
  1104.             }
  1106.             // un seul fichier
  1107.             if (!empty($extra['idfile']) && !empty($new_tabfile)) {
  1108.                 foreach ($new_tabfile as $f) {
  1109.                     return $f;
  1110.                 }
  1111.             }
  1113.             return $new_tabfile;
  1114.         }
  1116.         return null;
  1117.     }
  1119.     // }}}
  1121.     //  {{{ deleteVignettes()
  1123.     /** Supprimer les vignettes
  1124.      *
  1125.      * Supprimer toutes les vignettes d'un fichier
  1126.      *
  1127.      * @access   public
  1128.      * @param string $id id du fichier
  1129.      * @param string $objet le type d'objet (personnes, spectacles...)
  1130.      */
  1131.     public function deleteVignettes($idfile, $object = 'spectacles', $idobject = null, $filedata = array(), $thumbsdir = 'thumbs')
  1132.     {
  1133.         $debug = false;
  1134.         if ($debug) file_put_contents('/tmp/files.txt', "idfile=$idfile object=$object idobject=$idobject\n", FILE_APPEND);
  1136.         // retrouver les infos sur le fichier
  1137.         if (empty($filedata) && !empty($idfile)) {
  1138.             $filedata = $this->objToArray($this->get($idfile));
  1139.         }
  1141.         // parcourir les dossiers thumb et supprimer les vignettes
  1142.         $thumbsdir = $_ENV['PATH_DIRECTORYUPLOAD'] . $thumbsdir . '/';
  1143.         if (!empty($filedata['file'])
  1144.             && strpos($filedata['file'], '?') === false
  1145.             && strpos($filedata['file'], '*') === false
  1146.             && is_dir($thumbsdir)) {
  1147.             if ($debug) file_put_contents('/tmp/files.txt', "thumbdir=$thumbsdir\n", FILE_APPEND);
  1149.             $list = $this->func->rglob($filedata['file'], GLOB_NOSORT, $thumbsdir, 'f');
  1150.             if ($debug) file_put_contents('/tmp/files.txt', print_r($list, true), FILE_APPEND);
  1151.             foreach ($list as $thumb) {
  1152.                 @unlink($thumb);
  1153.             }
  1154.         }
  1156.         $idobject = (int)$idobject;
  1157.         if ($idobject > 0 && preg_match('/^[a-z0-9_-]+$/', $object)) {
  1158.             // repertoire des vignettes
  1159.             $vignettes_dir = $_ENV['PATH_DIRECTORYUPLOAD'] . $object . '/';
  1160.             if (is_dir($vignettes_dir)) {
  1161.                 if ($debug) file_put_contents('/tmp/files.txt', "dir=$vignettes_dir\n", FILE_APPEND);
  1163.                 $list = $this->func->rglob('*-' . $idobject . '.jpg', GLOB_NOSORT, $vignettes_dir, 'f');
  1164.                 if ($debug) file_put_contents('/tmp/files.txt', print_r($list, true), FILE_APPEND);
  1165.                 foreach ($list as $vignette) {
  1166.                     @unlink($vignette);
  1167.                 }
  1168.             }
  1169.         }
  1171.         return true;
  1172.     }
  1174.     // }}}
  1176.     //  {{{ deleteVignettesObject()
  1178.     /** Supprime les vignettes d'un objet
  1179.      *
  1180.      * @access public
  1181.      * @param string $object le type d'objet (personnes, spectacles...)
  1182.      * @param int $idobject Identifiant de l'enregistrement
  1183.      * @param string $classification la classification à supprimer
  1184.      * @return bool
  1185.      */
  1186.     public function deleteVignettesObject($object, $idobject, $classification)
  1187.     {
  1188.         // trouver l'idfile associé
  1189.         $filedata = $this->getAssociateFile($idobject, $object, $classification);
  1190.         return $this->deleteVignettes($filedata, $object, $idobject, $filedata);
  1191.     }
  1193.     // }}}
  1195.     //  {{{ getObjectTitle()
  1197.     /** Infos de l'item recherché classification et titre
  1198.      *
  1199.      * @access public
  1200.      * @param int $code Identifiant de l'enregistrement
  1201.      * @return string
  1202.      */
  1203.     public function getObjectTitle($code)
  1204.     {
  1206.         $sql = 'SELECT f.title,cl.classification
  1207.                 FROM files f, classifications cl, file_classification fc
  1208.                 WHERE f.idfile=' . (int)$code;
  1210.         //recuperer la ligne
  1211.         $data = $this->queryRow($sql);
  1213.         if (empty($data)) {
  1214.             return null;
  1215.         }
  1217.         return $data['title'] . ' ' . $this->translator->trans($data['classification']);
  1218.     }
  1220.     // }}}
  1222.     //  {{{ getAssociateFile()
  1224.     /** Recuperer un fichier associé à un objet
  1225.      *
  1226.      * @access   public
  1227.      * @param int $idobject id de l'objet lié
  1228.      * @param string $objet le type d'objet (personnes, spectacles...)
  1229.      * @param string|int|array $classification classification recherchee
  1230.      * @param array $params_content options supplémentaires (tag=>nom du tag, check_lng=>true|false)
  1231.      * @return   array
  1232.      * @see Theatre_Classifications::getAssociate())
  1233.      */
  1234.     public function getAssociateFile($idobject, $object, $classification, $params_content = array())
  1235.     {
  1236.         $fields = '*';
  1237.         $extra = array(
  1238.             'row' => true,
  1239.             'mode' => 'file',
  1240.         );
  1242.         $conn = $this->getEntityManager();
  1243.         $classifications = $conn->getRepository(Classifications::class);
  1244.         $classifications->setPublishStatus($this->publish_status);
  1245.         $data = $classifications->getAssociate($idobject, $object, $classification, $fields, $extra, $params_content);
  1247.         // ajouter le chemin complet
  1248.         if (!empty($data)) {
  1249.             $data['filepath'] = $_ENV['URL_DIRECTORYUPLOAD'] . strtolower($data['extension']) . '/' . $data['file'];
  1250.             //$data['fileAbsPath'] = PATH_IMG.'upload/'.strtolower($data['extension']).'/'.$data['file'];
  1251.         }
  1253.         //retourner le contenu
  1254.         return $data;
  1255.     }
  1257.     // }}}
  1259.     //  {{{ getRelationsArray()
  1261.     /** Description des relations
  1262.      *
  1263.      * @access  public
  1264.      * @param string|int $type si on souhaite retourner uniquement un type precis
  1265.      * @see     Theatre::getLinkedObject()
  1266.      */
  1267.     public function getRelationsArray($type = null)
  1268.     {
  1270.         $array_types = array(
  1271.             'file_classification' => array(// classifications associées
  1272.                 'type_join' => 'multiple',
  1273.                 'dest_table' => 'classifications',
  1274.                 'join_table' => 'file_classification',
  1275.                 'fields' => array('idclassification', 'classification', 'type'),
  1276.             ),
  1277.             'file_template' => array(// classifications associées
  1278.                 'type_join' => 'multiple',
  1279.                 'dest_table' => 'templates',
  1280.                 'join_table' => 'file_template',
  1281.                 'fields' => array('idtemplate', 'description', 'fichier'),
  1282.             ),
  1284.         );
  1286.         // retourne uniquement un type précis
  1287.         if (!empty($array_types[$type])) {
  1288.             $array_types[$type]['type'] = $type;
  1289.             return $array_types[$type];
  1290.         } else {
  1291.             return $array_types;
  1293.         }
  1295.     }
  1297.     // }}}
  1299.     //  {{{ countAssociateFile()
  1301.     /** compter les fichiers associes par type
  1302.      *
  1303.      * @access   public
  1304.      * @param string|int|array $classification classification recherchee
  1305.      * @param int $idobject id de l'objet lié
  1306.      * @param string $objet le type d'objet (personnes, spectacles...)
  1307.      * @return   array
  1308.      * @see Theatre_Classifications::getAssociate())
  1309.      */
  1310.     public function countAssociateFile($object, $idobject, $classification)
  1311.     {
  1312.         // string ou int pour classification
  1313.         $classifications = $this->getEntityManager()->getRepository(Classifications::class);
  1314.         return $classifications->getAssociate($idobject, $object, $classification);
  1315.     }
  1317.     // }}}
  1319.     //  {{{ getClassifications()
  1321.     /** récup les classifications d'un fichier
  1322.      *
  1323.      * @access   public
  1324.      * @param int $idfile id du fichier
  1325.      * @return   array
  1326.      */
  1327.     public function getClassifications($idfile)
  1328.     {
  1330.         $conn = $this->getEntityManager();
  1331.         $classifications = $conn->getRepository(Classifications::class);
  1332.         return $classifications->getObjectClassification($this->__table, $idfile, $this->getRelationsArray('file_classification'));
  1333.     }
  1335.     // }}}
  1337.     //  {{{ isImage()
  1339.     /** image à afficher
  1340.      *
  1341.      * @access   public
  1342.      * @param string $mime_type Mime type du fichier
  1343.      * @return   array
  1344.      */
  1345.     public function isImage($mime_type)
  1346.     {
  1347.         if ($mime_type == 'image/jpeg'
  1348.             || $mime_type == 'image/png'
  1349.             || $mime_type == 'image/gif') {
  1350.             return true;
  1351.         } else {
  1352.             return false;
  1353.         }
  1354.     }
  1356.     // }}}
  1358.     //  {{{ getFileByUrl()
  1360.     /**
  1361.      * télécharger une image et l'ajouter comme fichier associé
  1362.      *
  1363.      * @access   public
  1364.      * @return   array
  1365.      */
  1366.     function getFileByUrl($image, $idclassification, $object_infos)
  1367.     {
  1369.         $object = $object_infos['object'];
  1370.         $idobject = $object_infos['idobject'];
  1372.         $ext = strtolower(substr(strrchr($image, '.'), 1));
  1374.         // telecharger le fichier dans tmp via wget
  1375.         $image_sortie = '/tmp/' . uniqid($object . $idobject . '-') . '.' . $ext;
  1376.         $output = array();
  1377.         $return_code = -1;
  1378.         exec('wget -O ' . escapeshellarg($image_sortie) . ' ' . escapeshellarg($image) . ' 2>&1', $output, $return_code);
  1380.         if (!$return_code) {
  1381.             // pas d'erreur
  1383.             //  nom de fichier aléatoire
  1384.             do {
  1385.                 $nomfichier = uniqid($object . $idobject . '-') . '.jpg';
  1386.                 $relfichier = 'jpg/' . $nomfichier;
  1387.                 $absfichier = $_ENV['PATH_DIRECTORYUPLOAD'] . $relfichier;
  1389.                 $nomfichiertmp = 'tmp-' . $nomfichier;
  1390.                 $relfichiertmp = 'jpg/' . $nomfichiertmp;
  1391.                 $absfichiertmp = $_ENV['PATH_DIRECTORYUPLOAD'] . $relfichiertmp;
  1392.             } while (file_exists($absfichier) || file_exists($absfichiertmp));
  1394.             // conversion en jpg dans un fichier temporaire
  1395.             $output = array();
  1396.             $return_code = -1;
  1397.             exec($_ENV['MAGICK_CONVERT'] . ' ' . escapeshellarg($image_sortie) . ' +repage -unsharp 0x0.5 -background white -quality 85 ' . escapeshellarg($absfichiertmp) . ' 2>&1', $output, $return_code);
  1399.             $ret = false;
  1400.             if (!$return_code) {
  1401.                 chmod($absfichiertmp, self::FILE_MODE);
  1402.                 // pas d'erreur, on renomme le fichier temporaire
  1403.                 $ret = @rename($absfichiertmp, $absfichier);
  1404.             } else {
  1405.                 // on affiche les erreurs
  1406.                 print_r($output);
  1407.             }
  1409.             if (!$ret) {
  1410.                 // on efface le fichier temporaire en cas d'échec
  1411.                 @unlink($absfichiertmp);
  1412.             } else {
  1414.                 // mise à jour de la base
  1415.                 $values = array(
  1416.                     'idtype' => 1,
  1417.                     //'idclassification' => $idclassification,
  1418.                     'file' => $nomfichier,
  1419.                     'title' => $object_infos['title'],
  1420.                     'publish' => 1,
  1421.                     'language' => $object_infos['language'],
  1422.                     'dateinsert' => $this->now(),
  1423.                 );
  1425.                 //objet dans la table OBJECT_FILE
  1426.                 $obj_files = $this->getEntityManager()->getRepository(Files::class);
  1427.                 $obj_objectfile = $this->getEntityManager()->getRepository(ObjectFile::class);
  1429.                 // commencer la transaction
  1430.                 $error = null;
  1431.                 if ($obj_files->supports('transactions')) {
  1432.                     $obj_files->beginTransaction();
  1433.                 }
  1435.                 //champ a mettre a jour
  1436.                 $obj_files->setUpdateFields($values);
  1438.                 $error = false;
  1440.                 //on va créer dans la table file le document
  1441.                 try {
  1442.                     $idfileinsere = $obj_files->setData(null, true);
  1443.                 } catch (\Exception $e) {
  1444.                     $error = $e->getError();
  1445.                     if ($obj_files->in_transaction) {
  1446.                         $obj_files->rollback();
  1447.                     }
  1448.                 }
  1450.                 if ($idfileinsere) {
  1451.                     //mise en forme des données
  1452.                     $values = array(
  1453.                         'idobject' => $idobject,
  1454.                         'object' => $object,
  1455.                         'idfile' => $idfileinsere
  1456.                     );
  1458.                     // champ a mettre a jour
  1459.                     $obj_objectfile->setUpdateFields($values);
  1461.                     // on va créer dans la table object_file le document
  1462.                     try {
  1463.                         $idobjectfile = $obj_objectfile->setData(null, true);
  1464.                     } catch (\Exception $e) {
  1465.                         $error = $e->getError();
  1466.                         if ($obj_files->in_transaction) {
  1467.                             $obj_files->rollback();
  1468.                         }
  1469.                     }
  1471.                     // ajouter dans files_classification
  1472.                     $file_classification = Theatre::factory('file_classification');
  1474.                     //mise en forme des données
  1475.                     $values = array(
  1476.                         'idclassification' => $idclassification,
  1477.                         'idfile' => $idfileinsere
  1478.                     );
  1480.                     // champ a mettre a jour
  1481.                     $file_classification->setUpdateFields($values);
  1483.                     // on va créer dans la table object_file le document
  1484.                     try {
  1485.                         $file_classification->setData(null);
  1486.                     } catch (\Exception $e) {
  1487.                         $error = $e->getError();
  1488.                         if ($obj_files->in_transaction) {
  1489.                             $obj_files->rollback();
  1490.                         }
  1491.                     }
  1493.                     if (empty($error)) {
  1494.                         if ($obj_files->in_transaction) {
  1495.                             $obj_files->commit();
  1496.                         }
  1498.                     } else {
  1499.                         // on efface le fichier image en cas d'échec
  1500.                         @unlink($absfichier);
  1501.                     }
  1503.                 }
  1504.             }
  1506.         }
  1508.     }
  1510.     // }}}
  1512.     //  {{{ getObjects()
  1514.     /**
  1515.      * Trouver les contenus associés à un fichier
  1516.      *
  1517.      * @access   public
  1518.      * @return   array
  1519.      */
  1520.     function getObjects($idfile, $not = array())
  1521.     {
  1523.         $conn = $this->getEntityManager();
  1525.         $sql = 'SELECT *
  1526.                 FROM object_file
  1527.                 WHERE idfile=' . $idfile . ' ';
  1529.         if (!empty($not['idobject'])) {
  1530.             $sql .= ' AND  idobject!=' . $not['idobject'] . ' ';
  1531.         }
  1533.         if (!empty($not['object'])) {
  1534.             $sql .= ' AND  object!=\'' . $not['object'] . '\' ';
  1535.         }
  1537.         $results = $this->queryAll($sql);
  1539.         $associates = array();
  1541.         if (!empty($results)) {
  1542.             foreach ($results as $r) {
  1543.                 $associates[] = array(
  1544.                     'title' => $conn->getRepository('TheatreCore\Entity\\' . $r['object'])->getObjectTitle($r['idobject']),
  1545.                     'url_clean' => $this->getUrlClean($r['idobject'], $r['object']),
  1546.                     'idobject' => $r['idobject'],
  1547.                     'object' => $r['object'],
  1548.                 );
  1549.             }
  1550.         }
  1552.         return $associates;
  1554.     }
  1556.     // }}}
  1558.     //  {{{ getItemsList()
  1560.     /** récup les classifications d'un fichier
  1561.      *
  1562.      * @access   public
  1563.      * @param int $idcontent id du contenu
  1564.      * @return   array
  1565.      */
  1566.     public function getItemsList($idobject = null, $type, $src = null)
  1567.     {
  1568.         // trouver les groupe de menu
  1569.         if ($type == 'file_contact') {
  1570.             $sql = 'SELECT of.*, c.organisation, c.idcontact
  1571.                     FROM object_file of
  1572.                         JOIN contacts c ON of.idobject=c.idcontact
  1573.                     WHERE
  1574.                         of.object=\'contacts\'
  1575.                         AND of.idfile=' . $idobject;
  1576.             $results = $this->queryAll($sql);
  1577.             $itemslist = [];
  1578.             if (!empty($results)) {
  1579.                 foreach ($results as $r) {
  1580.                     $itemslist[$r['idcontact']]['id'] = $r['idcontact'];
  1581.                     $itemslist[$r['idcontact']]['view_name'] = $r['organisation'];
  1582.                 }
  1583.             }
  1584.             return $itemslist;
  1586.         }
  1588.         return $this->getItemsListTrait($idobject, $type, $src);
  1589.     }
  1591.     // }}}
  1593.     //  {{{ getSQLFiles()
  1595.     /** Générer la requete standard pour des fichiers
  1596.      *
  1597.      *
  1598.      * @access   public
  1599.      * @param array $query Les paramètres pour la requete
  1600.      * @param bool $debug afficher la requête TODO
  1601.      * @return   string
  1602.      */
  1603.     public function getSQLFiles($query = array(), $debug = false)
  1604.     {
  1606.         $conn = $this->getEntityManager();
  1608.         // on prepare les tableaux
  1609.         foreach (array('select', 'from', 'where', 'order', 'group', 'limit') as $t) {
  1610.             if (!empty($query[$t])) {
  1611.                 if (!is_array($query[$t])) {
  1612.                     $query[$t][] = $query[$t];
  1613.                 } else {
  1614.                     $query[$t] = $query[$t];
  1615.                 }
  1616.             } else {
  1617.                 $query[$t] = array();
  1618.             }
  1619.         }
  1621.         // champs par défaut
  1622.         $this->addSQLParams('select', $query, array(
  1623.             array('files' => '*'),
  1624.             array('file_classification' => '*'),
  1625.             array('typesfiles' => '*'),
  1626.             array('object_file' => '*')
  1627.         ));
  1629.         $this->addSQLParams('join', $query, array(
  1630.             'files.`idfile`' => 'file_classification.`idfile`',
  1631.             'typesfiles.`idtype`' => 'files.`idtype`',
  1632.             'files.`idfile`' => 'object_file.`idfile`',
  1633.             'file_classification.`idfile`' => 'files.`idfile`',
  1634.         ));
  1636.         // publié ou pas
  1637.         if (empty($query['publish']) && $_ENV['CHECK_IF_ONLINE']) {
  1638.             $this->addSQLParams('where', $query, array(
  1639.                 array('files', 'publish', 1)
  1640.             ));
  1641.         } elseif (!empty($query['publish'])) {
  1642.             $this->addSQLParams('where', $query, array(
  1643.                 array('files', 'publish', $query['publish'])
  1644.             ));
  1645.         }
  1647.         // pour les contacts
  1649.         // champs par défaut
  1650.         $this->addSQLParams('select', $query, array(
  1651.             array('contacts' => 'url_clean,organisation,nom_suite,city')
  1652.         ));
  1653.         $this->addSQLParams('join', $query, array(
  1654.             'object_file.`idobject`' => 'contacts.`idcontact`',
  1655.         ));
  1656.         $this->addSQLParams('where', $query, array(
  1657.             array('object_file', 'object', 'contacts')
  1658.         ));
  1660.         // type de structure
  1661.         if (!empty($query['idtypestructure'])) {
  1662.             $this->addSQLParams('where', $query, array(
  1663.                 array('contacts', 'idtypestructure', $query['idtypestructure'])
  1664.             ));
  1665.         }
  1666.         if (!empty($query['exclude_idtypestructure'])) {
  1667.             $this->addSQLParams('where', $query, array(
  1668.                 array('contacts', 'idtypestructure', $query['exclude_idtypestructure'], 'AND', 'NOT IN')
  1669.             ));
  1670.         }
  1672.         // classification
  1673.         if (!empty($query['idclassification'])) {
  1674.             $this->addSQLParams('where', $query, array(
  1675.                 array('file_classification', 'idclassification', $query['idclassification'])
  1676.             ));
  1677.         }
  1679.         // région
  1680.         if (!empty($query['area'])) {
  1681.             $bigregions = $conn->getRepository(Bigregions::class);
  1682.             $res_area = ' AND ' . $bigregions->getZipCode($query['area'], 'contacts');
  1683.             if (!$bigregions->getZipCode($query['area'], 'contacts')) {
  1684.                 return false;
  1685.             }
  1686.             $this->addSQLParams('where', $query, array($res_area));
  1687.         }
  1689.         // plauqtettes d'un contact
  1690.         if (!empty($query['idcontacts'])) {
  1691.             $this->addSQLParams('where', $query, array(
  1692.                 array('contacts', 'idcontact', $query['idcontacts'])
  1693.             ));
  1694.         }
  1696.         // par saison
  1697.         if (!empty($query['saison'])) {
  1698.             // si plusieurs saisons
  1699.             if (is_array($query['saison'])) {
  1700.                 foreach ($query['saison'] as $s) {
  1701.                     $s = explode('-', $s);
  1702.                     $sql_where_saison[] = ' (files.`date_start`=\'' . $s[0] . '-09-01\' AND files.`date_end`=\'' . $s[1] . '-08-31\') ';
  1703.                 }
  1704.                 $this->addSQLParams('where', $query, array(' AND (' . implode(' OR ', $sql_where_saison) . ') '));
  1705.             } else {
  1706.                 $saison = explode('-', $query['saison']);
  1707.                 $this->addSQLParams('where', $query, array(
  1708.                     array('files', 'date_start', $saison[0] . '-09-01'),
  1709.                     array('files', 'date_end', $saison[1] . '-08-31'),
  1710.                 ));
  1711.                 $this->addSQLParams('order', $query, array('files.`dateinsert`'));
  1712.                 $this->addSQLParams('direction', $query, 'DESC');
  1713.             }
  1714.         }
  1716.         // le dernier
  1717.         if (!empty($query['max'])) {
  1718.             $this->addSQLParams('order', $query, array('files.`date_end`'));
  1719.             $this->addSQLParams('limit', $query, array(0, 1));
  1720.         }
  1722.         return $this->getSQLObject($query);
  1724.     }
  1726.     // }}}
  1728.     //  {{{ getListFiles()
  1730.     /** Retourne des listes de fichiers
  1731.      *
  1732.      * Retourne des listes de fichiers au format "standard""
  1733.      *
  1734.      * @access   public
  1735.      * @param array $params_sql paramètre pour la requete SQL
  1736.      * @param array $format_vignette de la vignette si pas standard
  1737.      * @param array $params_display paramètre pour l'affichage
  1738.      * @return   array
  1739.      */
  1740.     public function getListFiles($params_sql = null, $format_vignette = array(), $params_display = array())
  1741.     {
  1743.         // si pas de tableau
  1744.         if (!isset($params_sql['special'])) {
  1745.             $params_sql['special'] = array();
  1746.         }
  1747.         if (!isset($params_sql['params'])) {
  1748.             $params_sql['params'] = array();
  1749.         }
  1751.         // construction de la requête avec le passage de paramètres
  1752.         $sql = $this->getSQLFiles($params_sql);
  1754.         if (!$sql) {
  1755.             return false;
  1756.         }
  1758.         // paramètre de debug
  1759.         $dbg = (empty($params_sql['dbg'])) ? array() : $dbg = $params_sql['dbg'];
  1761.         // executer la requete
  1762.         $this->query($sql, $dbg);
  1764.         // debug
  1765.         $start_boucle = microtime(true);
  1767.         $files = array();
  1769.         // on boucle
  1770.         while ($this->fetch()) {
  1771.             // le total
  1772.             if (!empty($params_sql['count_only'])) {
  1773.                 return $this->total;
  1774.             }
  1775.             $idfile = $this->idfile;
  1776.             $files[$idfile] = $this->getInfosFile($idfile, array('all' => true));
  1777.         }
  1779.         // debug de la boucle
  1780.         if ($this->isTraceMode('list_object')) {
  1781.             $this->setTraceInfos(array(
  1782.                 'execution_time_boucle' => microtime(true) - $start_boucle,
  1783.                 'nb_occurence' => count($files),
  1784.                 'dbg' => $dbg,
  1785.             ));
  1786.         }
  1788.         // groupement par saison
  1789.         if (!empty($files) && !empty($params_display['group_by_saison'])) {
  1790.             foreach ($files as $file) {
  1791.                 $files_by_saison[$file['saison']]['saison'] = $file['saison'];
  1792.                 $files_by_saison[$file['saison']]['programmes'][] = $file;
  1793.             }
  1794.             return $files_by_saison;
  1795.         }
  1797.         $this->free();
  1799.         return $files;
  1801.     }
  1803.     // }}}
  1805.     // {{{ getSaisons()
  1807.     /** Trouver les saisons qui ont des programmes
  1808.      *
  1809.      * @access public
  1810.      * @return int
  1811.      */
  1812.     public function getSaisons($params = array())
  1813.     {
  1815.         $sql_annees = '
  1816.             SELECT `files`.date_start as `date`, CONCAT_WS(\'-\', YEAR(files.`date_start`), YEAR(files.`date_end`)) as saison, YEAR(files.`date_start`) as annee
  1817.             FROM files
  1818.             WHERE CONCAT_WS(\'-\', YEAR(files.`date_start`), YEAR(files.`date_end`))!=\'0-0\' ';
  1820.         if (!empty($params['start_at'])) {
  1821.             $sql_annees .= ' AND files.`date_start`>=\'' . $params['start_at'] . '\' ';
  1822.         }
  1824.         $sql_annees .= '
  1825.             GROUP BY saison
  1826.             ORDER BY saison';
  1828.         $listdates = $this->queryAll($sql_annees);
  1830.         // liste des saisons et des années
  1831.         if (empty($listdates)) {
  1832.             return array();
  1833.         } else {
  1834.             return $listdates;
  1835.         }
  1837.     }
  1839.     // }}}
  1841.     //  {{{ getBookletsCurrent()
  1843.     /** Programmes de saison ou le plus récent
  1844.      *
  1845.      *
  1846.      * @access   public
  1847.      * @param integer $idcontact Contact
  1848.      * @return   array
  1849.      */
  1850.     public function getBookletsCurrent($idcontact, $get_next = false)
  1851.     {
  1853.         // voir si il y a des booklets pour la saison courante
  1854.         $current_saison = \TheatreCore\Classes\Date\DateTime::getLastSaison();
  1856.         $list = $this->getListFiles(array(
  1857.             'idcontacts' => $idcontact,
  1858.             'idclassification' => array(112),
  1859.             'saison' => array($current_saison),
  1860.             'dbg' => array('booklet_saison_' . $current_saison, 'Programme de la saison ' . $current_saison . ' pour le contact ' . $idcontact),
  1861.         ));
  1863.         // sinon, le dernier fichier
  1864.         if (empty($list)) {
  1865.             $list = $this->getListFiles(array(
  1866.                 'max' => true,
  1867.                 'idcontacts' => $idcontact,
  1868.                 'idclassification' => array(112),
  1869.                 'dbg' => array('booklet_saison', 'Programme le plus récent pour le contact ' . $idcontact),
  1870.             ));
  1871.         } else {
  1872.             // si demandé, vérifier également la saison suivante
  1873.             if ($get_next) {
  1874.                 $current_saison = explode('-', $current_saison);
  1875.                 $next_saison = ($current_saison[0] + 1) . '-' . ($current_saison[1] + 1);
  1876.                 $list += $this->getListFiles(array(
  1877.                     'idcontacts' => $idcontact,
  1878.                     'idclassification' => array(112),
  1879.                     'saison' => array($next_saison),
  1880.                     'dbg' => array('booklet_saison_' . $next_saison, 'Programme de la saison ' . $next_saison . ' pour le contact ' . $idcontact),
  1881.                 ));
  1882.             }
  1883.         }
  1885.         // on retourne le premier de la liste
  1886.         if (!empty($list)) {
  1887.             return $list;
  1888.         }
  1890.     }
  1892.     // }}}
  1894.     //  {{{ getBookletsBySaison()
  1896.     /** Les programmes de saison
  1897.      *
  1898.      *
  1899.      * @access   public
  1900.      * @param array $saison La saison
  1901.      * @param integer $idcontact Le contact
  1902.      * @return   string
  1903.      */
  1904.     public function getBookletsBySaison($saison, $idcontact)
  1905.     {
  1907.         $list = $this->getListFiles(array(
  1908.             'saison' => $saison,
  1909.             'idcontacts' => $idcontact,
  1910.             'idclassification' => array(112),
  1911.             'dbg' => array('booklet_saison', 'Programmes de la saison ' . $saison . ' pour le contact ' . $idcontact),
  1912.         ));
  1914.         // on retourne le premier de la liste
  1915.         if (!empty($list)) {
  1916.             return $list;
  1917.         }
  1919.     }
  1921.     // }}}
  1924.     public function getExtension()
  1925.     {
  1926.         if ($this->hasFile()) {
  1927.             echo 'ok';
  1928.             exit;
  1929.         }
  1930.     }
  1931. }