Changeset 114132 in spip-zone


Ignore:
Timestamp:
Feb 27, 2019, 8:59:50 AM (6 months ago)
Author:
peetdu@…
Message:

Mise en tête de gondole les fonctions servant d’API (marcimat)

File:
1 edited

Legend:

Unmodified
Added
Removed
  • _plugins_/declarerparent/trunk/base/objets_parents.php

    r110056 r114132  
    77// Cette API a vocation à migrer dans ce fichier à terme
    88include_spip('base/objets');
     9
     10/**
     11 * Cherche le contenu parent d'un contenu précis
     12 *
     13 * @api
     14 * @param $objet
     15 *              Type de l'objet dont on cherche le parent
     16 * @param $id_objet
     17 *              Identifiant de l'objet dont on cherche le parent
     18 * @return
     19 *      Retourne un tableau avec la clé "objet" et la clé "id_objet" décrivant le parent trouvé, ou false sinon
     20 *
     21 */
     22function objet_trouver_parent($objet, $id_objet) {
     23        $parent = false;
     24       
     25        // Si on trouve une ou des méthodes de parent
     26        if ($parent_methodes = type_objet_info_parent($objet)) {
     27                include_spip('base/abstract_sql');
     28                $table = table_objet_sql($objet);
     29                $cle_objet = id_table_objet($objet);
     30                $id_objet = intval($id_objet);
     31
     32                // Les méthode qui sont un simple tableau sont forcées en tableau de tableau,
     33                // pour pouvoir les parcourir comme les conditions
     34                if (count($parent_methodes) == count($parent_methodes, COUNT_RECURSIVE)) {
     35                        $parent_methodes = array($parent_methodes);
     36                }
     37                // On teste chacun méthode dans l'ordre, et dès qu'on a trouvé un parent on s'arrête
     38                foreach ($parent_methodes as $parent_methode) {
     39                        $where = array("$cle_objet = $id_objet");
     40                       
     41                        if (isset($parent_methode['condition'])) {
     42                                $where[] = $parent_methode['condition'];
     43                        }
     44                       
     45                        $select = array();
     46                        if (isset($parent_methode['champ'])) {
     47                                $select[] = $parent_methode['champ'];
     48                        }
     49                        if (isset($parent_methode['champ_type'])) {
     50                                $select[] = $parent_methode['champ_type'];
     51                        }
     52                       
     53                        // On lance la requête
     54                        if ($ligne = sql_fetsel($select, $table, $where)) {
     55                               
     56                                // Si le type est fixe
     57                                if (isset($parent_methode['type'])) {
     58                                        return array(
     59                                                'objet' => $parent_methode['type'],
     60                                                'id_objet' => intval($ligne[$parent_methode['champ']])
     61                                        );
     62                                }
     63                                elseif (isset($parent_methode['champ_type'])) {
     64                                        return array(
     65                                                'objet' => $ligne[$parent_methode['champ_type']],
     66                                                'id_objet' => intval($ligne[$parent_methode['champ']])
     67                                        );
     68                                }
     69                        }
     70                }
     71        }
     72       
     73        // On passe par un pipeline avant de retourner
     74        $parent = pipeline(
     75                'objet_trouver_parent',
     76                array(
     77                        'args' => array(
     78                                'objet' => $objet,
     79                                'id_objet' => $id_objet,
     80                        ),
     81                        'data' => $parent,
     82                )
     83        );
     84       
     85        return $parent;
     86}
     87
     88/**
     89 * Cherche tous les contenus enfants d'un contenu précis
     90 *
     91 * @api
     92 * @param $objet
     93 *              Type de l'objet dont on cherche les enfants
     94 * @param $id_objet
     95 *              Identifiant de l'objet dont on cherche les enfants
     96 * @return
     97 *      Retourne un tableau de tableaux, avec comme clés les types des objets, et dans chacun un tableau des identifiants trouvés
     98 *
     99 */
     100function objet_trouver_enfants($objet, $id_objet) {
     101        $enfants = array();
     102       
     103        // Si on trouve des types d'enfants et leurs méthodes
     104        if ($enfants_methodes = type_objet_info_enfants($objet)) {
     105                include_spip('base/abstract_sql');
     106                $id_objet = intval($id_objet);
     107               
     108                // On parcourt tous les types d'enfants trouvés
     109                foreach ($enfants_methodes as $objet_enfant => $methode) {
     110                        $table_enfant = table_objet_sql($objet_enfant);
     111                        $cle_objet_enfant = id_table_objet($objet_enfant);
     112                       
     113                        $where = array();
     114                        // L'identifiant du parent
     115                        if (isset($methode['champ'])) {
     116                                $where[] = $methode['champ'] . ' = ' . $id_objet;
     117                        }
     118                        // Si le parent est variable
     119                        if (isset($methode['champ_type'])) {
     120                                $where[] = $methode['champ_type'] . ' = ' . sql_quote($objet);
     121                        }
     122                        // S'il y a une condition supplémentaire
     123                        if (isset($methode['condition'])) {
     124                                $where[] = $methode['condition'];
     125                        }
     126                       
     127                        // On lance la requête
     128                        if ($ids = sql_allfetsel($cle_objet_enfant, $table_enfant, $where)) {
     129                                $ids = array_map('reset', $ids);
     130                                $enfants[$objet_enfant] = $ids;
     131                        }
     132                }
     133        }
     134       
     135        // On passe par un pipeline avant de retourner
     136        $enfants = pipeline(
     137                'objet_trouver_enfants',
     138                array(
     139                        'args' => array(
     140                                'objet' => $objet,
     141                                'id_objet' => $id_objet,
     142                        ),
     143                        'data' => $enfants,
     144                )
     145        );
     146       
     147        return $enfants;
     148}
    9149
    10150/**
     
    99239        return $enfants[$objet];
    100240}
    101 
    102 /**
    103  * Cherche le contenu parent d'un contenu précis
    104  *
    105  * @param $objet
    106  *              Type de l'objet dont on cherche le parent
    107  * @param $id_objet
    108  *              Identifiant de l'objet dont on cherche le parent
    109  * @return
    110  *      Retourne un tableau avec la clé "objet" et la clé "id_objet" décrivant le parent trouvé, ou false sinon
    111  *
    112  */
    113 function objet_trouver_parent($objet, $id_objet) {
    114         $parent = false;
    115        
    116         // Si on trouve une ou des méthodes de parent
    117         if ($parent_methodes = type_objet_info_parent($objet)) {
    118                 include_spip('base/abstract_sql');
    119                 $table = table_objet_sql($objet);
    120                 $cle_objet = id_table_objet($objet);
    121                 $id_objet = intval($id_objet);
    122 
    123                 // Les méthode qui sont un simple tableau sont forcées en tableau de tableau,
    124                 // pour pouvoir les parcourir comme les conditions
    125                 if (count($parent_methodes) == count($parent_methodes, COUNT_RECURSIVE)) {
    126                         $parent_methodes = array($parent_methodes);
    127                 }
    128                 // On teste chacun méthode dans l'ordre, et dès qu'on a trouvé un parent on s'arrête
    129                 foreach ($parent_methodes as $parent_methode) {
    130                         $where = array("$cle_objet = $id_objet");
    131                        
    132                         if (isset($parent_methode['condition'])) {
    133                                 $where[] = $parent_methode['condition'];
    134                         }
    135                        
    136                         $select = array();
    137                         if (isset($parent_methode['champ'])) {
    138                                 $select[] = $parent_methode['champ'];
    139                         }
    140                         if (isset($parent_methode['champ_type'])) {
    141                                 $select[] = $parent_methode['champ_type'];
    142                         }
    143                        
    144                         // On lance la requête
    145                         if ($ligne = sql_fetsel($select, $table, $where)) {
    146                                
    147                                 // Si le type est fixe
    148                                 if (isset($parent_methode['type'])) {
    149                                         return array(
    150                                                 'objet' => $parent_methode['type'],
    151                                                 'id_objet' => intval($ligne[$parent_methode['champ']])
    152                                         );
    153                                 }
    154                                 elseif (isset($parent_methode['champ_type'])) {
    155                                         return array(
    156                                                 'objet' => $ligne[$parent_methode['champ_type']],
    157                                                 'id_objet' => intval($ligne[$parent_methode['champ']])
    158                                         );
    159                                 }
    160                         }
    161                 }
    162         }
    163        
    164         // On passe par un pipeline avant de retourner
    165         $parent = pipeline(
    166                 'objet_trouver_parent',
    167                 array(
    168                         'args' => array(
    169                                 'objet' => $objet,
    170                                 'id_objet' => $id_objet,
    171                         ),
    172                         'data' => $parent,
    173                 )
    174         );
    175        
    176         return $parent;
    177 }
    178 
    179 /**
    180  * Cherche tous les contenus enfants d'un contenu précis
    181  *
    182  * @param $objet
    183  *              Type de l'objet dont on cherche les enfants
    184  * @param $id_objet
    185  *              Identifiant de l'objet dont on cherche les enfants
    186  * @return
    187  *      Retourne un tableau de tableaux, avec comme clés les types des objets, et dans chacun un tableau des identifiants trouvés
    188  *
    189  */
    190 function objet_trouver_enfants($objet, $id_objet) {
    191         $enfants = array();
    192        
    193         // Si on trouve des types d'enfants et leurs méthodes
    194         if ($enfants_methodes = type_objet_info_enfants($objet)) {
    195                 include_spip('base/abstract_sql');
    196                 $id_objet = intval($id_objet);
    197                
    198                 // On parcourt tous les types d'enfants trouvés
    199                 foreach ($enfants_methodes as $objet_enfant => $methode) {
    200                         $table_enfant = table_objet_sql($objet_enfant);
    201                         $cle_objet_enfant = id_table_objet($objet_enfant);
    202                        
    203                         $where = array();
    204                         // L'identifiant du parent
    205                         if (isset($methode['champ'])) {
    206                                 $where[] = $methode['champ'] . ' = ' . $id_objet;
    207                         }
    208                         // Si le parent est variable
    209                         if (isset($methode['champ_type'])) {
    210                                 $where[] = $methode['champ_type'] . ' = ' . sql_quote($objet);
    211                         }
    212                         // S'il y a une condition supplémentaire
    213                         if (isset($methode['condition'])) {
    214                                 $where[] = $methode['condition'];
    215                         }
    216                        
    217                         // On lance la requête
    218                         if ($ids = sql_allfetsel($cle_objet_enfant, $table_enfant, $where)) {
    219                                 $ids = array_map('reset', $ids);
    220                                 $enfants[$objet_enfant] = $ids;
    221                         }
    222                 }
    223         }
    224        
    225         // On passe par un pipeline avant de retourner
    226         $enfants = pipeline(
    227                 'objet_trouver_enfants',
    228                 array(
    229                         'args' => array(
    230                                 'objet' => $objet,
    231                                 'id_objet' => $id_objet,
    232                         ),
    233                         'data' => $enfants,
    234                 )
    235         );
    236        
    237         return $enfants;
    238 }
Note: See TracChangeset for help on using the changeset viewer.