Changeset 66150 in spip-zone for _plugins_/compositions


Ignore:
Timestamp:
Sep 22, 2012, 6:20:32 PM (7 years ago)
Author:
joseph@…
Message:

Reprise des fonctions d'héritage, pas encore assez génériques. Le formulaire d'édition prend bien en compte les héritages.

ATTENTION : les héritages doivent maintenant être explicitement déclarés via le pileline dédié.

Reste la question du verrouillage par branche qui pour le moment reste limité aux rubriques.

Location:
_plugins_/compositions/trunk
Files:
4 edited

Legend:

Unmodified
Added
Removed
  • _plugins_/compositions/trunk/compositions_fonctions.php

    r61988 r66150  
    224224/**
    225225 * Renvoie les parametres necessaires pour utiliser l'heritage de composition de façon generique
    226  * pour les objets n'utilisant pas les rubriques comme source d'heritage
    227  * recupere les donnes du pipeline compositions_declarer_heritage
     226 * recupere les donnes du pipeline compositions_declarer_heritage.
     227 * Si $type n'est pas precise, on renvoie simplement le tableau des objets pouvant heriter.
    228228 *
    229229 * @param string $type
     230 * @staticvar array $heritages
    230231 * @return array
    231232 */
    232 function compositions_recuperer_heritage($type){
    233         // recuperer les heritages declares via le pipeline compositions_declarer_heritage
    234         $Theritages = array();
    235         $Theritages = pipeline('compositions_declarer_heritage', $Theritages);
    236 
    237         if (array_key_exists($type, $Theritages)) {
    238                 $type_parent = $Theritages[$type];
    239                 // KISS: heritage a un seul niveau (pas de recursivite comme avec les rubriques)
    240                 $ancetres = false;
    241                 $nom_id_ancetre = null;
    242                 $arr_sql = array('composition');
    243         }
    244         else {
    245                 $type_parent = 'rubrique';
    246                 $nom_id_ancetre = 'id_parent';
    247                 $ancetres = true;
    248                 $arr_sql = array($nom_id_ancetre,'composition');
    249         }
    250         $table_parents =  table_objet_sql($type_parent);
    251         $nom_id_parent = id_table_objet($type_parent);
    252 
    253         // verifier que table et champs existent...
    254         $trouver_table = charger_fonction('trouver_table', 'base');
    255         if (!$type_parent OR $type_parent == ''
    256                 OR !$desc = $trouver_table($table_parents,$serveur)
    257                 OR !isset($desc['field']['composition'])
    258                 OR !isset($desc['field'][$nom_id_parent]))
    259                 return '';
    260 
    261         return array(
    262                 'type_parent'           => $type_parent,
    263                 'table_parents'         => $table_parents,
    264                 'nom_id_parent'         => $nom_id_parent,
    265                 'ancetres'                      => $ancetres,
    266                 'nom_id_ancetre'        => $nom_id_ancetre,
    267                 'arr_sql'                       => $arr_sql
    268         );
     233function compositions_recuperer_heritage($type=NULL){
     234        static $heritages = NULL;
     235        if (is_null($heritages)) // recuperer les heritages declares via le pipeline compositions_declarer_heritage
     236                $heritages = pipeline('compositions_declarer_heritage', array());
     237       
     238        if (is_null($type))
     239                return $heritages;
     240
     241        if (array_key_exists($type, $heritages)) {
     242                $type_parent = $heritages[$type];
     243                $table_parent =  table_objet_sql($type_parent);
     244                $nom_id_parent = ($type==$type_parent) ? 'id_parent' : id_table_objet($type_parent); // Recursivite pour les rubriques, nom de l'identifiant du parent dans la table enfant
     245                $nom_id_table_parent = id_table_objet($type_parent); // Nom de l'identifiant du parent dans la table parent
     246               
     247                // verifier que table et champs existent...
     248                $trouver_table = charger_fonction('trouver_table', 'base');
     249                if (!$type_parent
     250                        OR !$desc = $trouver_table($table_parent,$serveur)
     251                        OR !isset($desc['field']['composition'])
     252                        OR !isset($desc['field'][$nom_id_parent]))
     253                        return '';
     254
     255                return array(
     256                        'type_parent' => $type_parent,
     257                        'table_parent' => $table_parent,
     258                        'nom_id_parent' => $nom_id_parent,
     259                        'nom_id_table_parent' => $nom_id_table_parent
     260                );
     261        }
     262        return array();
    269263}
    270264
     
    272266 * Renvoie la composition qui s'applique a un objet
    273267 * en tenant compte, le cas echeant, de la composition heritee
    274  * si etoile=true on renvoi dire le champ sql
     268 * si etoile=true on renvoi directment le champ sql
    275269 *
    276270 * @param string $type
     
    282276function compositions_determiner($type, $id, $serveur='', $etoile = false){
    283277        static $composition = array();
    284 
     278        $id = intval($id);
     279       
    285280        if (isset($composition[$etoile][$serveur][$type][$id]))
    286281                return $composition[$etoile][$serveur][$type][$id];
     
    298293                $select = "composition";
    299294
    300         $Tparam_heritage = compositions_recuperer_heritage($type);
    301         if (isset($desc['field'][$Tparam_heritage['nom_id_parent']]))
    302                 $select .= "," . (($type == 'rubrique') ? 'id_parent' : $Tparam_heritage['nom_id_parent'].' as id_parent');
    303 
    304                 $row = sql_fetsel($select, $table_sql, "$_id_table=".intval($id), '', '', '', '', $serveur);
    305                 if ($row['composition'] != '')
    306                         $retour = $row['composition'];
    307                 elseif (!$etoile
    308                   AND isset($row['id_parent'])
    309                   AND $row['id_parent'])
    310                         $retour = compositions_heriter($type, $row['id_parent'], $serveur);
     295        $heritage = compositions_recuperer_heritage($type);
     296        if (isset($desc['field'][$heritage['nom_id_parent']]))
     297                $select .= ', '.$heritage['nom_id_parent'].' as id_parent';
     298
     299        $row = sql_fetsel($select, $table_sql, "$_id_table=".intval($id), '', '', '', '', $serveur);
     300        if ($row['composition'] != '')
     301                $retour = $row['composition'];
     302        elseif (!$etoile
     303          AND isset($row['id_parent'])
     304          AND $row['id_parent'])
     305                $retour = compositions_heriter($type, $id, $row['id_parent'], $serveur);
    311306        }
    312307        return $composition[$etoile][$serveur][$type][$id] = (($retour == '-') ? '' : $retour);
     
    314309
    315310/**
    316  * Renvoie la composition heritee par un objet selon sa rubrique
    317  * ou son groupe de mot-cles
    318  *
    319  * @param string $type
    320  * @param integer $id_rubrique
     311 * Renvoie la composition heritee par un objet selon son identifiant.
     312 * Optionnellement, on peut lui transmettre directement l'id du parent s'il a ate calcule.
     313 *
     314 * @param string $type
     315 * @param integer $id
     316 * @param integer $id_parent
    321317 * @param string $serveur
    322318 * @return string
    323319 */
    324 function compositions_heriter($type, $id_rubrique, $serveur=''){
     320function compositions_heriter($type, $id, $id_parent=NULL, $serveur=''){
    325321        if ($type=='syndic') $type='site'; //grml
    326         if (intval($id_rubrique) < 1) return '';
     322        if (intval($id) < 1) return '';
    327323        static $infos = null;
    328         $id_parent = $id_rubrique;
    329         $compo_rubrique = '';
    330 
    331         $Theritage = compositions_recuperer_heritage($type);
    332         $type_parent = $Theritage['type_parent'];               //'rubrique';
    333         $table_parents = $Theritage['table_parents'];   //'spip_rubriques';
    334         $nom_id_parent = $Theritage['nom_id_parent'];   //'id_rubrique';
    335         $ancetres = $Theritage['ancetres'];                             //true;
    336         $nom_id_ancetre = $Theritage['nom_id_ancetre']; //'id_parent';
    337         $arr_sql = $Theritage['arr_sql'];                               // array($nom_id_ancetre,'composition');
    338 
     324        $compo_parent = '';
     325       
     326        $heritage = compositions_recuperer_heritage($type);
     327        $type_parent = $heritage['type_parent'];
     328        $table_parent = $heritage['table_parent'];
     329        $nom_id_parent = $heritage['nom_id_parent'];
     330        $nom_id_table_parent = $heritage['nom_id_table_parent'];
     331       
     332        if (is_null($id_parent))
     333                $id_parent = sql_getfetsel($nom_id_parent, table_objet_sql($type), id_table_objet($type).'='.intval($id));
     334       
     335        $heritages = compositions_recuperer_heritage();
     336       
    339337        do {
    340                 $row = sql_fetsel($arr_sql, $table_parents, $nom_id_parent.'='.intval($id_parent),'','','','',$serveur);
     338                $select = 'composition';
     339                if ($heritages[$type_parent]==$type_parent) // S'il y a recursivite sur le parent
     340                        $select .= ', id_parent';
     341                $row = sql_fetsel($select, $table_parent, $nom_id_table_parent.'='.intval($id_parent),'','','','',$serveur);
    341342                if (strlen($row['composition']) AND $row['composition']!='-')
    342                         $compo_rubrique = $row['composition'];
    343                 elseif (strlen($row['composition'])==0 AND $ancetres) // il faut aussi verifier que la rub parente n'herite pas elle-meme d'une composition
    344                         $compo_rubrique = compositions_determiner($type_parent, $id_parent, $serveur='');
     343                        $compo_parent = $row['composition'];
     344                elseif (strlen($row['composition'])==0 AND isset($heritages[$type_parent])) // Si le parent peut heriter, il faut verifier s'il y a heritage
     345                        $compo_parent = compositions_determiner($type_parent, $id_parent, $serveur='');
    345346               
    346                 if (strlen($compo_rubrique) AND is_null($infos))
    347                         $infos = compositions_lister_disponibles($type_parent);
    348         }
    349         while ($id_parent = $row[$nom_id_ancetre] // Attention : nom_id_ancetre peut differer de nom_id_parent, pour les articles par exemple
     347                if (strlen($compo_parent) AND is_null($infos))
     348                        $infos = compositions_lister_disponibles('');
     349                       
     350        }
     351        while ($id_parent = $row['id_parent']
    350352                AND
    351                 (!strlen($compo_rubrique) OR !isset($infos[$type_parent][$compo_rubrique]['branche'][$type])));
    352 
    353         if (strlen($compo_rubrique) AND isset($infos[$type_parent][$compo_rubrique]['branche'][$type]))
    354                 return $infos[$type_parent][$compo_rubrique]['branche'][$type];
     353                (!strlen($compo_parent) OR !isset($infos[$type_parent][$compo_parent]['branche'][$type])));
     354
     355        if (strlen($compo_parent) AND isset($infos[$type_parent][$compo_parent]['branche'][$type]))
     356                return $infos[$type_parent][$compo_parent]['branche'][$type];
    355357
    356358        return '';
  • _plugins_/compositions/trunk/compositions_pipeline.php

    r60177 r66150  
    123123
    124124/**
    125  * utilisation du pipeline compositions_declarer_heritage:
    126  * exemple pour faire heriter l'objet machin des compostions definies dans son parent truc:
    127  *              $flux['machin'] = 'truc';
    128  * ce qui permet ensuite de faire dans le fichier truc-ma_compo.xml
    129  * <branche type="machin" composition="une_compo" />
     125 * Le pipeline compositions_declarer_heritage permet de declarer les heritages
     126 * sous la forme :
     127 *              $heritages['objet'] = 'parent';
     128 * ce qui permet ensuite de faire dans le fichier parent-ma_compo.xml
     129 * <branche type="objet" composition="une_compo" />
    130130 *
    131  * ajouter l'heritage pour les mots-cles (mieux ici que dans le plugin mots?)
    132  *
     131 * A partir de compositions 3.3.0 cette declaration est obligatoire.
     132 * Les objets "standards" de SPIP sont declares ici. (a deplacer dans leurs plugins respectifs ?)
    133133 */
    134 function compositions_compositions_declarer_heritage($arr){
    135         $arr['mot'] = 'groupe_mots';
    136        
    137         return $arr;
     134function compositions_compositions_declarer_heritage($heritages){
     135        $heritages['mot'] = 'groupe_mots';
     136        $heritages['rubrique'] = 'rubrique';
     137        $heritages['article'] = 'rubrique';
     138        $heritages['breve'] = 'rubrique';
     139        $heritages['site'] = 'rubrique';
     140        return $heritages;
    138141}
    139142
  • _plugins_/compositions/trunk/formulaires/editer_composition_objet.php

    r57712 r66150  
    3434        if ($type=='rubrique')
    3535                $valeurs['composition_branche_lock'] = sql_getfetsel('composition_branche_lock',$table_objet_sql,"$id_table_objet=".intval($id));
    36 
    37         $trouver_table = charger_fonction('trouver_table', 'base');
    38         $desc = $trouver_table($table_objet_sql);
    39         if (isset($desc['field']['id_rubrique'])) {
    40                 $_id_rubrique = ($type == 'rubrique') ? 'id_parent' : 'id_rubrique';
    41                 $id_rubrique = sql_getfetsel($_id_rubrique,$table_objet_sql,"$id_table_objet=".intval($id),'','','','',$serveur);
    42                 $valeurs['composition_heritee'] = compositions_heriter($type, $id_rubrique);
    43                 $valeurs['verrou_branche'] = compositions_verrou_branche($id_rubrique);
    44         } else {
    45                 $valeurs['composition_heritee'] = '';
    46                 $valeurs['verrou_branche'] = false;
    47         }
     36       
     37        $valeurs['composition_heritee'] = compositions_heriter($type, $id);
     38        $valeurs['verrou_branche'] = compositions_verrou_branche($type, $id);
     39        $valeurs['verrou_branche'] = false;
    4840        $valeurs['composition_verrouillee'] = compositions_verrouiller($type, $id);
    4941
  • _plugins_/compositions/trunk/paquet.xml

    r66147 r66150  
    22        prefix="compositions"
    33        categorie="outil"
    4         version="3.2"
     4        version="3.3.0"
    55        etat="test"
    66        compatibilite="[3.0.0-dev;3.0.*]"
Note: See TracChangeset for help on using the changeset viewer.