Changeset 125435 in spip-zone


Ignore:
Timestamp:
Oct 6, 2020, 8:45:44 AM (3 weeks ago)
Author:
Matthieu Marcillaud
Message:

Permettre de trouver le parent dans une table de liens

  • Prise en compte d'une table de liens pour le calcul du parent.
  • Mise au point des fonctions de localisation du parent (aps les enfants)
  • Mettre au point la recherche des enfants en y incluant le cas des tables de liens.
Location:
_plugins_/declarerparent/branches/issue_3
Files:
1 edited
1 copied

Legend:

Unmodified
Added
Removed

  • _plugins_/declarerparent/branches/issue_3/base/objets_parents.php

    r125160 r125435  
    99
    1010/**
    11  * Cherche le contenu parent d'un contenu précis
    12  *
     11 * Cherche le contenu parent d'un contenu précis. Cette version permet de gérer un parent trouvé dans une table de lien
     12 * comme :
     13 * ```
     14 * $tables['spip_auteurs']['parent']  = array(
     15 *     'type' => 'organisation',
     16 *     'champ' => 'id_organisation',
     17 *     'table' => 'spip_organisations_liens',
     18 *     'table_condition' => 'role="parent"',
     19 *     'source_champ' => 'id_objet',
     20 *     'champ_type' => 'objet'
     21 * );
     22 * ```
     23 *
     24 *
    1325 * @api
    1426 * @param $objet
    … …  
    1830 * @return array|false
    1931 *      Retourne un tableau décrivant le parent trouvé, ou false sinon
    20  * 
     32 *
    2133 */
    2234function objet_trouver_parent($objet, $id_objet) {
    2335        $parent = false;
    24        
     36
    2537        // Si on trouve une ou des méthodes de parent
    2638        if ($parent_methodes = type_objet_info_parent($objet)) {
    2739
     40                // On identifie les informations sur l'objet source dont on cherche le parent.
    2841                include_spip('base/abstract_sql');
    29                 $table = table_objet_sql($objet);
     42                $table_objet = table_objet_sql($objet);
    3043                $cle_objet = id_table_objet($objet);
    3144                $id_objet = intval($id_objet);
    3245
    33 
    3446                // On teste chacun méthode dans l'ordre, et dès qu'on a trouvé un parent on s'arrête
    35                 foreach ($parent_methodes as $parent_methode) {
    36                         $where = array("$cle_objet = $id_objet");
    37 
    38                         // Détermination d'une condition sur la détection du parent
    39                         if (isset($parent_methode['condition'])) {
    40                                 $where[] = $parent_methode['condition'];
    41                         }
    42 
     47                foreach ($parent_methodes as $_parent_methode) {
     48                        // Champ identifiant le parent (id et éventuellement le type)
     49                        // -- cette identification ne dépend pas du fait que le parent soit stocké dans une table de différente
     50                        //    de celle de l'objet source
    4351                        $select = array();
    44                         if (isset($parent_methode['champ'])) {
    45                                 $select[] = $parent_methode['champ'];
    46                         }
    47                         if (isset($parent_methode['champ_type'])) {
    48                                 $select[] = $parent_methode['champ_type'];
    49                         }
    50 
    51                         // On lance la requête
    52                         if ($ligne = sql_fetsel($select, $table, $where)) {
    53                                
     52                        if (isset($_parent_methode['champ'])) {
     53                                $select[] = $_parent_methode['champ'];
     54                        }
     55                        if (isset($_parent_methode['champ_type'])) {
     56                                $select[] = $_parent_methode['champ_type'];
     57                        }
     58
     59                        // Détermination de la table du parent et des conditions sur l'objet source et le parent.
     60                        $condition_objet_invalide = false;
     61                        $where = array();
     62                        if (!isset($_parent_methode['table'])) {
     63                                // Le parent est stocké dans la même table que l'objet source :
     64                                // -- toutes les conditions s'appliquent à la table source.
     65                                $table = $table_objet;
     66                                $where = array("$cle_objet = $id_objet");
     67                                // -- Condition supplémentaire sur la détection du parent
     68                                if (isset($_parent_methode['condition'])) {
     69                                        $where[] = $_parent_methode['condition'];
     70                                }
     71                        } else {
     72                                // Le parent est stocké dans une table différente de l'objet source.
     73                                // -- on vérifie d'emblée si il y a une condition sur l'objet source et si celle-ci est vérifiée
     74                                //    Si non, on peut arrêter le traitement.
     75                                if (isset($_parent_methode['condition'])) {
     76                                        $where = array(
     77                                                "$cle_objet = $id_objet",
     78                                                $_parent_methode['condition']
     79                                        );
     80                                        if (!sql_countsel($table_objet, $where)) {
     81                                                $condition_objet_invalide = true;
     82                                        }
     83                                }
     84
     85                                // Si pas de condition sur l'objet source ou que la condition est vérifiée, on peut construire
     86                                // la requête sur la table qui accueille le parent.
     87                                if (!$condition_objet_invalide) {
     88                                        $table = $_parent_methode['table'];
     89                                        // On construit les conditions en fonction de l'identification de l'objet source
     90                                        $where = array();
     91                                        // -- si le champ_source de l'id n'est pas précisé c'est qu'il est déjà connu et donc que c'est
     92                                        //    le même que celui de l'objet source.
     93                                        $where[] = isset($_parent_methode['source_champ'])
     94                                                ? "{$_parent_methode['source_champ']} = $id_objet"
     95                                                : "${cle_objet} = $id_objet";
     96                                        if (isset($_parent_methode['source_champ_type'])) {
     97                                                $where[] = "{$_parent_methode['source_champ_type']} = " . sql_quote($objet);
     98                                        }
     99                                        // -- Condition supplémentaire sur la détection du parent
     100                                        if (isset($_parent_methode['table_condition'])) {
     101                                                $where[] = $_parent_methode['table_condition'];
     102                                        }
     103                                }
     104                        }
     105
     106                        // On lance la requête de récupération du parent
     107                        if (
     108                                !$condition_objet_invalide
     109                                and $where
     110                                and ($ligne = sql_fetsel($select, $table, $where))
     111                        ) {
    54112                                // Si le type est fixe
    55                                 if (isset($parent_methode['type'])) {
     113                                if (isset($_parent_methode['type'])) {
    56114                                        $parent = array(
    57                                                 'objet'         => $parent_methode['type'],
    58                                                 'id_objet'      => intval($ligne[$parent_methode['champ']]),
    59                                                 'champ'         => $parent_methode['champ'],
     115                                                'objet'         => $_parent_methode['type'],
     116                                                'id_objet'      => intval($ligne[$_parent_methode['champ']]),
     117                                                'champ'         => $_parent_methode['champ'],
    60118                                        );
    61119                                }
    62                                 elseif (isset($parent_methode['champ_type'])) {
     120                                elseif (isset($_parent_methode['champ_type'])) {
    63121                                        $parent = array(
    64                                                 'objet'          => $ligne[$parent_methode['champ_type']],
    65                                                 'id_objet'       => intval($ligne[$parent_methode['champ']]),
    66                                                 'champ'          => $parent_methode['champ'],
    67                                                 'champ_type' => $parent_methode['champ_type'],
     122                                                'objet'          => $ligne[$_parent_methode['champ_type']],
     123                                                'id_objet'       => intval($ligne[$_parent_methode['champ']]),
     124                                                'champ'          => $_parent_methode['champ'],
     125                                                'champ_type' => $_parent_methode['champ_type'],
    68126                                        );
    69127                                }
    70 
    71                                 if ($parent) {
    72                                         break;
    73                                 }
     128                                break;
    74129                        }
    75130                }
    76131        }
    77        
     132
    78133        // On passe par un pipeline avant de retourner
    79134        $parent = pipeline(
    … …  
    87142                )
    88143        );
    89        
     144
    90145        return $parent;
    91146}
    … …  
    112167               
    113168                // On parcourt tous les types d'enfants trouvés
    114                 foreach ($enfants_methodes as $objet_enfant => $methode) {
    115                         $table_enfant = table_objet_sql($objet_enfant);
    116                         $cle_objet_enfant = id_table_objet($objet_enfant);
    117                        
     169                foreach ($enfants_methodes as $objet_enfant => $_methode_parent) {
     170                        // On construit les conditions d'identification du parent
    118171                        $where = array();
    119                         // L'identifiant du parent
    120                         if (isset($methode['champ'])) {
    121                                 $where[] = $methode['champ'] . ' = ' . $id_objet;
    122                         }
    123                         // Si le parent est variable
    124                         if (isset($methode['champ_type'])) {
    125                                 $where[] = $methode['champ_type'] . ' = ' . sql_quote($objet);
    126                         }
    127                         // S'il y a une condition supplémentaire
    128                         if (isset($methode['condition'])) {
    129                                 $where[] = $methode['condition'];
    130                         }
    131                        
     172                        // -- L'identifiant du parent
     173                        if (isset($_methode_parent['champ'])) {
     174                                $where[] = $_methode_parent['champ'] . ' = ' . $id_objet;
     175                        }
     176                        // -- Si le parent est variable
     177                        if (isset($_methode_parent['champ_type'])) {
     178                                $where[] = $_methode_parent['champ_type'] . ' = ' . sql_quote($objet);
     179                        }
     180
     181                        // On détermine la table, le champ id des enfants et on complète éventuellement les conditions
     182                        if (!isset($_methode_parent['table'])) {
     183                                // Les enfants sont stockés dans la même table que l'objet parent :
     184                                $table_enfant = table_objet_sql($objet_enfant);
     185                                $cle_objet_enfant = id_table_objet($objet_enfant);
     186
     187                                // S'il y a une condition supplémentaire
     188                                if (isset($_methode_parent['condition'])) {
     189                                        $where[] = $_methode_parent['condition'];
     190                                }
     191                        } else {
     192                                // Les enfants sont stockés dans une table différente de l'objet parent.
     193                                $table_enfant = $_methode_parent['table'];
     194                                $cle_objet_enfant = isset($_methode_parent['source_champ'])
     195                                        ? $_methode_parent['source_champ']
     196                                        : id_table_objet($objet_enfant);
     197
     198                                // S'il y a une condition supplémentaire
     199                                if (isset($_methode_parent['table_condition'])) {
     200                                        $where[] = $_methode_parent['table_condition'];
     201                                }
     202                        }
     203
    132204                        // On lance la requête
    133205                        if ($ids = sql_allfetsel($cle_objet_enfant, $table_enfant, $where)) {
    134206                                $ids = array_map('reset', $ids);
    135                                 $enfants[$objet_enfant] = $ids;
     207                                $enfants[$objet_enfant] = isset($enfants[$objet_enfant])
     208                                        ? array_merge($enfants[$objet_enfant], $ids)
     209                                        : $ids;
    136210                        }
    137211                }
    … …  
    172246                // Si on trouve bien la description de cet objet
    173247                if ($infos = lister_tables_objets_sql($table)) {
    174                         // S'il y a une description explicite de parent, c'est prioritaire
    175248                        if (isset($infos['parent']) and is_array($infos['parent'])) {
    176                                 if (count($infos['parent']) === count($infos['parent'], COUNT_RECURSIVE)) {
     249                                // S'il y a une description explicite de parent, c'est prioritaire
     250                                // -- on traite les cas où il y a une ou plusieurs description mais on renvoie toujours un tableau
     251                                //    de description
     252                                if (!isset($infos['parent'][0])) {
    177253                                        $parents[$objet] = array($infos['parent']);
    178254                                } else {
    179255                                        $parents[$objet] = $infos['parent'];
    180256                                }
    181                         }
    182                         // Sinon on cherche des cas courants connus magiquement, à commencer par id_rubrique
    183                         elseif (isset($infos['field']['id_rubrique'])) {
     257                        } elseif (isset($infos['field']['id_rubrique'])) {
     258                                // Sinon on cherche des cas courants connus magiquement, à commencer par id_rubrique
    184259                                $parents[$objet] = array(array('type' => 'rubrique', 'champ' => 'id_rubrique'));
    185                         }
    186                         // Sinon on cherche un champ id_parent, ce qui signifie que l'objet est parent de lui-même
    187                         elseif (isset($infos['field']['id_parent'])) {
     260                        } elseif (isset($infos['field']['id_parent'])) {
     261                                // Sinon on cherche un champ id_parent, ce qui signifie que l'objet est parent de lui-même
    188262                                $parents[$objet] = array(array('type' => $objet, 'champ' => 'id_parent'));
    189263                        }
    190                         //~ // Sinon on cherche s'il y a objet et id_objet dans la table, ce qui signifie que le parent peut-être n'importe quel objet
    191                         //~ // comme c'est le cas pour les forums de premier niveau
    192                         //~ elseif (isset($infos['field']['objet']) and isset($infos['field']['id_objet'])) {
    193                                 //~ $parents[$objet] = array(array('champ_type' => 'objet', 'champ' => 'id_objet'));
    194                         //~ }
    195264                }
    196265        }
    … …  
    223292                        if ($parent_methodes = type_objet_info_parent($objet_enfant)) {
    224293                                // On parcourt les différents cas possible, si certains peuvent concerner l'objet demandé
    225                                 foreach ($parent_methodes as $parent_methode) {
     294                                foreach ($parent_methodes as $_parent_methode) {
    226295                                        // Si la méthode qu'on teste n'exclut pas le parent demandé
    227                                         if (!isset($parent_methode['exclus']) or !in_array($objet, $parent_methode['exclus'])) {
     296                                        if (!isset($_parent_methode['exclus']) or !in_array($objet, $_parent_methode['exclus'])) {
    228297                                                // Si le type du parent est fixe et directement l'objet demandé
    229                                                 if (isset($parent_methode['type']) and isset($parent_methode['champ']) and $parent_methode['type'] == $objet) {
    230                                                         $enfants[$objet][$objet_enfant] = $parent_methode;
     298                                                if (isset($_parent_methode['type']) and isset($_parent_methode['champ']) and $_parent_methode['type'] == $objet) {
     299                                                        $enfants[$objet][$objet_enfant] = $_parent_methode;
    231300                                                }
    232301                                                // Si le type est variable, alors l'objet demandé peut forcément être parent
    233                                                 elseif (isset($parent_methode['champ_type']) and isset($parent_methode['champ'])) {
    234                                                         $enfants[$objet][$objet_enfant] = $parent_methode;
     302                                                elseif (isset($_parent_methode['champ_type']) and isset($_parent_methode['champ'])) {
     303                                                        $enfants[$objet][$objet_enfant] = $_parent_methode;
    235304                                                }
    236305                                        }
Note: See TracChangeset for help on using the changeset viewer.