vendor/theatre/core/src/Repository/AidesRepository.php line 460

Open in your IDE?
  1. <?php
  3. namespace TheatreCore\Repository;
  5. use TheatreCore\Entity\Aidecontacts;
  6. use TheatreCore\Entity\Aides;
  7. use TheatreCore\Traits\TheatreTrait;
  8. use TheatreCore\Entity\Contacts;
  9. use Doctrine\Bundle\DoctrineBundle\Repository\ServiceEntityRepository;
  10. use Doctrine\Persistence\ManagerRegistry;
  11. use Doctrine\ORM\Query;
  12. use Symfony\Contracts\Translation\TranslatorInterface;
  14. /**
  15.  * AidesRepository
  16.  *
  17.  * This class was generated by the Doctrine ORM. Add your own custom
  18.  * repository methods below.
  19.  */
  20. class AidesRepository extends ServiceEntityRepository
  21. {
  22.     use TheatreTrait;
  24.     private $em;
  25.     public $__table;
  26.     public $__table_object;
  27.     public $__idtable;
  29.     public function __construct(ManagerRegistry $registry, TranslatorInterface $translator)
  30.     {
  31.         parent::__construct($registry, Aides::class);
  32.         $this->__table = $this->getClassMetadata()->getTableName();
  33.         $this->__table_object = $this->getClassMetadata()->name;
  34.         $this->__idtable = $this->getClassMetadata()->getSingleIdentifierFieldName();
  36.         $this->translator = $translator;
  37.     }
  39.     //  {{{ findData()
  41.     /** Recherche d'aide
  42.      *
  43.      * Permet de rechercher des aides selon différents critères
  44.      *
  45.      * @access  public
  46.      * @see     Theatre::find()
  47.      */
  48.     public function findData($idclassification = null)
  49.     {
  51.         $query = $this->createQueryBuilder('e');
  53.         if ($this->getCount()) {
  54.             $query->select('COUNT(e.idaide)');
  56.             $this->setCount(false);
  58.             return $query;
  59.         }
  60. //
  61. //        // parametres
  62. //        if(isset($_REQUEST['keywords']) && $_REQUEST['keywords']!='nom') {
  63. //            $keywords = filter_var(trim($_REQUEST['keywords']));
  64. //        }
  65. //        if(isset($_REQUEST['idaide']) && my_is_int($_REQUEST['idaide'])) {
  66. //            $idaide = (int)$_REQUEST['idaide'];
  67. //        }
  68. //
  69. //        // query perso
  70. //        $query = 'SELECT '.$this->__table.'.* FROM '.$this->__table.'
  71. //                    LEFT JOIN aidecontacts ON aidecontacts.idaidecontact = aides.idaidecontact
  72. //                    LEFT JOIN contacts ON contacts.idcontact = aides.idcontact
  73. //                    WHERE  1';
  74. //
  75. //        //recherche stricte par id
  76. //        if(!empty($idaide)) {
  77. //            $query .= ' AND cl.idaide='.(int)$idaide;
  78. //        } else {
  79. //            // mots cles
  80. //            if (!empty($keywords)) {
  81. //                $query .= ' AND (aide LIKE \'%'.$this->escape($keywords).'%\' OR aidecontacts.title LIKE \'%'.$this->escape($keywords).'%\' OR contacts.organisation LIKE \'%'.$this->escape($keywords).'%\') ';
  82. //            }
  83. //        }
  85.         // on lance la recherche
  86.         return $query->getQuery();
  88.     }
  90.     // }}}
  92.     //  {{{ setToArray()
  94.     /** Liste des aides dans un tableau associatif
  95.      *
  96.      * Tableau associatif notament utilisé pour lister les informations sur des aides
  97.      * Utile pour générer les tableaux HTML de listes de aides
  98.      *
  99.      * @access  public
  100.      * @return  array
  101.      * @see     findData()
  102.      */
  103.     public function setToArray($spec = true)
  104.     {
  105.         if ($spec == true) {
  106.             $this->findData();
  107.         }
  109.         $values = array();
  110.         $color = null;
  111.         $nb = 0;
  113.         while ($this->fetch()) {
  115.             $values[$nb] = $this->getInfosAide(null, array('get_contact' => true, 'get_aidecontact' => true));
  116.             $values[$nb]['id'] = $this->idaide;
  118.             // couleur de ligne alternative
  119.             $color = $this->colorAlternate($color);
  120.             $values[$nb]['colorline'] = $color;
  122.             $nb++;
  123.         }
  125.         return $values;
  126.     }
  128.     // }}}
  130.     //  {{{ getInfosAide()
  132.     /** Informations sur une aide
  133.      *
  134.      * @access public
  135.      * @param int $idaide Identifiant de l'aide
  136.      * @return array
  137.      */
  138.     public function getInfosAide($idaide = null, $params = array())
  139.     {
  141.         $infos = array();
  143.         ////////////// infos de la table
  144.         if (empty($this->idaide) || $idaide) {
  146.             $infos = $this->createQueryBuilder('u')
  147.                 ->select('u, ac, uc')
  148.                 ->leftJoin('u.idaidecontact', 'ac')
  149.                 ->leftJoin('u.idcontact', 'uc')
  150.                 ->where('u.' . $this->__idtable . ' =:value')->setParameter('value', $idaide)
  151.                 ->getQuery()
  152.                 ->getOneOrNullResult(Query::HYDRATE_ARRAY);
  154.             $this->loadResult($infos);
  156.         }
  158.         $infos += array(
  159.             'idaide' => $this->idaide,
  160.             'idcontact' => $this->idcontact,
  161.             'type_aide' => $this->typeAide,
  162.             'idaidecontact' => $this->idaidecontact,
  163.             'aide' => $this->aide,
  164.             'description' => $this->description,
  165.             'url_clean' => $this->urlClean,
  166.             'dateupdate' => $this->dateupdate,
  167.             'dateinsert' => $this->dateinsert,
  168.             'publish' => $this->publish,
  169.         );
  171.         if (!empty($infos['typeAide'])) {
  172.             $infos['type_aide_label'] = $this->getAideTypes($infos['typeAide']);
  173.             $infos['type_aide_infos'] = $this->getAideTypes($infos['typeAide'], false);
  174.         } else {
  175.             $infos['type_aide_label'] = null;
  176.         }
  178.         $mentions = array(
  179.             'Spectacles' => 'le spectacle',
  180.             'Texts' => 'le texte',
  181.             'Contacts' => 'la structure',
  182.             'Persons' => 'la biographie',
  183.         );
  185.         foreach ($mentions as $f => $v) {
  186.             $infos['mention_' . $f] = $this->{'mention' . ucfirst($f)};
  187.         }
  189.         $con = $this->getEntityManager();
  191.         // récupère les infos sur le contact
  192.         if (!empty($params['get_contact']) && $infos['idcontact'] != '') {
  193.             $infos['contact'] = $con->getRepository(Contacts::class)->getInfosContact($infos['idcontact'], array('get_profile_picture' => true));
  194.         }
  197.         // récupère les infos sur la catégorie
  198.         if (!empty($params['get_aidecontact']) && !empty($infos['idaidecontact'])) {
  199.             $infos['aidecontact'] = $con->getRepository(Aidecontacts::class)->getInfosAidecontact($infos['idaidecontact']['idaidecontact']);
  200.         }
  202.         $infos['nameview'] = $infos['aide'];
  204.         return $infos;
  206.     }
  208.     // }}}
  210.     //  {{{ getObjectTitle()
  212.     /** Infos de l'item recherché
  213.      *
  214.      *
  215.      * @access public
  216.      * @param int $idobject Identifiant de l'item
  217.      * @param array $infos_object Informations pour construire le titre
  218.      * @param array $params Paramétres supplémentaires
  219.      * @return string|array
  220.      */
  221.     public function getObjectTitle($idobject = null, $infos_object = array(), $params = array())
  222.     {
  224.         if (!$idobject && isset($this->idaide)) $idobject = $this->idaide;
  226.         // champs
  227.         $fields = array('idaide', 'aide', 'url_clean');
  229.         if (!empty($infos_object)) {
  231.             foreach ($fields as $k => $v) {
  232.                 if (array_key_exists($v, $infos_object)) {
  233.                     $infos[$v] = $infos_object[$v];
  234.                 } else {
  235.                     $infos[$v] = '';
  236.                 }
  237.             }
  239.         } else {
  241.             //charger les infos que si necessaire
  242.             if (empty($this->aide)) {
  244.                 $sql = 'SELECT ' . implode(',', $fields) . '
  245.                         FROM ' . $this->__table . '
  246.                         WHERE ' . $this->__idtable . '=' . $idobject;
  248.                 $infos = $this->queryRow($sql);
  249.             } else {
  250.                 foreach ($fields as $k => $v) {
  251.                     if (isset($this->$v) && $this->$v != '') {
  252.                         $infos[$v] = trim($this->$v);
  253.                     } else {
  254.                         $infos[$v] = '';
  255.                     }
  256.                 }
  257.             }
  259.         }
  261.         $infos = $this->getInfosAide($idobject, array(
  262.             'get_contact' => true,
  263.             'get_aidecontact' => true,
  264.         ));
  266.         // catégorie
  267.         if (!empty($infos['aidecontact'])) {
  268.             $title[] = $infos['aidecontact']['title'];
  269.         }
  271.         $title[] = $infos['aide'];
  273.         if (!empty($infos['type_aide_label'])) {
  274.             $title[] = $infos['type_aide_label'];
  275.         }
  277.         // contact
  278.         if (!empty($infos['contact'])) {
  279.             $title[] = $infos['contact']['organisation'];
  280.         }
  282.         $infos['title'] = join(' / ', $title);
  284.         // renvoyer un array plutôt que le titre (utile si on veux l'url)
  285.         if (array_key_exists('return_array', $params)) {
  286.             return $infos;
  287.         }
  289.         return $infos['title'];
  291.     }
  293.     // }}}
  295.     //  {{{ getRelationsArray()
  297.     /** Décrit les relations de l'objet
  298.      *
  299.      * @access  public
  300.      * @param string|int $type si on souhaite retourner uniquement un type precis
  301.      * @see     Theatre::getLinkedObject()
  302.      */
  303.     public function getRelationsArray($type)
  304.     {
  306.         $array_types = array(
  307.             'idcontact' => array(// contacts associés ?
  308.                 'type_join' => 'simple',
  309.                 'dest_table' => 'contacts',
  310.                 'fields' => array('idcontact', 'organisation', 'lastname', 'firstname', 'type', 'url_clean', 'valid'),
  311.                 'join_field_src' => 'idcontact',
  312.                 'description' => 'Contact associé à l\'aide',
  313.                 'silent_delete_relation' => true,
  314.             ),
  315.             'text_aide' => array(// text associés ?
  316.                 'type_join' => 'multiple',
  317.                 'dest_table' => 'texts',
  318.                 'fields' => array('idtext', 'title', 'publish', 'url_clean', 'valid'),
  319.                 'join_table' => 'text_aide',
  320.                 'description' => 'Textes associé à l\'aide',
  321.                 'silent_delete_relation' => true,
  322.             ),
  323.         );
  325.         // retourne uniquement un type précis
  326.         if ($type == 'all') {
  327.             return $array_types;
  328.         }
  330.         if (!empty($array_types[$type])) {
  331.             $array_types[$type]['type'] = $type;
  332.             return $array_types[$type];
  333.         } else {
  334.             return null;
  335.         }
  337.     }
  339.     // }}}
  341.     //  {{{ getListSearch()
  343.     /** Liste des aides
  344.      *
  345.      * Pour les champs Ajax de relations et les recherches diverses
  346.      *
  347.      * @access  public
  348.      * @param string $lettres Pour la recherche alphabetique
  349.      * @param string $type Pour le type recherche (editeurs, revues...)
  350.      * @param string $keywords Recherche par mots cles
  351.      * @return  array
  352.      */
  353.     public function getListSearch($lettre, $type = null, $keywords = null)
  354.     {
  355.         $sql = 'SELECT a.idaide, a.aide, a.type_aide, c.organisation, ac.title
  356.                  FROM ' . $this->__table . ' a
  357.                  JOIN contacts c ON c.idcontact=a.idcontact
  358.                  LEFT JOIN aidecontacts ac ON a.idaidecontact=ac.idaidecontact
  359.                  WHERE 1 ';
  361.         // selection par ordre alpha
  362.         if (!empty($lettre) && $lettre != 'tous') {
  363.             $sql_where[] = array('LOWER(LEFT(LTRIM(aide),1))=\'' . $this->escape($lettre) . '\'');
  364.         }
  366.         // recherche avec un mot cle
  367.         $list = $this->splitKeywords($keywords);
  369.         if ($list) {
  370.             if (!empty($list[$this->IDSTR])) {
  371.                 // mots clés
  372.                 foreach ($list[$this->IDSTR] as $s) {
  373.                     $sql_more_name[] = 'aide LIKE \'%' . $s . '%\'';
  374.                 }
  375.                 $sql_where[] = array('(' . join(' OR ', $sql_more_name) . ')');
  376.             }
  377.             if (!empty($list[$this->IDNUM])) {
  378.                 // recherche par numéro d'id pour les mots clés numériques
  379.                 $sql_where[] = array('idaide IN (' . implode(',', $list[$this->IDNUM]) . ')', 'OR');
  380.             }
  381.         }
  383.         if (!empty($sql_where)) {
  384.             foreach ($sql_where as $k => $v) {
  385.                 if (!empty($v[1])) {
  386.                     $sql .= ' ' . $v[1] . ' ' . $v[0];
  387.                 } else {
  388.                     $sql .= ' AND ' . $v[0];
  389.                 }
  390.             }
  391.         }
  393.         $sql .= ' ORDER BY title';
  395.         $this->query($sql);
  397.         $r = array();
  399.         while ($this->fetch()) {
  400.             $infos = array();
  401.             foreach (array('title', 'aide', 'type_aide', 'organisation') as $f) {
  402.                 if (!empty($this->$f)) {
  403.                     if ($f == 'type_aide') {
  404.                         $infos[$f] = $this->getAideTypes($this->$f);
  405.                     } else {
  406.                         $infos[] = $this->$f;
  407.                     }
  408.                 }
  409.             }
  410.             $r[$this->idaide] = join(' / ', $infos);
  411.             // si trouvé par id, on l'affiche en fin de titre
  412.             if (!empty($list[$this->IDNUM]) && in_array($this->idaide, $list[$this->IDNUM])) {
  413.                 $r[$this->idaide] .= ' - n°' . $this->idaide;
  414.             }
  415.         }
  416.         $this->free();
  418.         return $r;
  419.     }
  421.     // }}}
  423.     //  {{{ getListAides()
  425.     /** Retourne des listes des aides
  426.      *
  427.      * Retourne des listes de aides au format "standard""
  428.      *
  429.      * @access   public
  430.      * @param array $params_sql paramètre pour la requete SQL
  431.      * @param array $format_vignette de la vignette si pas standard
  432.      * @param array $params_display paramètre pour l'affichage
  433.      * @return   array
  434.      */
  435.     public function getListAides($params_sql = null, $format_vignette = array(), $params_display = array())
  436.     {
  438.         $conn = $this->getEntityManager();
  440.         // si pas de tableau
  441.         if (!isset($params_sql['special'])) {
  442.             $params_sql['special'] = array();
  443.         }
  444.         if (!isset($params_sql['params'])) {
  445.             $params_sql['params'] = array();
  446.         }
  448.         // construction de la requête avec le passage de paramètres
  449.         $sql = $this->getSQLAides($params_sql);
  451.         // vignettes
  452.         if (empty($params['format_vignette'])) {
  453.             $format_vignette = array('width' => 130, 'height' => 110, 'direction' => 'thumb');
  454.         }
  456.         // paramètre de debug
  457.         $dbg = (empty($params_sql['dbg'])) ? array() : $dbg = $params_sql['dbg'];
  459.         // executer la requete
  460.         $this->query($sql, $dbg);
  461.         $videos = array();
  463.         // donnée entières ?
  464.         if (empty($params_display['alldata'])) {
  465.             $params_display['alldata'] = false;
  466.         }
  468.         // debug
  469.         $start_boucle = microtime(true);
  471.         $aides = array();
  473.         // on boucle
  474.         while ($this->fetch()) {
  475.             $idaide = $this->idaide;
  476.             if (!empty($params_sql['fields'])) {
  477.                 foreach ($params_sql['fields'] as $f) {
  478.                     $aides[$idaide][$f] = $this->$f;
  479.                 }
  480.             } else {
  481.                 $aides[$idaide] = $this->getInfosAide($idaide, array('get_contact' => true, 'get_aidecontact' => true));
  482.                 $aides[$idaide]['description_courte'] = $this->cutSentence(strip_tags($aides[$idaide]['description']), 45, true);
  483.             }
  484.         }
  486.         // debug de la boucle
  487.         if ($this->isTraceMode('list_object')) {
  488.             $this->setTraceInfos(array(
  489.                 'execution_time_boucle' => microtime(true) - $start_boucle,
  490.                 'nb_occurence' => count($aides),
  491.                 'dbg' => $dbg,
  492.             ));
  493.         }
  495.         $this->free();
  497.         // grouper par contact
  498.         if (!empty($params_display['group_by_contact']) && !empty($aides)) {
  499.             foreach ($aides as $k => $v) {
  500.                 $aides_by_contact[$v['contact']['idcontact']] = $v['contact'];
  501.                 $aides_by_contact[$v['contact']['idcontact']]['profile_picture'] = $conn->getRepository(Contacts::class)->getVignetteContact($v['contact']['idcontact'], array(), 'class_pp');
  502.                 if (strpos($aides_by_contact[$v['contact']['idcontact']]['profile_picture'], 'normal-def.jpg') !== false) {
  503.                     $aides_by_contact[$v['contact']['idcontact']]['profile_picture'] = $_ENV['URL_THNET'] . '/images/menu/interface/no_contact-100x100.png';
  504.                 }
  505.             }
  506.             return $aides_by_contact;
  507.         }
  509.         // grouper par type d'aides
  510.         if (!empty($params_display['groupe_by_type']) && !empty($aides)) {
  511.             foreach ($aides as $k => $v) {
  512.                 if (empty($aides_by_type[$this->getAideTypes($v['type_aide'], false, true)]['type_aide'])) {
  513.                     $aides_by_type[$this->getAideTypes($v['type_aide'], false, true)] = array(
  514.                         'type_aide' => $v['type_aide'],
  515.                         'type_aide_label' => $this->getAideTypes($v['type_aide'], true, false),
  516.                     );
  517.                 }
  518.                 $aides_by_type[$this->getAideTypes($v['type_aide'], false, true)]['datas'][$v['idaide']] = $v;
  519.             }
  520.             return $aides_by_type;
  521.         }
  523.         return $aides;
  525.     }
  527.     // }}}
  529.     //  {{{ countListAides()
  531.     /** Compter la liste des aides
  532.      *
  533.      * @access   public
  534.      * @param array $params_sql paramètre pour la requete SQL
  535.      * @param bool $debug mode débugage
  536.      * @return   int
  537.      */
  538.     public function countListAides($params_sql = null, $debug = false)
  539.     {
  541.         // si pas de limite => tout
  542.         if (empty($params_sql['limit'])) {
  543.             $params_sql['limit'] = array('all');
  544.         }
  546.         $params_sql['special']['count_only'] = true;
  548.         // construction de la requête avec le passage de paramètres
  549.         return $this->queryOne($this->getSQLAides($params_sql, $debug));
  551.     }
  553.     // }}}
  555.     //  {{{ getSQLAides()
  557.     /** Générer la requete standard pour des aides
  558.      *
  559.      * @access   public
  560.      * @param array $aueru Les paramètres pour la requete
  561.      * @param bool $debug afficher la requête
  562.      * @return   string
  563.      */
  564.     public function getSQLAides($query = array(), $debug = false)
  565.     {
  567.         // on prepare les tableaux
  568.         foreach (array('select', 'from', 'where', 'order', 'group', 'limit') as $t) {
  569.             if (!empty($query[$t])) {
  570.                 if (!is_array($query[$t])) {
  571.                     $query[$t][] = $query[$t];
  572.                 } else {
  573.                     $query[$t] = $query[$t];
  574.                 }
  575.             } else {
  576.                 $query[$t] = array();
  577.             }
  578.         }
  580.         // champs par défaut
  581.         $this->addSQLParams('select', $query, array(
  582.             array('aides' => '*')
  583.         ));
  585.         $this->addSQLParams('from', $query, array(
  586.             'contacts',
  587.         ));
  588.         $this->addSQLParams('join', $query, array(
  589.             'aides.`idcontact`' => 'contacts.`idcontact`',
  590.         ));
  592.         // publié ou pas
  593.         if (empty($query['publish']) && $_ENV['CHECK_IF_ONLINE']) {
  594.             $this->addSQLParams('where', $query, array(
  595.                 array('aides', 'publish', 1)
  596.             ));
  597.         } elseif (!empty($query['publish'])) {
  598.             $this->addSQLParams('where', $query, array(
  599.                 array('aides', 'publish', $query['publish'])
  600.             ));
  601.         }
  603.         // recherche par liaison via text_aide
  604.         if (!empty($query['special']['idtexts']) || !empty($query['special']['text_aide'])) {
  605.             $this->addSQLParams('from', $query, array(
  606.                 'text_aide',
  607.             ));
  608.             // jointure entre les 3 tables
  609.             $this->addSQLParams('join', $query, array(
  610.                 'aides.`idaide`' => 'text_aide.`idaide`',
  611.             ));
  612.         }
  614.         if (!empty($query['special']['idtexts'])) {
  615.             if (is_array($query['special']['idtexts'])) {
  616.                 $this->addSQLParams('where', $query, array(
  617.                     array('text_aide', 'idtext', $query['special']['idtexts']),
  618.                 ));
  619.             } else {
  620.                 $this->addSQLParams('group', $query, 'no');
  621.                 $this->addSQLParams('distinct', $query, 'no');
  622.                 $this->addSQLParams('select', $query, array(
  623.                     array('text_aide' => '*')
  624.                 ));
  625.             }
  626.         }
  628.         // recherche des aides d'un contact
  629.         if (!empty($query['special']['aides']['idcontacts'])) {
  630.             $this->addSQLParams('where', $query, array(
  631.                 array('aides', 'idcontact', $query['special']['aides']['idcontacts']),
  632.             ));
  633.         }
  635.         // recherche par type
  636.         if (!empty($query['special']['type_aides'])) {
  637.             $query['special']['type_aide'] = $query['special']['type_aides'];
  638.         }
  639.         if (!empty($query['special']['type_aide'])) {
  640.             $this->addSQLParams('where', $query, array(
  641.                 array('aides', 'type_aide', $query['special']['type_aide']),
  642.             ));
  643.         }
  645.         // recherche par type
  646.         if (!empty($query['special']['idaidecontact'])) {
  647.             $this->addSQLParams('where', $query, array(
  648.                 array('aides', 'idaidecontact', $query['special']['idaidecontact']),
  649.             ));
  650.         }
  652.         // si object => liaison
  653.         if (!empty($query['special']['contact_aide']) || !empty($query['special']['idcontacts'])) {
  654.             $this->addSQLParams('from', $query, array(
  655.                 'contact_aide',
  656.             ));
  657.             // jointure entre les 3 tables
  658.             $this->addSQLParams('join', $query, array(
  659.                 'aides.`idaide`' => 'contact_aide.`idaide`',
  660.             ));
  661.         }
  663.         // recherche par liaison via contact_aide
  664.         if (!empty($query['special']['idcontacts'])) {
  665.             $this->addSQLParams('where', $query, array(
  666.                 array('contact_aide', 'idcontact', $query['special']['idcontacts']),
  667.             ));
  668.         }
  670.         // si object => liaison
  671.         if (!empty($query['special']['spectacle_aide']) || !empty($query['special']['idspectacles'])) {
  672.             $this->addSQLParams('from', $query, array(
  673.                 'spectacle_aide',
  674.             ));
  675.             // jointure entre les 3 tables
  676.             $this->addSQLParams('join', $query, array(
  677.                 'aides.`idaide`' => 'spectacle_aide.`idaide`',
  678.             ));
  679.         }
  681.         // recherche par liaison via _aide
  682.         if (!empty($query['special']['idspectacles'])) {
  683.             $this->addSQLParams('where', $query, array(
  684.                 array('spectacle_aide', 'idspectacle', $query['special']['idspectacles']),
  685.             ));
  686.         }
  688.         return $this->getSQLObject($query);
  690.     }
  692.     // }}}
  694.     //  {{{ countAides()
  696.     /** Compter la liste des aides nominations ou laureats
  697.      *
  698.      * @access   public
  699.      * @param array $params_sql paramètre pour la requete SQL
  700.      * @param bool $debug mode débugage
  701.      * @return   int
  702.      */
  703.     public function countAides($params_sql = null, $debug = false)
  704.     {
  706.         $nb = 0;
  708.         foreach (array('spectacle', 'text', 'person', 'contact') as $t) {
  710.             $sql = 'SELECT COUNT(' . $t . '_aide.`idaide`)
  711.                     FROM aides
  712.                     JOIN ' . $t . '_aide ON ' . $t . '_aide.`idaide`=aides.`idaide`
  713.                     WHERE aides.`idcontact`=' . (int)$params_sql['special']['aides']['idcontacts'] . '
  714.                     AND aides.`type_aide`=' . (int)$params_sql['special']['type_aide'] . ' ';
  716.             $nb = $nb + $this->queryOne($sql);
  718.         }
  720.         return $nb;
  722.     }
  724.     // }}}
  726.     //  {{{ getAides()
  728.     /** Retourne des listes des aides
  729.      *
  730.      * Retourne des listes de aides au format "standard""
  731.      *
  732.      * @access   public
  733.      * @return   array
  734.      */
  735.     public function getAides()
  736.     {
  738.         $sql = 'SELECT idaide,aide
  739.                 FROM ' . $this->__table . ' WHERE 1 ';
  741.         return $this->queryAll($sql, array(), null, true);
  743.     }
  745.     // }}}
  747.     //  {{{ getAideTypes()
  749.     /** Retourne des listes des types
  750.      *
  751.      * Retourne des listes de type d'aide'
  752.      *
  753.      * @access   public
  754.      * @return   array
  755.      */
  756.     public function getAideTypes($type_aide = null, $label = true, $name = false, $params = array())
  757.     {
  759.         $types_aide = array(
  760.             1 => array(
  761.                 'label' => 'Aide/soutien',
  762.                 'contact_link' => '',
  763.                 'name' => 'aides',
  764.             ),
  765.             2 => array(
  766.                 'label' => 'Lauréat',
  767.                 'contact_link' => 'laureats',
  768.                 'name' => 'prix',
  769.             ),
  770.             3 => array(
  771.                 'label' => 'Nomination',
  772.                 'contact_link' => 'nominations',
  773.                 'name' => 'nomination',
  774.             ),
  775.             4 => array(
  776.                 'label' => 'Sélection',
  777.                 'contact_link' => 'selections',
  778.                 'name' => 'selection',
  779.             )
  780.         );
  782.         if ($label) {
  783.             foreach ($types_aide as $k => $v) {
  784.                 $types_aide_label[$k] = $v['label'];
  785.             }
  786.             $types_aide = $types_aide_label;
  787.         }
  789.         if ($name) {
  790.             foreach ($types_aide as $k => $v) {
  791.                 $types_aide_label[$k] = $v['name'];
  792.             }
  793.             $types_aide = $types_aide_label;
  794.         }
  796.         if (!empty($type_aide)) {
  797.             if (isset($types_aide[$type_aide])) {
  798.                 return $types_aide[$type_aide];
  799.             } else {
  800.                 return null;
  801.             }
  802.         }
  804.         return $types_aide;
  806.     }
  808.     // }}}
  810.     // {{{ getAidesByYearContact()
  812.     /** Récupérer les derniers laureats
  813.      *
  814.      *
  815.      * @access public
  816.      * @return array
  817.      */
  818.     public function getAidesByYearContact($idcontact, $periode = 'current', $type_aide = 0, $params_display = array())
  819.     {
  821.         $types_object = array(
  822.             'text' => array('name' => 'Les textes'),
  823.             'spectacle' => array('name' => 'Les spectacles'),
  824.             'person' => array('name' => 'Les artistes'),
  825.         );
  827.         $aides['nb_laureats'] = 0;
  829.         $conn = $this->getEntityManager();
  831.         foreach ($types_object as $t => $v) {
  833.             // récupèrer les prix associés au contact
  834.             $object_aide = $conn->getRepository('TheatreCore\Entity\\' . ucfirst($t) . 'Aide');
  836.             // si current, trouver l'année de l'aide la plus proche
  837.             if ($periode == 'current') {
  838.                 $params_sql_year_aide = array(
  839.                     'special' => array(
  840.                         'aides' => array(
  841.                             'idcontacts' => $idcontact,
  842.                             'type_aides' => array($type_aide), // Prix
  843.                         ),
  844.                     ),
  845.                     'limit' => array(0, 1),
  846.                     'dbg' => array($t . '_year_aide', 'Année la plus proche de ' . $t . ' lauréats'),
  847.                 );
  848.                 $years = $object_aide->{'getList' . ucfirst($t) . 'Aide'}($params_sql_year_aide);
  849.                 foreach ($years as $year) {
  850.                     $periode = $year['year_start'];
  851.                     break;
  852.                 }
  853.             }
  855.             $params_sql_aide = array(
  856.                 'special' => array(
  857.                     'aides' => array(
  858.                         'idcontacts' => $idcontact,
  859.                         'type_aides' => array($type_aide), // Prix
  860.                     ),
  861.                 ),
  862.                 'dbg' => array($t . '_aide', 'Nombre de ' . $t . ' lauréats'),
  863.             );
  865.             // compter le nombre total de lauréats
  866.             $nb_list = $object_aide->{'countList' . ucfirst($t) . 'Aide'}($params_sql_aide);
  868.             // trouver les nominations de cette année
  869.             $params_sql_aide['special']['period']['year'] = $periode;
  870.             $aides[$t] = $object_aide->{'getList' . ucfirst($t) . 'Aide'}($params_sql_aide, $params_display);
  872.             $aides['year'] = $periode;
  873.             $aides['nb_laureats'] = count($aides[$t]) + $aides['nb_laureats'];
  875.         }
  878.         return $aides;
  880.     }
  882.     // }}}
  884.     // {{{ countTextAuthors()
  886.     /** Compter les auteurs ayant reçus une aide pour leurs texts
  887.      *
  888.      *
  889.      * @access public
  890.      * @return array
  891.      */
  892.     public function countTextAuthors($idaidecontact = null)
  893.     {
  895.         $sql = 'SELECT COUNT(DISTINCT(ta.`idperson`)) as total
  896.                 FROM text_aide tai JOIN aides ai
  897.                 ON ai.`idaide`=tai.`idaide`JOIN text_author ta
  898.                 ON ta.`idtext`=tai.`idtext`
  899.                 WHERE ai.`idaidecontact`=' . $idaidecontact;
  901.         $res = $this->queryOne($sql);
  903.         if ($res) {
  904.             return $res;
  905.         } else {
  906.             return 0;
  907.         }
  909.     }
  911.     // }}}
  913.     // {{{ countTexts()
  915.     /** Compter les texts qui ont reçus une aide
  916.      *
  917.      *
  918.      * @access public
  919.      * @return array
  920.      */
  921.     public function countTexts($idaidecontact = null)
  922.     {
  924.         $sql = 'SELECT COUNT(DISTINCT(tai.`idtext`))
  925.                 FROM text_aide tai JOIN aides ai
  926.                 ON ai.`idaide`=tai.`idaide`
  927.                 WHERE ai.`idaidecontact`=' . $idaidecontact;
  929.         $res = $this->queryOne($sql);
  931.         if ($res) {
  932.             return $res;
  933.         } else {
  934.             return 0;
  935.         }
  937.     }
  939.     // }}}
  941.     // {{{ getAuthorsTexts()
  943.     /** trouver les auteurs ayant reçus une aide pour leurs texts
  944.      *
  945.      *
  946.      * @access public
  947.      * @return array
  948.      */
  949.     public function getAuthorsTexts($idaidecontact = null)
  950.     {
  952.         $sql = 'SELECT p.`idperson`,p.`lastname`,p.`firstname`,p.`url_clean`, LEFT(p.`lastname`, 1) AS letter
  953.                 FROM text_aide tai
  954.                 JOIN aides ai ON ai.`idaide`=tai.`idaide`
  955.                 JOIN text_author ta ON ta.`idtext`=tai.`idtext`
  956.                 JOIN persons p ON ta.`idperson`=p.`idperson`
  957.                 WHERE ai.`idaidecontact`=' . $idaidecontact . '
  958.                 GROUP BY p.`idperson`';
  960.         $authors = $this->queryAll($sql);
  962.         if (!empty($authors)) {
  963.             return $authors;
  964.         } else {
  965.             return array();
  966.         }
  968.     }
  970.     // }}}
  972.     // {{{ countTextsSpectacles()
  974.     /** Compter les spectacles montés à partir d'un texte ayant bénéficié de l'aide à la création
  975.      *
  976.      *
  977.      * @access public
  978.      * @return array
  979.      */
  980.     public function countTextsSpectacles($idaidecontact = null)
  981.     {
  983.         $sql = 'SELECT COUNT(DISTINCT(ts.`idspectacle`))
  984.                 FROM text_spectacle ts
  985.                     JOIN text_aide tai  ON tai.`idtext`=ts.`idtext`
  986.                     JOIN aides ai ON ai.`idaide`=tai.`idaide`
  987.                 WHERE ai.`idaidecontact`=' . $idaidecontact;
  989.         try {
  990.             $res = $this->queryOne($sql);
  991.             return $res;
  992.         } catch (\Throwable $e) {
  993.             return 0;
  994.         }
  995.     }
  997.     // }}}
  998. }