Dépôt officiel du core SPIP * Anciennement présent sur svn://trac.rezo.net/spip * Les plugins-dist faisant partie de la distribution SPIP sont présents dans https://git.spip.net/SPIP/[nom du plugin dist] https://www.spip.net
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

513 lines
16 KiB

Intégration dans SPIP de la possibilité de gérer des liens entre objets avec des rôles. On intègre l'API présente actuellement dans le plugin Rôles, en modifiant un peu les fonctions d'édition de liens. Celles-ci permettent maintenant d'éditer des liens ayant donc des rôles. Ces différents rôles et le nom de la colonne SQL qui les reçoit, s'ils sont utilisés, doivent être déclarés avec la déclaration de l'objet éditorial correspondant. Un exemple est donné avec le plugin «Roles auteurs» qui définit quelques rôles. Les champs décrivant les rôles : `roles_colonne`, `roles_titres` et `roles_objets` doivent être déclarés (via le pipeline declarer_tables_objets_sql). ``` "roles_colonne" => "role", "roles_titres" => array( 'redacteur' => 'info_statut_redacteur', 'traducteur' => 'roles_auteurs:traducteur', 'correcteur' => 'roles_auteurs:correcteur', 'relecteur' => 'roles_auteurs:relecteur', ), "roles_objets" => array( 'articles' => array( 'choix' => array('redacteur', 'traducteur', 'correcteur', 'relecteur'), 'defaut' => 'redacteur' ) #'*' => array() ) ``` Une fois déclaré, on peut appeler les fonctions d'édition de lien en transmettant des valeurs de rôles, tel que : ``` objet_associer( array('auteur' => 3), array('article' => 11), array('role' => 'correcteur') ); // utilisera le rôle par défaut objet_associer( array('auteur' => 3), array('article' => 11) ); ``` Si aucun rôle n'est indiqué, le rôle par défaut est appliqué. Dans le cas d'une dissociation également, si aucun rôle n'est indiqué, seuls les liaisons avec le rôle par défaut seront supprimés ; pour supprimer tous les rôles, il faut à ce moment là indiquer '*' : ``` objet_dissocier( array('auteur' => 3), array('article' => 11), array('role' => 'correcteur') ); // utilisera le rôle par défaut objet_dissocier( array('auteur' => 3), array('article' => 11) ); // enlèvera tous les rôles objet_dissocier( array('auteur' => 3), array('article' => 11), array('role' => '*') ); ``` Le formulaire d'édition de liens n'utilisera pas les mêmes squelettes de liaison lorsqu'une colonne de rôle est déclarée. Ainsi dans cet exemple, au lieu de `prive/objets/liste/auteurs_lies.html` et `auteurs_associer.html`, cela utiliserait `prive/objets/liste/auteurs_roles_lies.html` et `auteurs_roles_associer.html`. Il faut donc créer ces squelettes. Ces squelettes peuvent poster les valeurs au formulaire pour insérer de nouveaux liens, de la forme `qualifier_lien[auteur-3-article-11][role]` en postant `redacteur` par exemple. Il est possible au passage de poster en plus d'autres valeurs, qui seront intégrées dans l'enregistrement du lien. Ainsi, poster en même temps `qualifier_lien[auteur-3-article-11][valeur]` = `50` enregistrera la valeur 50 dans la colonne `valeur` de la table de lien (qui doit exister !). D'autres informations sont présentes dans http://contrib.spip.net/Des-roles-sur-des-liens, http://zone.spip.org/trac/spip-zone/browser/_plugins_/roles_auteurs ou encore http://zone.spip.org/trac/spip-zone/browser/_plugins_/roles
7 years ago
Intégration dans SPIP de la possibilité de gérer des liens entre objets avec des rôles. On intègre l'API présente actuellement dans le plugin Rôles, en modifiant un peu les fonctions d'édition de liens. Celles-ci permettent maintenant d'éditer des liens ayant donc des rôles. Ces différents rôles et le nom de la colonne SQL qui les reçoit, s'ils sont utilisés, doivent être déclarés avec la déclaration de l'objet éditorial correspondant. Un exemple est donné avec le plugin «Roles auteurs» qui définit quelques rôles. Les champs décrivant les rôles : `roles_colonne`, `roles_titres` et `roles_objets` doivent être déclarés (via le pipeline declarer_tables_objets_sql). ``` "roles_colonne" => "role", "roles_titres" => array( 'redacteur' => 'info_statut_redacteur', 'traducteur' => 'roles_auteurs:traducteur', 'correcteur' => 'roles_auteurs:correcteur', 'relecteur' => 'roles_auteurs:relecteur', ), "roles_objets" => array( 'articles' => array( 'choix' => array('redacteur', 'traducteur', 'correcteur', 'relecteur'), 'defaut' => 'redacteur' ) #'*' => array() ) ``` Une fois déclaré, on peut appeler les fonctions d'édition de lien en transmettant des valeurs de rôles, tel que : ``` objet_associer( array('auteur' => 3), array('article' => 11), array('role' => 'correcteur') ); // utilisera le rôle par défaut objet_associer( array('auteur' => 3), array('article' => 11) ); ``` Si aucun rôle n'est indiqué, le rôle par défaut est appliqué. Dans le cas d'une dissociation également, si aucun rôle n'est indiqué, seuls les liaisons avec le rôle par défaut seront supprimés ; pour supprimer tous les rôles, il faut à ce moment là indiquer '*' : ``` objet_dissocier( array('auteur' => 3), array('article' => 11), array('role' => 'correcteur') ); // utilisera le rôle par défaut objet_dissocier( array('auteur' => 3), array('article' => 11) ); // enlèvera tous les rôles objet_dissocier( array('auteur' => 3), array('article' => 11), array('role' => '*') ); ``` Le formulaire d'édition de liens n'utilisera pas les mêmes squelettes de liaison lorsqu'une colonne de rôle est déclarée. Ainsi dans cet exemple, au lieu de `prive/objets/liste/auteurs_lies.html` et `auteurs_associer.html`, cela utiliserait `prive/objets/liste/auteurs_roles_lies.html` et `auteurs_roles_associer.html`. Il faut donc créer ces squelettes. Ces squelettes peuvent poster les valeurs au formulaire pour insérer de nouveaux liens, de la forme `qualifier_lien[auteur-3-article-11][role]` en postant `redacteur` par exemple. Il est possible au passage de poster en plus d'autres valeurs, qui seront intégrées dans l'enregistrement du lien. Ainsi, poster en même temps `qualifier_lien[auteur-3-article-11][valeur]` = `50` enregistrera la valeur 50 dans la colonne `valeur` de la table de lien (qui doit exister !). D'autres informations sont présentes dans http://contrib.spip.net/Des-roles-sur-des-liens, http://zone.spip.org/trac/spip-zone/browser/_plugins_/roles_auteurs ou encore http://zone.spip.org/trac/spip-zone/browser/_plugins_/roles
7 years ago
Intégration dans SPIP de la possibilité de gérer des liens entre objets avec des rôles. On intègre l'API présente actuellement dans le plugin Rôles, en modifiant un peu les fonctions d'édition de liens. Celles-ci permettent maintenant d'éditer des liens ayant donc des rôles. Ces différents rôles et le nom de la colonne SQL qui les reçoit, s'ils sont utilisés, doivent être déclarés avec la déclaration de l'objet éditorial correspondant. Un exemple est donné avec le plugin «Roles auteurs» qui définit quelques rôles. Les champs décrivant les rôles : `roles_colonne`, `roles_titres` et `roles_objets` doivent être déclarés (via le pipeline declarer_tables_objets_sql). ``` "roles_colonne" => "role", "roles_titres" => array( 'redacteur' => 'info_statut_redacteur', 'traducteur' => 'roles_auteurs:traducteur', 'correcteur' => 'roles_auteurs:correcteur', 'relecteur' => 'roles_auteurs:relecteur', ), "roles_objets" => array( 'articles' => array( 'choix' => array('redacteur', 'traducteur', 'correcteur', 'relecteur'), 'defaut' => 'redacteur' ) #'*' => array() ) ``` Une fois déclaré, on peut appeler les fonctions d'édition de lien en transmettant des valeurs de rôles, tel que : ``` objet_associer( array('auteur' => 3), array('article' => 11), array('role' => 'correcteur') ); // utilisera le rôle par défaut objet_associer( array('auteur' => 3), array('article' => 11) ); ``` Si aucun rôle n'est indiqué, le rôle par défaut est appliqué. Dans le cas d'une dissociation également, si aucun rôle n'est indiqué, seuls les liaisons avec le rôle par défaut seront supprimés ; pour supprimer tous les rôles, il faut à ce moment là indiquer '*' : ``` objet_dissocier( array('auteur' => 3), array('article' => 11), array('role' => 'correcteur') ); // utilisera le rôle par défaut objet_dissocier( array('auteur' => 3), array('article' => 11) ); // enlèvera tous les rôles objet_dissocier( array('auteur' => 3), array('article' => 11), array('role' => '*') ); ``` Le formulaire d'édition de liens n'utilisera pas les mêmes squelettes de liaison lorsqu'une colonne de rôle est déclarée. Ainsi dans cet exemple, au lieu de `prive/objets/liste/auteurs_lies.html` et `auteurs_associer.html`, cela utiliserait `prive/objets/liste/auteurs_roles_lies.html` et `auteurs_roles_associer.html`. Il faut donc créer ces squelettes. Ces squelettes peuvent poster les valeurs au formulaire pour insérer de nouveaux liens, de la forme `qualifier_lien[auteur-3-article-11][role]` en postant `redacteur` par exemple. Il est possible au passage de poster en plus d'autres valeurs, qui seront intégrées dans l'enregistrement du lien. Ainsi, poster en même temps `qualifier_lien[auteur-3-article-11][valeur]` = `50` enregistrera la valeur 50 dans la colonne `valeur` de la table de lien (qui doit exister !). D'autres informations sont présentes dans http://contrib.spip.net/Des-roles-sur-des-liens, http://zone.spip.org/trac/spip-zone/browser/_plugins_/roles_auteurs ou encore http://zone.spip.org/trac/spip-zone/browser/_plugins_/roles
7 years ago
Intégration dans SPIP de la possibilité de gérer des liens entre objets avec des rôles. On intègre l'API présente actuellement dans le plugin Rôles, en modifiant un peu les fonctions d'édition de liens. Celles-ci permettent maintenant d'éditer des liens ayant donc des rôles. Ces différents rôles et le nom de la colonne SQL qui les reçoit, s'ils sont utilisés, doivent être déclarés avec la déclaration de l'objet éditorial correspondant. Un exemple est donné avec le plugin «Roles auteurs» qui définit quelques rôles. Les champs décrivant les rôles : `roles_colonne`, `roles_titres` et `roles_objets` doivent être déclarés (via le pipeline declarer_tables_objets_sql). ``` "roles_colonne" => "role", "roles_titres" => array( 'redacteur' => 'info_statut_redacteur', 'traducteur' => 'roles_auteurs:traducteur', 'correcteur' => 'roles_auteurs:correcteur', 'relecteur' => 'roles_auteurs:relecteur', ), "roles_objets" => array( 'articles' => array( 'choix' => array('redacteur', 'traducteur', 'correcteur', 'relecteur'), 'defaut' => 'redacteur' ) #'*' => array() ) ``` Une fois déclaré, on peut appeler les fonctions d'édition de lien en transmettant des valeurs de rôles, tel que : ``` objet_associer( array('auteur' => 3), array('article' => 11), array('role' => 'correcteur') ); // utilisera le rôle par défaut objet_associer( array('auteur' => 3), array('article' => 11) ); ``` Si aucun rôle n'est indiqué, le rôle par défaut est appliqué. Dans le cas d'une dissociation également, si aucun rôle n'est indiqué, seuls les liaisons avec le rôle par défaut seront supprimés ; pour supprimer tous les rôles, il faut à ce moment là indiquer '*' : ``` objet_dissocier( array('auteur' => 3), array('article' => 11), array('role' => 'correcteur') ); // utilisera le rôle par défaut objet_dissocier( array('auteur' => 3), array('article' => 11) ); // enlèvera tous les rôles objet_dissocier( array('auteur' => 3), array('article' => 11), array('role' => '*') ); ``` Le formulaire d'édition de liens n'utilisera pas les mêmes squelettes de liaison lorsqu'une colonne de rôle est déclarée. Ainsi dans cet exemple, au lieu de `prive/objets/liste/auteurs_lies.html` et `auteurs_associer.html`, cela utiliserait `prive/objets/liste/auteurs_roles_lies.html` et `auteurs_roles_associer.html`. Il faut donc créer ces squelettes. Ces squelettes peuvent poster les valeurs au formulaire pour insérer de nouveaux liens, de la forme `qualifier_lien[auteur-3-article-11][role]` en postant `redacteur` par exemple. Il est possible au passage de poster en plus d'autres valeurs, qui seront intégrées dans l'enregistrement du lien. Ainsi, poster en même temps `qualifier_lien[auteur-3-article-11][valeur]` = `50` enregistrera la valeur 50 dans la colonne `valeur` de la table de lien (qui doit exister !). D'autres informations sont présentes dans http://contrib.spip.net/Des-roles-sur-des-liens, http://zone.spip.org/trac/spip-zone/browser/_plugins_/roles_auteurs ou encore http://zone.spip.org/trac/spip-zone/browser/_plugins_/roles
7 years ago
Intégration dans SPIP de la possibilité de gérer des liens entre objets avec des rôles. On intègre l'API présente actuellement dans le plugin Rôles, en modifiant un peu les fonctions d'édition de liens. Celles-ci permettent maintenant d'éditer des liens ayant donc des rôles. Ces différents rôles et le nom de la colonne SQL qui les reçoit, s'ils sont utilisés, doivent être déclarés avec la déclaration de l'objet éditorial correspondant. Un exemple est donné avec le plugin «Roles auteurs» qui définit quelques rôles. Les champs décrivant les rôles : `roles_colonne`, `roles_titres` et `roles_objets` doivent être déclarés (via le pipeline declarer_tables_objets_sql). ``` "roles_colonne" => "role", "roles_titres" => array( 'redacteur' => 'info_statut_redacteur', 'traducteur' => 'roles_auteurs:traducteur', 'correcteur' => 'roles_auteurs:correcteur', 'relecteur' => 'roles_auteurs:relecteur', ), "roles_objets" => array( 'articles' => array( 'choix' => array('redacteur', 'traducteur', 'correcteur', 'relecteur'), 'defaut' => 'redacteur' ) #'*' => array() ) ``` Une fois déclaré, on peut appeler les fonctions d'édition de lien en transmettant des valeurs de rôles, tel que : ``` objet_associer( array('auteur' => 3), array('article' => 11), array('role' => 'correcteur') ); // utilisera le rôle par défaut objet_associer( array('auteur' => 3), array('article' => 11) ); ``` Si aucun rôle n'est indiqué, le rôle par défaut est appliqué. Dans le cas d'une dissociation également, si aucun rôle n'est indiqué, seuls les liaisons avec le rôle par défaut seront supprimés ; pour supprimer tous les rôles, il faut à ce moment là indiquer '*' : ``` objet_dissocier( array('auteur' => 3), array('article' => 11), array('role' => 'correcteur') ); // utilisera le rôle par défaut objet_dissocier( array('auteur' => 3), array('article' => 11) ); // enlèvera tous les rôles objet_dissocier( array('auteur' => 3), array('article' => 11), array('role' => '*') ); ``` Le formulaire d'édition de liens n'utilisera pas les mêmes squelettes de liaison lorsqu'une colonne de rôle est déclarée. Ainsi dans cet exemple, au lieu de `prive/objets/liste/auteurs_lies.html` et `auteurs_associer.html`, cela utiliserait `prive/objets/liste/auteurs_roles_lies.html` et `auteurs_roles_associer.html`. Il faut donc créer ces squelettes. Ces squelettes peuvent poster les valeurs au formulaire pour insérer de nouveaux liens, de la forme `qualifier_lien[auteur-3-article-11][role]` en postant `redacteur` par exemple. Il est possible au passage de poster en plus d'autres valeurs, qui seront intégrées dans l'enregistrement du lien. Ainsi, poster en même temps `qualifier_lien[auteur-3-article-11][valeur]` = `50` enregistrera la valeur 50 dans la colonne `valeur` de la table de lien (qui doit exister !). D'autres informations sont présentes dans http://contrib.spip.net/Des-roles-sur-des-liens, http://zone.spip.org/trac/spip-zone/browser/_plugins_/roles_auteurs ou encore http://zone.spip.org/trac/spip-zone/browser/_plugins_/roles
7 years ago
Intégration dans SPIP de la possibilité de gérer des liens entre objets avec des rôles. On intègre l'API présente actuellement dans le plugin Rôles, en modifiant un peu les fonctions d'édition de liens. Celles-ci permettent maintenant d'éditer des liens ayant donc des rôles. Ces différents rôles et le nom de la colonne SQL qui les reçoit, s'ils sont utilisés, doivent être déclarés avec la déclaration de l'objet éditorial correspondant. Un exemple est donné avec le plugin «Roles auteurs» qui définit quelques rôles. Les champs décrivant les rôles : `roles_colonne`, `roles_titres` et `roles_objets` doivent être déclarés (via le pipeline declarer_tables_objets_sql). ``` "roles_colonne" => "role", "roles_titres" => array( 'redacteur' => 'info_statut_redacteur', 'traducteur' => 'roles_auteurs:traducteur', 'correcteur' => 'roles_auteurs:correcteur', 'relecteur' => 'roles_auteurs:relecteur', ), "roles_objets" => array( 'articles' => array( 'choix' => array('redacteur', 'traducteur', 'correcteur', 'relecteur'), 'defaut' => 'redacteur' ) #'*' => array() ) ``` Une fois déclaré, on peut appeler les fonctions d'édition de lien en transmettant des valeurs de rôles, tel que : ``` objet_associer( array('auteur' => 3), array('article' => 11), array('role' => 'correcteur') ); // utilisera le rôle par défaut objet_associer( array('auteur' => 3), array('article' => 11) ); ``` Si aucun rôle n'est indiqué, le rôle par défaut est appliqué. Dans le cas d'une dissociation également, si aucun rôle n'est indiqué, seuls les liaisons avec le rôle par défaut seront supprimés ; pour supprimer tous les rôles, il faut à ce moment là indiquer '*' : ``` objet_dissocier( array('auteur' => 3), array('article' => 11), array('role' => 'correcteur') ); // utilisera le rôle par défaut objet_dissocier( array('auteur' => 3), array('article' => 11) ); // enlèvera tous les rôles objet_dissocier( array('auteur' => 3), array('article' => 11), array('role' => '*') ); ``` Le formulaire d'édition de liens n'utilisera pas les mêmes squelettes de liaison lorsqu'une colonne de rôle est déclarée. Ainsi dans cet exemple, au lieu de `prive/objets/liste/auteurs_lies.html` et `auteurs_associer.html`, cela utiliserait `prive/objets/liste/auteurs_roles_lies.html` et `auteurs_roles_associer.html`. Il faut donc créer ces squelettes. Ces squelettes peuvent poster les valeurs au formulaire pour insérer de nouveaux liens, de la forme `qualifier_lien[auteur-3-article-11][role]` en postant `redacteur` par exemple. Il est possible au passage de poster en plus d'autres valeurs, qui seront intégrées dans l'enregistrement du lien. Ainsi, poster en même temps `qualifier_lien[auteur-3-article-11][valeur]` = `50` enregistrera la valeur 50 dans la colonne `valeur` de la table de lien (qui doit exister !). D'autres informations sont présentes dans http://contrib.spip.net/Des-roles-sur-des-liens, http://zone.spip.org/trac/spip-zone/browser/_plugins_/roles_auteurs ou encore http://zone.spip.org/trac/spip-zone/browser/_plugins_/roles
7 years ago
Intégration dans SPIP de la possibilité de gérer des liens entre objets avec des rôles. On intègre l'API présente actuellement dans le plugin Rôles, en modifiant un peu les fonctions d'édition de liens. Celles-ci permettent maintenant d'éditer des liens ayant donc des rôles. Ces différents rôles et le nom de la colonne SQL qui les reçoit, s'ils sont utilisés, doivent être déclarés avec la déclaration de l'objet éditorial correspondant. Un exemple est donné avec le plugin «Roles auteurs» qui définit quelques rôles. Les champs décrivant les rôles : `roles_colonne`, `roles_titres` et `roles_objets` doivent être déclarés (via le pipeline declarer_tables_objets_sql). ``` "roles_colonne" => "role", "roles_titres" => array( 'redacteur' => 'info_statut_redacteur', 'traducteur' => 'roles_auteurs:traducteur', 'correcteur' => 'roles_auteurs:correcteur', 'relecteur' => 'roles_auteurs:relecteur', ), "roles_objets" => array( 'articles' => array( 'choix' => array('redacteur', 'traducteur', 'correcteur', 'relecteur'), 'defaut' => 'redacteur' ) #'*' => array() ) ``` Une fois déclaré, on peut appeler les fonctions d'édition de lien en transmettant des valeurs de rôles, tel que : ``` objet_associer( array('auteur' => 3), array('article' => 11), array('role' => 'correcteur') ); // utilisera le rôle par défaut objet_associer( array('auteur' => 3), array('article' => 11) ); ``` Si aucun rôle n'est indiqué, le rôle par défaut est appliqué. Dans le cas d'une dissociation également, si aucun rôle n'est indiqué, seuls les liaisons avec le rôle par défaut seront supprimés ; pour supprimer tous les rôles, il faut à ce moment là indiquer '*' : ``` objet_dissocier( array('auteur' => 3), array('article' => 11), array('role' => 'correcteur') ); // utilisera le rôle par défaut objet_dissocier( array('auteur' => 3), array('article' => 11) ); // enlèvera tous les rôles objet_dissocier( array('auteur' => 3), array('article' => 11), array('role' => '*') ); ``` Le formulaire d'édition de liens n'utilisera pas les mêmes squelettes de liaison lorsqu'une colonne de rôle est déclarée. Ainsi dans cet exemple, au lieu de `prive/objets/liste/auteurs_lies.html` et `auteurs_associer.html`, cela utiliserait `prive/objets/liste/auteurs_roles_lies.html` et `auteurs_roles_associer.html`. Il faut donc créer ces squelettes. Ces squelettes peuvent poster les valeurs au formulaire pour insérer de nouveaux liens, de la forme `qualifier_lien[auteur-3-article-11][role]` en postant `redacteur` par exemple. Il est possible au passage de poster en plus d'autres valeurs, qui seront intégrées dans l'enregistrement du lien. Ainsi, poster en même temps `qualifier_lien[auteur-3-article-11][valeur]` = `50` enregistrera la valeur 50 dans la colonne `valeur` de la table de lien (qui doit exister !). D'autres informations sont présentes dans http://contrib.spip.net/Des-roles-sur-des-liens, http://zone.spip.org/trac/spip-zone/browser/_plugins_/roles_auteurs ou encore http://zone.spip.org/trac/spip-zone/browser/_plugins_/roles
7 years ago
Intégration dans SPIP de la possibilité de gérer des liens entre objets avec des rôles. On intègre l'API présente actuellement dans le plugin Rôles, en modifiant un peu les fonctions d'édition de liens. Celles-ci permettent maintenant d'éditer des liens ayant donc des rôles. Ces différents rôles et le nom de la colonne SQL qui les reçoit, s'ils sont utilisés, doivent être déclarés avec la déclaration de l'objet éditorial correspondant. Un exemple est donné avec le plugin «Roles auteurs» qui définit quelques rôles. Les champs décrivant les rôles : `roles_colonne`, `roles_titres` et `roles_objets` doivent être déclarés (via le pipeline declarer_tables_objets_sql). ``` "roles_colonne" => "role", "roles_titres" => array( 'redacteur' => 'info_statut_redacteur', 'traducteur' => 'roles_auteurs:traducteur', 'correcteur' => 'roles_auteurs:correcteur', 'relecteur' => 'roles_auteurs:relecteur', ), "roles_objets" => array( 'articles' => array( 'choix' => array('redacteur', 'traducteur', 'correcteur', 'relecteur'), 'defaut' => 'redacteur' ) #'*' => array() ) ``` Une fois déclaré, on peut appeler les fonctions d'édition de lien en transmettant des valeurs de rôles, tel que : ``` objet_associer( array('auteur' => 3), array('article' => 11), array('role' => 'correcteur') ); // utilisera le rôle par défaut objet_associer( array('auteur' => 3), array('article' => 11) ); ``` Si aucun rôle n'est indiqué, le rôle par défaut est appliqué. Dans le cas d'une dissociation également, si aucun rôle n'est indiqué, seuls les liaisons avec le rôle par défaut seront supprimés ; pour supprimer tous les rôles, il faut à ce moment là indiquer '*' : ``` objet_dissocier( array('auteur' => 3), array('article' => 11), array('role' => 'correcteur') ); // utilisera le rôle par défaut objet_dissocier( array('auteur' => 3), array('article' => 11) ); // enlèvera tous les rôles objet_dissocier( array('auteur' => 3), array('article' => 11), array('role' => '*') ); ``` Le formulaire d'édition de liens n'utilisera pas les mêmes squelettes de liaison lorsqu'une colonne de rôle est déclarée. Ainsi dans cet exemple, au lieu de `prive/objets/liste/auteurs_lies.html` et `auteurs_associer.html`, cela utiliserait `prive/objets/liste/auteurs_roles_lies.html` et `auteurs_roles_associer.html`. Il faut donc créer ces squelettes. Ces squelettes peuvent poster les valeurs au formulaire pour insérer de nouveaux liens, de la forme `qualifier_lien[auteur-3-article-11][role]` en postant `redacteur` par exemple. Il est possible au passage de poster en plus d'autres valeurs, qui seront intégrées dans l'enregistrement du lien. Ainsi, poster en même temps `qualifier_lien[auteur-3-article-11][valeur]` = `50` enregistrera la valeur 50 dans la colonne `valeur` de la table de lien (qui doit exister !). D'autres informations sont présentes dans http://contrib.spip.net/Des-roles-sur-des-liens, http://zone.spip.org/trac/spip-zone/browser/_plugins_/roles_auteurs ou encore http://zone.spip.org/trac/spip-zone/browser/_plugins_/roles
7 years ago
Intégration dans SPIP de la possibilité de gérer des liens entre objets avec des rôles. On intègre l'API présente actuellement dans le plugin Rôles, en modifiant un peu les fonctions d'édition de liens. Celles-ci permettent maintenant d'éditer des liens ayant donc des rôles. Ces différents rôles et le nom de la colonne SQL qui les reçoit, s'ils sont utilisés, doivent être déclarés avec la déclaration de l'objet éditorial correspondant. Un exemple est donné avec le plugin «Roles auteurs» qui définit quelques rôles. Les champs décrivant les rôles : `roles_colonne`, `roles_titres` et `roles_objets` doivent être déclarés (via le pipeline declarer_tables_objets_sql). ``` "roles_colonne" => "role", "roles_titres" => array( 'redacteur' => 'info_statut_redacteur', 'traducteur' => 'roles_auteurs:traducteur', 'correcteur' => 'roles_auteurs:correcteur', 'relecteur' => 'roles_auteurs:relecteur', ), "roles_objets" => array( 'articles' => array( 'choix' => array('redacteur', 'traducteur', 'correcteur', 'relecteur'), 'defaut' => 'redacteur' ) #'*' => array() ) ``` Une fois déclaré, on peut appeler les fonctions d'édition de lien en transmettant des valeurs de rôles, tel que : ``` objet_associer( array('auteur' => 3), array('article' => 11), array('role' => 'correcteur') ); // utilisera le rôle par défaut objet_associer( array('auteur' => 3), array('article' => 11) ); ``` Si aucun rôle n'est indiqué, le rôle par défaut est appliqué. Dans le cas d'une dissociation également, si aucun rôle n'est indiqué, seuls les liaisons avec le rôle par défaut seront supprimés ; pour supprimer tous les rôles, il faut à ce moment là indiquer '*' : ``` objet_dissocier( array('auteur' => 3), array('article' => 11), array('role' => 'correcteur') ); // utilisera le rôle par défaut objet_dissocier( array('auteur' => 3), array('article' => 11) ); // enlèvera tous les rôles objet_dissocier( array('auteur' => 3), array('article' => 11), array('role' => '*') ); ``` Le formulaire d'édition de liens n'utilisera pas les mêmes squelettes de liaison lorsqu'une colonne de rôle est déclarée. Ainsi dans cet exemple, au lieu de `prive/objets/liste/auteurs_lies.html` et `auteurs_associer.html`, cela utiliserait `prive/objets/liste/auteurs_roles_lies.html` et `auteurs_roles_associer.html`. Il faut donc créer ces squelettes. Ces squelettes peuvent poster les valeurs au formulaire pour insérer de nouveaux liens, de la forme `qualifier_lien[auteur-3-article-11][role]` en postant `redacteur` par exemple. Il est possible au passage de poster en plus d'autres valeurs, qui seront intégrées dans l'enregistrement du lien. Ainsi, poster en même temps `qualifier_lien[auteur-3-article-11][valeur]` = `50` enregistrera la valeur 50 dans la colonne `valeur` de la table de lien (qui doit exister !). D'autres informations sont présentes dans http://contrib.spip.net/Des-roles-sur-des-liens, http://zone.spip.org/trac/spip-zone/browser/_plugins_/roles_auteurs ou encore http://zone.spip.org/trac/spip-zone/browser/_plugins_/roles
7 years ago
Intégration dans SPIP de la possibilité de gérer des liens entre objets avec des rôles. On intègre l'API présente actuellement dans le plugin Rôles, en modifiant un peu les fonctions d'édition de liens. Celles-ci permettent maintenant d'éditer des liens ayant donc des rôles. Ces différents rôles et le nom de la colonne SQL qui les reçoit, s'ils sont utilisés, doivent être déclarés avec la déclaration de l'objet éditorial correspondant. Un exemple est donné avec le plugin «Roles auteurs» qui définit quelques rôles. Les champs décrivant les rôles : `roles_colonne`, `roles_titres` et `roles_objets` doivent être déclarés (via le pipeline declarer_tables_objets_sql). ``` "roles_colonne" => "role", "roles_titres" => array( 'redacteur' => 'info_statut_redacteur', 'traducteur' => 'roles_auteurs:traducteur', 'correcteur' => 'roles_auteurs:correcteur', 'relecteur' => 'roles_auteurs:relecteur', ), "roles_objets" => array( 'articles' => array( 'choix' => array('redacteur', 'traducteur', 'correcteur', 'relecteur'), 'defaut' => 'redacteur' ) #'*' => array() ) ``` Une fois déclaré, on peut appeler les fonctions d'édition de lien en transmettant des valeurs de rôles, tel que : ``` objet_associer( array('auteur' => 3), array('article' => 11), array('role' => 'correcteur') ); // utilisera le rôle par défaut objet_associer( array('auteur' => 3), array('article' => 11) ); ``` Si aucun rôle n'est indiqué, le rôle par défaut est appliqué. Dans le cas d'une dissociation également, si aucun rôle n'est indiqué, seuls les liaisons avec le rôle par défaut seront supprimés ; pour supprimer tous les rôles, il faut à ce moment là indiquer '*' : ``` objet_dissocier( array('auteur' => 3), array('article' => 11), array('role' => 'correcteur') ); // utilisera le rôle par défaut objet_dissocier( array('auteur' => 3), array('article' => 11) ); // enlèvera tous les rôles objet_dissocier( array('auteur' => 3), array('article' => 11), array('role' => '*') ); ``` Le formulaire d'édition de liens n'utilisera pas les mêmes squelettes de liaison lorsqu'une colonne de rôle est déclarée. Ainsi dans cet exemple, au lieu de `prive/objets/liste/auteurs_lies.html` et `auteurs_associer.html`, cela utiliserait `prive/objets/liste/auteurs_roles_lies.html` et `auteurs_roles_associer.html`. Il faut donc créer ces squelettes. Ces squelettes peuvent poster les valeurs au formulaire pour insérer de nouveaux liens, de la forme `qualifier_lien[auteur-3-article-11][role]` en postant `redacteur` par exemple. Il est possible au passage de poster en plus d'autres valeurs, qui seront intégrées dans l'enregistrement du lien. Ainsi, poster en même temps `qualifier_lien[auteur-3-article-11][valeur]` = `50` enregistrera la valeur 50 dans la colonne `valeur` de la table de lien (qui doit exister !). D'autres informations sont présentes dans http://contrib.spip.net/Des-roles-sur-des-liens, http://zone.spip.org/trac/spip-zone/browser/_plugins_/roles_auteurs ou encore http://zone.spip.org/trac/spip-zone/browser/_plugins_/roles
7 years ago
Intégration dans SPIP de la possibilité de gérer des liens entre objets avec des rôles. On intègre l'API présente actuellement dans le plugin Rôles, en modifiant un peu les fonctions d'édition de liens. Celles-ci permettent maintenant d'éditer des liens ayant donc des rôles. Ces différents rôles et le nom de la colonne SQL qui les reçoit, s'ils sont utilisés, doivent être déclarés avec la déclaration de l'objet éditorial correspondant. Un exemple est donné avec le plugin «Roles auteurs» qui définit quelques rôles. Les champs décrivant les rôles : `roles_colonne`, `roles_titres` et `roles_objets` doivent être déclarés (via le pipeline declarer_tables_objets_sql). ``` "roles_colonne" => "role", "roles_titres" => array( 'redacteur' => 'info_statut_redacteur', 'traducteur' => 'roles_auteurs:traducteur', 'correcteur' => 'roles_auteurs:correcteur', 'relecteur' => 'roles_auteurs:relecteur', ), "roles_objets" => array( 'articles' => array( 'choix' => array('redacteur', 'traducteur', 'correcteur', 'relecteur'), 'defaut' => 'redacteur' ) #'*' => array() ) ``` Une fois déclaré, on peut appeler les fonctions d'édition de lien en transmettant des valeurs de rôles, tel que : ``` objet_associer( array('auteur' => 3), array('article' => 11), array('role' => 'correcteur') ); // utilisera le rôle par défaut objet_associer( array('auteur' => 3), array('article' => 11) ); ``` Si aucun rôle n'est indiqué, le rôle par défaut est appliqué. Dans le cas d'une dissociation également, si aucun rôle n'est indiqué, seuls les liaisons avec le rôle par défaut seront supprimés ; pour supprimer tous les rôles, il faut à ce moment là indiquer '*' : ``` objet_dissocier( array('auteur' => 3), array('article' => 11), array('role' => 'correcteur') ); // utilisera le rôle par défaut objet_dissocier( array('auteur' => 3), array('article' => 11) ); // enlèvera tous les rôles objet_dissocier( array('auteur' => 3), array('article' => 11), array('role' => '*') ); ``` Le formulaire d'édition de liens n'utilisera pas les mêmes squelettes de liaison lorsqu'une colonne de rôle est déclarée. Ainsi dans cet exemple, au lieu de `prive/objets/liste/auteurs_lies.html` et `auteurs_associer.html`, cela utiliserait `prive/objets/liste/auteurs_roles_lies.html` et `auteurs_roles_associer.html`. Il faut donc créer ces squelettes. Ces squelettes peuvent poster les valeurs au formulaire pour insérer de nouveaux liens, de la forme `qualifier_lien[auteur-3-article-11][role]` en postant `redacteur` par exemple. Il est possible au passage de poster en plus d'autres valeurs, qui seront intégrées dans l'enregistrement du lien. Ainsi, poster en même temps `qualifier_lien[auteur-3-article-11][valeur]` = `50` enregistrera la valeur 50 dans la colonne `valeur` de la table de lien (qui doit exister !). D'autres informations sont présentes dans http://contrib.spip.net/Des-roles-sur-des-liens, http://zone.spip.org/trac/spip-zone/browser/_plugins_/roles_auteurs ou encore http://zone.spip.org/trac/spip-zone/browser/_plugins_/roles
7 years ago
Intégration dans SPIP de la possibilité de gérer des liens entre objets avec des rôles. On intègre l'API présente actuellement dans le plugin Rôles, en modifiant un peu les fonctions d'édition de liens. Celles-ci permettent maintenant d'éditer des liens ayant donc des rôles. Ces différents rôles et le nom de la colonne SQL qui les reçoit, s'ils sont utilisés, doivent être déclarés avec la déclaration de l'objet éditorial correspondant. Un exemple est donné avec le plugin «Roles auteurs» qui définit quelques rôles. Les champs décrivant les rôles : `roles_colonne`, `roles_titres` et `roles_objets` doivent être déclarés (via le pipeline declarer_tables_objets_sql). ``` "roles_colonne" => "role", "roles_titres" => array( 'redacteur' => 'info_statut_redacteur', 'traducteur' => 'roles_auteurs:traducteur', 'correcteur' => 'roles_auteurs:correcteur', 'relecteur' => 'roles_auteurs:relecteur', ), "roles_objets" => array( 'articles' => array( 'choix' => array('redacteur', 'traducteur', 'correcteur', 'relecteur'), 'defaut' => 'redacteur' ) #'*' => array() ) ``` Une fois déclaré, on peut appeler les fonctions d'édition de lien en transmettant des valeurs de rôles, tel que : ``` objet_associer( array('auteur' => 3), array('article' => 11), array('role' => 'correcteur') ); // utilisera le rôle par défaut objet_associer( array('auteur' => 3), array('article' => 11) ); ``` Si aucun rôle n'est indiqué, le rôle par défaut est appliqué. Dans le cas d'une dissociation également, si aucun rôle n'est indiqué, seuls les liaisons avec le rôle par défaut seront supprimés ; pour supprimer tous les rôles, il faut à ce moment là indiquer '*' : ``` objet_dissocier( array('auteur' => 3), array('article' => 11), array('role' => 'correcteur') ); // utilisera le rôle par défaut objet_dissocier( array('auteur' => 3), array('article' => 11) ); // enlèvera tous les rôles objet_dissocier( array('auteur' => 3), array('article' => 11), array('role' => '*') ); ``` Le formulaire d'édition de liens n'utilisera pas les mêmes squelettes de liaison lorsqu'une colonne de rôle est déclarée. Ainsi dans cet exemple, au lieu de `prive/objets/liste/auteurs_lies.html` et `auteurs_associer.html`, cela utiliserait `prive/objets/liste/auteurs_roles_lies.html` et `auteurs_roles_associer.html`. Il faut donc créer ces squelettes. Ces squelettes peuvent poster les valeurs au formulaire pour insérer de nouveaux liens, de la forme `qualifier_lien[auteur-3-article-11][role]` en postant `redacteur` par exemple. Il est possible au passage de poster en plus d'autres valeurs, qui seront intégrées dans l'enregistrement du lien. Ainsi, poster en même temps `qualifier_lien[auteur-3-article-11][valeur]` = `50` enregistrera la valeur 50 dans la colonne `valeur` de la table de lien (qui doit exister !). D'autres informations sont présentes dans http://contrib.spip.net/Des-roles-sur-des-liens, http://zone.spip.org/trac/spip-zone/browser/_plugins_/roles_auteurs ou encore http://zone.spip.org/trac/spip-zone/browser/_plugins_/roles
7 years ago
Intégration dans SPIP de la possibilité de gérer des liens entre objets avec des rôles. On intègre l'API présente actuellement dans le plugin Rôles, en modifiant un peu les fonctions d'édition de liens. Celles-ci permettent maintenant d'éditer des liens ayant donc des rôles. Ces différents rôles et le nom de la colonne SQL qui les reçoit, s'ils sont utilisés, doivent être déclarés avec la déclaration de l'objet éditorial correspondant. Un exemple est donné avec le plugin «Roles auteurs» qui définit quelques rôles. Les champs décrivant les rôles : `roles_colonne`, `roles_titres` et `roles_objets` doivent être déclarés (via le pipeline declarer_tables_objets_sql). ``` "roles_colonne" => "role", "roles_titres" => array( 'redacteur' => 'info_statut_redacteur', 'traducteur' => 'roles_auteurs:traducteur', 'correcteur' => 'roles_auteurs:correcteur', 'relecteur' => 'roles_auteurs:relecteur', ), "roles_objets" => array( 'articles' => array( 'choix' => array('redacteur', 'traducteur', 'correcteur', 'relecteur'), 'defaut' => 'redacteur' ) #'*' => array() ) ``` Une fois déclaré, on peut appeler les fonctions d'édition de lien en transmettant des valeurs de rôles, tel que : ``` objet_associer( array('auteur' => 3), array('article' => 11), array('role' => 'correcteur') ); // utilisera le rôle par défaut objet_associer( array('auteur' => 3), array('article' => 11) ); ``` Si aucun rôle n'est indiqué, le rôle par défaut est appliqué. Dans le cas d'une dissociation également, si aucun rôle n'est indiqué, seuls les liaisons avec le rôle par défaut seront supprimés ; pour supprimer tous les rôles, il faut à ce moment là indiquer '*' : ``` objet_dissocier( array('auteur' => 3), array('article' => 11), array('role' => 'correcteur') ); // utilisera le rôle par défaut objet_dissocier( array('auteur' => 3), array('article' => 11) ); // enlèvera tous les rôles objet_dissocier( array('auteur' => 3), array('article' => 11), array('role' => '*') ); ``` Le formulaire d'édition de liens n'utilisera pas les mêmes squelettes de liaison lorsqu'une colonne de rôle est déclarée. Ainsi dans cet exemple, au lieu de `prive/objets/liste/auteurs_lies.html` et `auteurs_associer.html`, cela utiliserait `prive/objets/liste/auteurs_roles_lies.html` et `auteurs_roles_associer.html`. Il faut donc créer ces squelettes. Ces squelettes peuvent poster les valeurs au formulaire pour insérer de nouveaux liens, de la forme `qualifier_lien[auteur-3-article-11][role]` en postant `redacteur` par exemple. Il est possible au passage de poster en plus d'autres valeurs, qui seront intégrées dans l'enregistrement du lien. Ainsi, poster en même temps `qualifier_lien[auteur-3-article-11][valeur]` = `50` enregistrera la valeur 50 dans la colonne `valeur` de la table de lien (qui doit exister !). D'autres informations sont présentes dans http://contrib.spip.net/Des-roles-sur-des-liens, http://zone.spip.org/trac/spip-zone/browser/_plugins_/roles_auteurs ou encore http://zone.spip.org/trac/spip-zone/browser/_plugins_/roles
7 years ago
Intégration dans SPIP de la possibilité de gérer des liens entre objets avec des rôles. On intègre l'API présente actuellement dans le plugin Rôles, en modifiant un peu les fonctions d'édition de liens. Celles-ci permettent maintenant d'éditer des liens ayant donc des rôles. Ces différents rôles et le nom de la colonne SQL qui les reçoit, s'ils sont utilisés, doivent être déclarés avec la déclaration de l'objet éditorial correspondant. Un exemple est donné avec le plugin «Roles auteurs» qui définit quelques rôles. Les champs décrivant les rôles : `roles_colonne`, `roles_titres` et `roles_objets` doivent être déclarés (via le pipeline declarer_tables_objets_sql). ``` "roles_colonne" => "role", "roles_titres" => array( 'redacteur' => 'info_statut_redacteur', 'traducteur' => 'roles_auteurs:traducteur', 'correcteur' => 'roles_auteurs:correcteur', 'relecteur' => 'roles_auteurs:relecteur', ), "roles_objets" => array( 'articles' => array( 'choix' => array('redacteur', 'traducteur', 'correcteur', 'relecteur'), 'defaut' => 'redacteur' ) #'*' => array() ) ``` Une fois déclaré, on peut appeler les fonctions d'édition de lien en transmettant des valeurs de rôles, tel que : ``` objet_associer( array('auteur' => 3), array('article' => 11), array('role' => 'correcteur') ); // utilisera le rôle par défaut objet_associer( array('auteur' => 3), array('article' => 11) ); ``` Si aucun rôle n'est indiqué, le rôle par défaut est appliqué. Dans le cas d'une dissociation également, si aucun rôle n'est indiqué, seuls les liaisons avec le rôle par défaut seront supprimés ; pour supprimer tous les rôles, il faut à ce moment là indiquer '*' : ``` objet_dissocier( array('auteur' => 3), array('article' => 11), array('role' => 'correcteur') ); // utilisera le rôle par défaut objet_dissocier( array('auteur' => 3), array('article' => 11) ); // enlèvera tous les rôles objet_dissocier( array('auteur' => 3), array('article' => 11), array('role' => '*') ); ``` Le formulaire d'édition de liens n'utilisera pas les mêmes squelettes de liaison lorsqu'une colonne de rôle est déclarée. Ainsi dans cet exemple, au lieu de `prive/objets/liste/auteurs_lies.html` et `auteurs_associer.html`, cela utiliserait `prive/objets/liste/auteurs_roles_lies.html` et `auteurs_roles_associer.html`. Il faut donc créer ces squelettes. Ces squelettes peuvent poster les valeurs au formulaire pour insérer de nouveaux liens, de la forme `qualifier_lien[auteur-3-article-11][role]` en postant `redacteur` par exemple. Il est possible au passage de poster en plus d'autres valeurs, qui seront intégrées dans l'enregistrement du lien. Ainsi, poster en même temps `qualifier_lien[auteur-3-article-11][valeur]` = `50` enregistrera la valeur 50 dans la colonne `valeur` de la table de lien (qui doit exister !). D'autres informations sont présentes dans http://contrib.spip.net/Des-roles-sur-des-liens, http://zone.spip.org/trac/spip-zone/browser/_plugins_/roles_auteurs ou encore http://zone.spip.org/trac/spip-zone/browser/_plugins_/roles
7 years ago
Intégration dans SPIP de la possibilité de gérer des liens entre objets avec des rôles. On intègre l'API présente actuellement dans le plugin Rôles, en modifiant un peu les fonctions d'édition de liens. Celles-ci permettent maintenant d'éditer des liens ayant donc des rôles. Ces différents rôles et le nom de la colonne SQL qui les reçoit, s'ils sont utilisés, doivent être déclarés avec la déclaration de l'objet éditorial correspondant. Un exemple est donné avec le plugin «Roles auteurs» qui définit quelques rôles. Les champs décrivant les rôles : `roles_colonne`, `roles_titres` et `roles_objets` doivent être déclarés (via le pipeline declarer_tables_objets_sql). ``` "roles_colonne" => "role", "roles_titres" => array( 'redacteur' => 'info_statut_redacteur', 'traducteur' => 'roles_auteurs:traducteur', 'correcteur' => 'roles_auteurs:correcteur', 'relecteur' => 'roles_auteurs:relecteur', ), "roles_objets" => array( 'articles' => array( 'choix' => array('redacteur', 'traducteur', 'correcteur', 'relecteur'), 'defaut' => 'redacteur' ) #'*' => array() ) ``` Une fois déclaré, on peut appeler les fonctions d'édition de lien en transmettant des valeurs de rôles, tel que : ``` objet_associer( array('auteur' => 3), array('article' => 11), array('role' => 'correcteur') ); // utilisera le rôle par défaut objet_associer( array('auteur' => 3), array('article' => 11) ); ``` Si aucun rôle n'est indiqué, le rôle par défaut est appliqué. Dans le cas d'une dissociation également, si aucun rôle n'est indiqué, seuls les liaisons avec le rôle par défaut seront supprimés ; pour supprimer tous les rôles, il faut à ce moment là indiquer '*' : ``` objet_dissocier( array('auteur' => 3), array('article' => 11), array('role' => 'correcteur') ); // utilisera le rôle par défaut objet_dissocier( array('auteur' => 3), array('article' => 11) ); // enlèvera tous les rôles objet_dissocier( array('auteur' => 3), array('article' => 11), array('role' => '*') ); ``` Le formulaire d'édition de liens n'utilisera pas les mêmes squelettes de liaison lorsqu'une colonne de rôle est déclarée. Ainsi dans cet exemple, au lieu de `prive/objets/liste/auteurs_lies.html` et `auteurs_associer.html`, cela utiliserait `prive/objets/liste/auteurs_roles_lies.html` et `auteurs_roles_associer.html`. Il faut donc créer ces squelettes. Ces squelettes peuvent poster les valeurs au formulaire pour insérer de nouveaux liens, de la forme `qualifier_lien[auteur-3-article-11][role]` en postant `redacteur` par exemple. Il est possible au passage de poster en plus d'autres valeurs, qui seront intégrées dans l'enregistrement du lien. Ainsi, poster en même temps `qualifier_lien[auteur-3-article-11][valeur]` = `50` enregistrera la valeur 50 dans la colonne `valeur` de la table de lien (qui doit exister !). D'autres informations sont présentes dans http://contrib.spip.net/Des-roles-sur-des-liens, http://zone.spip.org/trac/spip-zone/browser/_plugins_/roles_auteurs ou encore http://zone.spip.org/trac/spip-zone/browser/_plugins_/roles
7 years ago
Intégration dans SPIP de la possibilité de gérer des liens entre objets avec des rôles. On intègre l'API présente actuellement dans le plugin Rôles, en modifiant un peu les fonctions d'édition de liens. Celles-ci permettent maintenant d'éditer des liens ayant donc des rôles. Ces différents rôles et le nom de la colonne SQL qui les reçoit, s'ils sont utilisés, doivent être déclarés avec la déclaration de l'objet éditorial correspondant. Un exemple est donné avec le plugin «Roles auteurs» qui définit quelques rôles. Les champs décrivant les rôles : `roles_colonne`, `roles_titres` et `roles_objets` doivent être déclarés (via le pipeline declarer_tables_objets_sql). ``` "roles_colonne" => "role", "roles_titres" => array( 'redacteur' => 'info_statut_redacteur', 'traducteur' => 'roles_auteurs:traducteur', 'correcteur' => 'roles_auteurs:correcteur', 'relecteur' => 'roles_auteurs:relecteur', ), "roles_objets" => array( 'articles' => array( 'choix' => array('redacteur', 'traducteur', 'correcteur', 'relecteur'), 'defaut' => 'redacteur' ) #'*' => array() ) ``` Une fois déclaré, on peut appeler les fonctions d'édition de lien en transmettant des valeurs de rôles, tel que : ``` objet_associer( array('auteur' => 3), array('article' => 11), array('role' => 'correcteur') ); // utilisera le rôle par défaut objet_associer( array('auteur' => 3), array('article' => 11) ); ``` Si aucun rôle n'est indiqué, le rôle par défaut est appliqué. Dans le cas d'une dissociation également, si aucun rôle n'est indiqué, seuls les liaisons avec le rôle par défaut seront supprimés ; pour supprimer tous les rôles, il faut à ce moment là indiquer '*' : ``` objet_dissocier( array('auteur' => 3), array('article' => 11), array('role' => 'correcteur') ); // utilisera le rôle par défaut objet_dissocier( array('auteur' => 3), array('article' => 11) ); // enlèvera tous les rôles objet_dissocier( array('auteur' => 3), array('article' => 11), array('role' => '*') ); ``` Le formulaire d'édition de liens n'utilisera pas les mêmes squelettes de liaison lorsqu'une colonne de rôle est déclarée. Ainsi dans cet exemple, au lieu de `prive/objets/liste/auteurs_lies.html` et `auteurs_associer.html`, cela utiliserait `prive/objets/liste/auteurs_roles_lies.html` et `auteurs_roles_associer.html`. Il faut donc créer ces squelettes. Ces squelettes peuvent poster les valeurs au formulaire pour insérer de nouveaux liens, de la forme `qualifier_lien[auteur-3-article-11][role]` en postant `redacteur` par exemple. Il est possible au passage de poster en plus d'autres valeurs, qui seront intégrées dans l'enregistrement du lien. Ainsi, poster en même temps `qualifier_lien[auteur-3-article-11][valeur]` = `50` enregistrera la valeur 50 dans la colonne `valeur` de la table de lien (qui doit exister !). D'autres informations sont présentes dans http://contrib.spip.net/Des-roles-sur-des-liens, http://zone.spip.org/trac/spip-zone/browser/_plugins_/roles_auteurs ou encore http://zone.spip.org/trac/spip-zone/browser/_plugins_/roles
7 years ago
Intégration dans SPIP de la possibilité de gérer des liens entre objets avec des rôles. On intègre l'API présente actuellement dans le plugin Rôles, en modifiant un peu les fonctions d'édition de liens. Celles-ci permettent maintenant d'éditer des liens ayant donc des rôles. Ces différents rôles et le nom de la colonne SQL qui les reçoit, s'ils sont utilisés, doivent être déclarés avec la déclaration de l'objet éditorial correspondant. Un exemple est donné avec le plugin «Roles auteurs» qui définit quelques rôles. Les champs décrivant les rôles : `roles_colonne`, `roles_titres` et `roles_objets` doivent être déclarés (via le pipeline declarer_tables_objets_sql). ``` "roles_colonne" => "role", "roles_titres" => array( 'redacteur' => 'info_statut_redacteur', 'traducteur' => 'roles_auteurs:traducteur', 'correcteur' => 'roles_auteurs:correcteur', 'relecteur' => 'roles_auteurs:relecteur', ), "roles_objets" => array( 'articles' => array( 'choix' => array('redacteur', 'traducteur', 'correcteur', 'relecteur'), 'defaut' => 'redacteur' ) #'*' => array() ) ``` Une fois déclaré, on peut appeler les fonctions d'édition de lien en transmettant des valeurs de rôles, tel que : ``` objet_associer( array('auteur' => 3), array('article' => 11), array('role' => 'correcteur') ); // utilisera le rôle par défaut objet_associer( array('auteur' => 3), array('article' => 11) ); ``` Si aucun rôle n'est indiqué, le rôle par défaut est appliqué. Dans le cas d'une dissociation également, si aucun rôle n'est indiqué, seuls les liaisons avec le rôle par défaut seront supprimés ; pour supprimer tous les rôles, il faut à ce moment là indiquer '*' : ``` objet_dissocier( array('auteur' => 3), array('article' => 11), array('role' => 'correcteur') ); // utilisera le rôle par défaut objet_dissocier( array('auteur' => 3), array('article' => 11) ); // enlèvera tous les rôles objet_dissocier( array('auteur' => 3), array('article' => 11), array('role' => '*') ); ``` Le formulaire d'édition de liens n'utilisera pas les mêmes squelettes de liaison lorsqu'une colonne de rôle est déclarée. Ainsi dans cet exemple, au lieu de `prive/objets/liste/auteurs_lies.html` et `auteurs_associer.html`, cela utiliserait `prive/objets/liste/auteurs_roles_lies.html` et `auteurs_roles_associer.html`. Il faut donc créer ces squelettes. Ces squelettes peuvent poster les valeurs au formulaire pour insérer de nouveaux liens, de la forme `qualifier_lien[auteur-3-article-11][role]` en postant `redacteur` par exemple. Il est possible au passage de poster en plus d'autres valeurs, qui seront intégrées dans l'enregistrement du lien. Ainsi, poster en même temps `qualifier_lien[auteur-3-article-11][valeur]` = `50` enregistrera la valeur 50 dans la colonne `valeur` de la table de lien (qui doit exister !). D'autres informations sont présentes dans http://contrib.spip.net/Des-roles-sur-des-liens, http://zone.spip.org/trac/spip-zone/browser/_plugins_/roles_auteurs ou encore http://zone.spip.org/trac/spip-zone/browser/_plugins_/roles
7 years ago
Intégration dans SPIP de la possibilité de gérer des liens entre objets avec des rôles. On intègre l'API présente actuellement dans le plugin Rôles, en modifiant un peu les fonctions d'édition de liens. Celles-ci permettent maintenant d'éditer des liens ayant donc des rôles. Ces différents rôles et le nom de la colonne SQL qui les reçoit, s'ils sont utilisés, doivent être déclarés avec la déclaration de l'objet éditorial correspondant. Un exemple est donné avec le plugin «Roles auteurs» qui définit quelques rôles. Les champs décrivant les rôles : `roles_colonne`, `roles_titres` et `roles_objets` doivent être déclarés (via le pipeline declarer_tables_objets_sql). ``` "roles_colonne" => "role", "roles_titres" => array( 'redacteur' => 'info_statut_redacteur', 'traducteur' => 'roles_auteurs:traducteur', 'correcteur' => 'roles_auteurs:correcteur', 'relecteur' => 'roles_auteurs:relecteur', ), "roles_objets" => array( 'articles' => array( 'choix' => array('redacteur', 'traducteur', 'correcteur', 'relecteur'), 'defaut' => 'redacteur' ) #'*' => array() ) ``` Une fois déclaré, on peut appeler les fonctions d'édition de lien en transmettant des valeurs de rôles, tel que : ``` objet_associer( array('auteur' => 3), array('article' => 11), array('role' => 'correcteur') ); // utilisera le rôle par défaut objet_associer( array('auteur' => 3), array('article' => 11) ); ``` Si aucun rôle n'est indiqué, le rôle par défaut est appliqué. Dans le cas d'une dissociation également, si aucun rôle n'est indiqué, seuls les liaisons avec le rôle par défaut seront supprimés ; pour supprimer tous les rôles, il faut à ce moment là indiquer '*' : ``` objet_dissocier( array('auteur' => 3), array('article' => 11), array('role' => 'correcteur') ); // utilisera le rôle par défaut objet_dissocier( array('auteur' => 3), array('article' => 11) ); // enlèvera tous les rôles objet_dissocier( array('auteur' => 3), array('article' => 11), array('role' => '*') ); ``` Le formulaire d'édition de liens n'utilisera pas les mêmes squelettes de liaison lorsqu'une colonne de rôle est déclarée. Ainsi dans cet exemple, au lieu de `prive/objets/liste/auteurs_lies.html` et `auteurs_associer.html`, cela utiliserait `prive/objets/liste/auteurs_roles_lies.html` et `auteurs_roles_associer.html`. Il faut donc créer ces squelettes. Ces squelettes peuvent poster les valeurs au formulaire pour insérer de nouveaux liens, de la forme `qualifier_lien[auteur-3-article-11][role]` en postant `redacteur` par exemple. Il est possible au passage de poster en plus d'autres valeurs, qui seront intégrées dans l'enregistrement du lien. Ainsi, poster en même temps `qualifier_lien[auteur-3-article-11][valeur]` = `50` enregistrera la valeur 50 dans la colonne `valeur` de la table de lien (qui doit exister !). D'autres informations sont présentes dans http://contrib.spip.net/Des-roles-sur-des-liens, http://zone.spip.org/trac/spip-zone/browser/_plugins_/roles_auteurs ou encore http://zone.spip.org/trac/spip-zone/browser/_plugins_/roles
7 years ago
Intégration dans SPIP de la possibilité de gérer des liens entre objets avec des rôles. On intègre l'API présente actuellement dans le plugin Rôles, en modifiant un peu les fonctions d'édition de liens. Celles-ci permettent maintenant d'éditer des liens ayant donc des rôles. Ces différents rôles et le nom de la colonne SQL qui les reçoit, s'ils sont utilisés, doivent être déclarés avec la déclaration de l'objet éditorial correspondant. Un exemple est donné avec le plugin «Roles auteurs» qui définit quelques rôles. Les champs décrivant les rôles : `roles_colonne`, `roles_titres` et `roles_objets` doivent être déclarés (via le pipeline declarer_tables_objets_sql). ``` "roles_colonne" => "role", "roles_titres" => array( 'redacteur' => 'info_statut_redacteur', 'traducteur' => 'roles_auteurs:traducteur', 'correcteur' => 'roles_auteurs:correcteur', 'relecteur' => 'roles_auteurs:relecteur', ), "roles_objets" => array( 'articles' => array( 'choix' => array('redacteur', 'traducteur', 'correcteur', 'relecteur'), 'defaut' => 'redacteur' ) #'*' => array() ) ``` Une fois déclaré, on peut appeler les fonctions d'édition de lien en transmettant des valeurs de rôles, tel que : ``` objet_associer( array('auteur' => 3), array('article' => 11), array('role' => 'correcteur') ); // utilisera le rôle par défaut objet_associer( array('auteur' => 3), array('article' => 11) ); ``` Si aucun rôle n'est indiqué, le rôle par défaut est appliqué. Dans le cas d'une dissociation également, si aucun rôle n'est indiqué, seuls les liaisons avec le rôle par défaut seront supprimés ; pour supprimer tous les rôles, il faut à ce moment là indiquer '*' : ``` objet_dissocier( array('auteur' => 3), array('article' => 11), array('role' => 'correcteur') ); // utilisera le rôle par défaut objet_dissocier( array('auteur' => 3), array('article' => 11) ); // enlèvera tous les rôles objet_dissocier( array('auteur' => 3), array('article' => 11), array('role' => '*') ); ``` Le formulaire d'édition de liens n'utilisera pas les mêmes squelettes de liaison lorsqu'une colonne de rôle est déclarée. Ainsi dans cet exemple, au lieu de `prive/objets/liste/auteurs_lies.html` et `auteurs_associer.html`, cela utiliserait `prive/objets/liste/auteurs_roles_lies.html` et `auteurs_roles_associer.html`. Il faut donc créer ces squelettes. Ces squelettes peuvent poster les valeurs au formulaire pour insérer de nouveaux liens, de la forme `qualifier_lien[auteur-3-article-11][role]` en postant `redacteur` par exemple. Il est possible au passage de poster en plus d'autres valeurs, qui seront intégrées dans l'enregistrement du lien. Ainsi, poster en même temps `qualifier_lien[auteur-3-article-11][valeur]` = `50` enregistrera la valeur 50 dans la colonne `valeur` de la table de lien (qui doit exister !). D'autres informations sont présentes dans http://contrib.spip.net/Des-roles-sur-des-liens, http://zone.spip.org/trac/spip-zone/browser/_plugins_/roles_auteurs ou encore http://zone.spip.org/trac/spip-zone/browser/_plugins_/roles
7 years ago
Intégration dans SPIP de la possibilité de gérer des liens entre objets avec des rôles. On intègre l'API présente actuellement dans le plugin Rôles, en modifiant un peu les fonctions d'édition de liens. Celles-ci permettent maintenant d'éditer des liens ayant donc des rôles. Ces différents rôles et le nom de la colonne SQL qui les reçoit, s'ils sont utilisés, doivent être déclarés avec la déclaration de l'objet éditorial correspondant. Un exemple est donné avec le plugin «Roles auteurs» qui définit quelques rôles. Les champs décrivant les rôles : `roles_colonne`, `roles_titres` et `roles_objets` doivent être déclarés (via le pipeline declarer_tables_objets_sql). ``` "roles_colonne" => "role", "roles_titres" => array( 'redacteur' => 'info_statut_redacteur', 'traducteur' => 'roles_auteurs:traducteur', 'correcteur' => 'roles_auteurs:correcteur', 'relecteur' => 'roles_auteurs:relecteur', ), "roles_objets" => array( 'articles' => array( 'choix' => array('redacteur', 'traducteur', 'correcteur', 'relecteur'), 'defaut' => 'redacteur' ) #'*' => array() ) ``` Une fois déclaré, on peut appeler les fonctions d'édition de lien en transmettant des valeurs de rôles, tel que : ``` objet_associer( array('auteur' => 3), array('article' => 11), array('role' => 'correcteur') ); // utilisera le rôle par défaut objet_associer( array('auteur' => 3), array('article' => 11) ); ``` Si aucun rôle n'est indiqué, le rôle par défaut est appliqué. Dans le cas d'une dissociation également, si aucun rôle n'est indiqué, seuls les liaisons avec le rôle par défaut seront supprimés ; pour supprimer tous les rôles, il faut à ce moment là indiquer '*' : ``` objet_dissocier( array('auteur' => 3), array('article' => 11), array('role' => 'correcteur') ); // utilisera le rôle par défaut objet_dissocier( array('auteur' => 3), array('article' => 11) ); // enlèvera tous les rôles objet_dissocier( array('auteur' => 3), array('article' => 11), array('role' => '*') ); ``` Le formulaire d'édition de liens n'utilisera pas les mêmes squelettes de liaison lorsqu'une colonne de rôle est déclarée. Ainsi dans cet exemple, au lieu de `prive/objets/liste/auteurs_lies.html` et `auteurs_associer.html`, cela utiliserait `prive/objets/liste/auteurs_roles_lies.html` et `auteurs_roles_associer.html`. Il faut donc créer ces squelettes. Ces squelettes peuvent poster les valeurs au formulaire pour insérer de nouveaux liens, de la forme `qualifier_lien[auteur-3-article-11][role]` en postant `redacteur` par exemple. Il est possible au passage de poster en plus d'autres valeurs, qui seront intégrées dans l'enregistrement du lien. Ainsi, poster en même temps `qualifier_lien[auteur-3-article-11][valeur]` = `50` enregistrera la valeur 50 dans la colonne `valeur` de la table de lien (qui doit exister !). D'autres informations sont présentes dans http://contrib.spip.net/Des-roles-sur-des-liens, http://zone.spip.org/trac/spip-zone/browser/_plugins_/roles_auteurs ou encore http://zone.spip.org/trac/spip-zone/browser/_plugins_/roles
7 years ago
Intégration dans SPIP de la possibilité de gérer des liens entre objets avec des rôles. On intègre l'API présente actuellement dans le plugin Rôles, en modifiant un peu les fonctions d'édition de liens. Celles-ci permettent maintenant d'éditer des liens ayant donc des rôles. Ces différents rôles et le nom de la colonne SQL qui les reçoit, s'ils sont utilisés, doivent être déclarés avec la déclaration de l'objet éditorial correspondant. Un exemple est donné avec le plugin «Roles auteurs» qui définit quelques rôles. Les champs décrivant les rôles : `roles_colonne`, `roles_titres` et `roles_objets` doivent être déclarés (via le pipeline declarer_tables_objets_sql). ``` "roles_colonne" => "role", "roles_titres" => array( 'redacteur' => 'info_statut_redacteur', 'traducteur' => 'roles_auteurs:traducteur', 'correcteur' => 'roles_auteurs:correcteur', 'relecteur' => 'roles_auteurs:relecteur', ), "roles_objets" => array( 'articles' => array( 'choix' => array('redacteur', 'traducteur', 'correcteur', 'relecteur'), 'defaut' => 'redacteur' ) #'*' => array() ) ``` Une fois déclaré, on peut appeler les fonctions d'édition de lien en transmettant des valeurs de rôles, tel que : ``` objet_associer( array('auteur' => 3), array('article' => 11), array('role' => 'correcteur') ); // utilisera le rôle par défaut objet_associer( array('auteur' => 3), array('article' => 11) ); ``` Si aucun rôle n'est indiqué, le rôle par défaut est appliqué. Dans le cas d'une dissociation également, si aucun rôle n'est indiqué, seuls les liaisons avec le rôle par défaut seront supprimés ; pour supprimer tous les rôles, il faut à ce moment là indiquer '*' : ``` objet_dissocier( array('auteur' => 3), array('article' => 11), array('role' => 'correcteur') ); // utilisera le rôle par défaut objet_dissocier( array('auteur' => 3), array('article' => 11) ); // enlèvera tous les rôles objet_dissocier( array('auteur' => 3), array('article' => 11), array('role' => '*') ); ``` Le formulaire d'édition de liens n'utilisera pas les mêmes squelettes de liaison lorsqu'une colonne de rôle est déclarée. Ainsi dans cet exemple, au lieu de `prive/objets/liste/auteurs_lies.html` et `auteurs_associer.html`, cela utiliserait `prive/objets/liste/auteurs_roles_lies.html` et `auteurs_roles_associer.html`. Il faut donc créer ces squelettes. Ces squelettes peuvent poster les valeurs au formulaire pour insérer de nouveaux liens, de la forme `qualifier_lien[auteur-3-article-11][role]` en postant `redacteur` par exemple. Il est possible au passage de poster en plus d'autres valeurs, qui seront intégrées dans l'enregistrement du lien. Ainsi, poster en même temps `qualifier_lien[auteur-3-article-11][valeur]` = `50` enregistrera la valeur 50 dans la colonne `valeur` de la table de lien (qui doit exister !). D'autres informations sont présentes dans http://contrib.spip.net/Des-roles-sur-des-liens, http://zone.spip.org/trac/spip-zone/browser/_plugins_/roles_auteurs ou encore http://zone.spip.org/trac/spip-zone/browser/_plugins_/roles
7 years ago
Intégration dans SPIP de la possibilité de gérer des liens entre objets avec des rôles. On intègre l'API présente actuellement dans le plugin Rôles, en modifiant un peu les fonctions d'édition de liens. Celles-ci permettent maintenant d'éditer des liens ayant donc des rôles. Ces différents rôles et le nom de la colonne SQL qui les reçoit, s'ils sont utilisés, doivent être déclarés avec la déclaration de l'objet éditorial correspondant. Un exemple est donné avec le plugin «Roles auteurs» qui définit quelques rôles. Les champs décrivant les rôles : `roles_colonne`, `roles_titres` et `roles_objets` doivent être déclarés (via le pipeline declarer_tables_objets_sql). ``` "roles_colonne" => "role", "roles_titres" => array( 'redacteur' => 'info_statut_redacteur', 'traducteur' => 'roles_auteurs:traducteur', 'correcteur' => 'roles_auteurs:correcteur', 'relecteur' => 'roles_auteurs:relecteur', ), "roles_objets" => array( 'articles' => array( 'choix' => array('redacteur', 'traducteur', 'correcteur', 'relecteur'), 'defaut' => 'redacteur' ) #'*' => array() ) ``` Une fois déclaré, on peut appeler les fonctions d'édition de lien en transmettant des valeurs de rôles, tel que : ``` objet_associer( array('auteur' => 3), array('article' => 11), array('role' => 'correcteur') ); // utilisera le rôle par défaut objet_associer( array('auteur' => 3), array('article' => 11) ); ``` Si aucun rôle n'est indiqué, le rôle par défaut est appliqué. Dans le cas d'une dissociation également, si aucun rôle n'est indiqué, seuls les liaisons avec le rôle par défaut seront supprimés ; pour supprimer tous les rôles, il faut à ce moment là indiquer '*' : ``` objet_dissocier( array('auteur' => 3), array('article' => 11), array('role' => 'correcteur') ); // utilisera le rôle par défaut objet_dissocier( array('auteur' => 3), array('article' => 11) ); // enlèvera tous les rôles objet_dissocier( array('auteur' => 3), array('article' => 11), array('role' => '*') ); ``` Le formulaire d'édition de liens n'utilisera pas les mêmes squelettes de liaison lorsqu'une colonne de rôle est déclarée. Ainsi dans cet exemple, au lieu de `prive/objets/liste/auteurs_lies.html` et `auteurs_associer.html`, cela utiliserait `prive/objets/liste/auteurs_roles_lies.html` et `auteurs_roles_associer.html`. Il faut donc créer ces squelettes. Ces squelettes peuvent poster les valeurs au formulaire pour insérer de nouveaux liens, de la forme `qualifier_lien[auteur-3-article-11][role]` en postant `redacteur` par exemple. Il est possible au passage de poster en plus d'autres valeurs, qui seront intégrées dans l'enregistrement du lien. Ainsi, poster en même temps `qualifier_lien[auteur-3-article-11][valeur]` = `50` enregistrera la valeur 50 dans la colonne `valeur` de la table de lien (qui doit exister !). D'autres informations sont présentes dans http://contrib.spip.net/Des-roles-sur-des-liens, http://zone.spip.org/trac/spip-zone/browser/_plugins_/roles_auteurs ou encore http://zone.spip.org/trac/spip-zone/browser/_plugins_/roles
7 years ago
Intégration dans SPIP de la possibilité de gérer des liens entre objets avec des rôles. On intègre l'API présente actuellement dans le plugin Rôles, en modifiant un peu les fonctions d'édition de liens. Celles-ci permettent maintenant d'éditer des liens ayant donc des rôles. Ces différents rôles et le nom de la colonne SQL qui les reçoit, s'ils sont utilisés, doivent être déclarés avec la déclaration de l'objet éditorial correspondant. Un exemple est donné avec le plugin «Roles auteurs» qui définit quelques rôles. Les champs décrivant les rôles : `roles_colonne`, `roles_titres` et `roles_objets` doivent être déclarés (via le pipeline declarer_tables_objets_sql). ``` "roles_colonne" => "role", "roles_titres" => array( 'redacteur' => 'info_statut_redacteur', 'traducteur' => 'roles_auteurs:traducteur', 'correcteur' => 'roles_auteurs:correcteur', 'relecteur' => 'roles_auteurs:relecteur', ), "roles_objets" => array( 'articles' => array( 'choix' => array('redacteur', 'traducteur', 'correcteur', 'relecteur'), 'defaut' => 'redacteur' ) #'*' => array() ) ``` Une fois déclaré, on peut appeler les fonctions d'édition de lien en transmettant des valeurs de rôles, tel que : ``` objet_associer( array('auteur' => 3), array('article' => 11), array('role' => 'correcteur') ); // utilisera le rôle par défaut objet_associer( array('auteur' => 3), array('article' => 11) ); ``` Si aucun rôle n'est indiqué, le rôle par défaut est appliqué. Dans le cas d'une dissociation également, si aucun rôle n'est indiqué, seuls les liaisons avec le rôle par défaut seront supprimés ; pour supprimer tous les rôles, il faut à ce moment là indiquer '*' : ``` objet_dissocier( array('auteur' => 3), array('article' => 11), array('role' => 'correcteur') ); // utilisera le rôle par défaut objet_dissocier( array('auteur' => 3), array('article' => 11) ); // enlèvera tous les rôles objet_dissocier( array('auteur' => 3), array('article' => 11), array('role' => '*') ); ``` Le formulaire d'édition de liens n'utilisera pas les mêmes squelettes de liaison lorsqu'une colonne de rôle est déclarée. Ainsi dans cet exemple, au lieu de `prive/objets/liste/auteurs_lies.html` et `auteurs_associer.html`, cela utiliserait `prive/objets/liste/auteurs_roles_lies.html` et `auteurs_roles_associer.html`. Il faut donc créer ces squelettes. Ces squelettes peuvent poster les valeurs au formulaire pour insérer de nouveaux liens, de la forme `qualifier_lien[auteur-3-article-11][role]` en postant `redacteur` par exemple. Il est possible au passage de poster en plus d'autres valeurs, qui seront intégrées dans l'enregistrement du lien. Ainsi, poster en même temps `qualifier_lien[auteur-3-article-11][valeur]` = `50` enregistrera la valeur 50 dans la colonne `valeur` de la table de lien (qui doit exister !). D'autres informations sont présentes dans http://contrib.spip.net/Des-roles-sur-des-liens, http://zone.spip.org/trac/spip-zone/browser/_plugins_/roles_auteurs ou encore http://zone.spip.org/trac/spip-zone/browser/_plugins_/roles
7 years ago
Intégration dans SPIP de la possibilité de gérer des liens entre objets avec des rôles. On intègre l'API présente actuellement dans le plugin Rôles, en modifiant un peu les fonctions d'édition de liens. Celles-ci permettent maintenant d'éditer des liens ayant donc des rôles. Ces différents rôles et le nom de la colonne SQL qui les reçoit, s'ils sont utilisés, doivent être déclarés avec la déclaration de l'objet éditorial correspondant. Un exemple est donné avec le plugin «Roles auteurs» qui définit quelques rôles. Les champs décrivant les rôles : `roles_colonne`, `roles_titres` et `roles_objets` doivent être déclarés (via le pipeline declarer_tables_objets_sql). ``` "roles_colonne" => "role", "roles_titres" => array( 'redacteur' => 'info_statut_redacteur', 'traducteur' => 'roles_auteurs:traducteur', 'correcteur' => 'roles_auteurs:correcteur', 'relecteur' => 'roles_auteurs:relecteur', ), "roles_objets" => array( 'articles' => array( 'choix' => array('redacteur', 'traducteur', 'correcteur', 'relecteur'), 'defaut' => 'redacteur' ) #'*' => array() ) ``` Une fois déclaré, on peut appeler les fonctions d'édition de lien en transmettant des valeurs de rôles, tel que : ``` objet_associer( array('auteur' => 3), array('article' => 11), array('role' => 'correcteur') ); // utilisera le rôle par défaut objet_associer( array('auteur' => 3), array('article' => 11) ); ``` Si aucun rôle n'est indiqué, le rôle par défaut est appliqué. Dans le cas d'une dissociation également, si aucun rôle n'est indiqué, seuls les liaisons avec le rôle par défaut seront supprimés ; pour supprimer tous les rôles, il faut à ce moment là indiquer '*' : ``` objet_dissocier( array('auteur' => 3), array('article' => 11), array('role' => 'correcteur') ); // utilisera le rôle par défaut objet_dissocier( array('auteur' => 3), array('article' => 11) ); // enlèvera tous les rôles objet_dissocier( array('auteur' => 3), array('article' => 11), array('role' => '*') ); ``` Le formulaire d'édition de liens n'utilisera pas les mêmes squelettes de liaison lorsqu'une colonne de rôle est déclarée. Ainsi dans cet exemple, au lieu de `prive/objets/liste/auteurs_lies.html` et `auteurs_associer.html`, cela utiliserait `prive/objets/liste/auteurs_roles_lies.html` et `auteurs_roles_associer.html`. Il faut donc créer ces squelettes. Ces squelettes peuvent poster les valeurs au formulaire pour insérer de nouveaux liens, de la forme `qualifier_lien[auteur-3-article-11][role]` en postant `redacteur` par exemple. Il est possible au passage de poster en plus d'autres valeurs, qui seront intégrées dans l'enregistrement du lien. Ainsi, poster en même temps `qualifier_lien[auteur-3-article-11][valeur]` = `50` enregistrera la valeur 50 dans la colonne `valeur` de la table de lien (qui doit exister !). D'autres informations sont présentes dans http://contrib.spip.net/Des-roles-sur-des-liens, http://zone.spip.org/trac/spip-zone/browser/_plugins_/roles_auteurs ou encore http://zone.spip.org/trac/spip-zone/browser/_plugins_/roles
7 years ago
Intégration dans SPIP de la possibilité de gérer des liens entre objets avec des rôles. On intègre l'API présente actuellement dans le plugin Rôles, en modifiant un peu les fonctions d'édition de liens. Celles-ci permettent maintenant d'éditer des liens ayant donc des rôles. Ces différents rôles et le nom de la colonne SQL qui les reçoit, s'ils sont utilisés, doivent être déclarés avec la déclaration de l'objet éditorial correspondant. Un exemple est donné avec le plugin «Roles auteurs» qui définit quelques rôles. Les champs décrivant les rôles : `roles_colonne`, `roles_titres` et `roles_objets` doivent être déclarés (via le pipeline declarer_tables_objets_sql). ``` "roles_colonne" => "role", "roles_titres" => array( 'redacteur' => 'info_statut_redacteur', 'traducteur' => 'roles_auteurs:traducteur', 'correcteur' => 'roles_auteurs:correcteur', 'relecteur' => 'roles_auteurs:relecteur', ), "roles_objets" => array( 'articles' => array( 'choix' => array('redacteur', 'traducteur', 'correcteur', 'relecteur'), 'defaut' => 'redacteur' ) #'*' => array() ) ``` Une fois déclaré, on peut appeler les fonctions d'édition de lien en transmettant des valeurs de rôles, tel que : ``` objet_associer( array('auteur' => 3), array('article' => 11), array('role' => 'correcteur') ); // utilisera le rôle par défaut objet_associer( array('auteur' => 3), array('article' => 11) ); ``` Si aucun rôle n'est indiqué, le rôle par défaut est appliqué. Dans le cas d'une dissociation également, si aucun rôle n'est indiqué, seuls les liaisons avec le rôle par défaut seront supprimés ; pour supprimer tous les rôles, il faut à ce moment là indiquer '*' : ``` objet_dissocier( array('auteur' => 3), array('article' => 11), array('role' => 'correcteur') ); // utilisera le rôle par défaut objet_dissocier( array('auteur' => 3), array('article' => 11) ); // enlèvera tous les rôles objet_dissocier( array('auteur' => 3), array('article' => 11), array('role' => '*') ); ``` Le formulaire d'édition de liens n'utilisera pas les mêmes squelettes de liaison lorsqu'une colonne de rôle est déclarée. Ainsi dans cet exemple, au lieu de `prive/objets/liste/auteurs_lies.html` et `auteurs_associer.html`, cela utiliserait `prive/objets/liste/auteurs_roles_lies.html` et `auteurs_roles_associer.html`. Il faut donc créer ces squelettes. Ces squelettes peuvent poster les valeurs au formulaire pour insérer de nouveaux liens, de la forme `qualifier_lien[auteur-3-article-11][role]` en postant `redacteur` par exemple. Il est possible au passage de poster en plus d'autres valeurs, qui seront intégrées dans l'enregistrement du lien. Ainsi, poster en même temps `qualifier_lien[auteur-3-article-11][valeur]` = `50` enregistrera la valeur 50 dans la colonne `valeur` de la table de lien (qui doit exister !). D'autres informations sont présentes dans http://contrib.spip.net/Des-roles-sur-des-liens, http://zone.spip.org/trac/spip-zone/browser/_plugins_/roles_auteurs ou encore http://zone.spip.org/trac/spip-zone/browser/_plugins_/roles
7 years ago
Intégration dans SPIP de la possibilité de gérer des liens entre objets avec des rôles. On intègre l'API présente actuellement dans le plugin Rôles, en modifiant un peu les fonctions d'édition de liens. Celles-ci permettent maintenant d'éditer des liens ayant donc des rôles. Ces différents rôles et le nom de la colonne SQL qui les reçoit, s'ils sont utilisés, doivent être déclarés avec la déclaration de l'objet éditorial correspondant. Un exemple est donné avec le plugin «Roles auteurs» qui définit quelques rôles. Les champs décrivant les rôles : `roles_colonne`, `roles_titres` et `roles_objets` doivent être déclarés (via le pipeline declarer_tables_objets_sql). ``` "roles_colonne" => "role", "roles_titres" => array( 'redacteur' => 'info_statut_redacteur', 'traducteur' => 'roles_auteurs:traducteur', 'correcteur' => 'roles_auteurs:correcteur', 'relecteur' => 'roles_auteurs:relecteur', ), "roles_objets" => array( 'articles' => array( 'choix' => array('redacteur', 'traducteur', 'correcteur', 'relecteur'), 'defaut' => 'redacteur' ) #'*' => array() ) ``` Une fois déclaré, on peut appeler les fonctions d'édition de lien en transmettant des valeurs de rôles, tel que : ``` objet_associer( array('auteur' => 3), array('article' => 11), array('role' => 'correcteur') ); // utilisera le rôle par défaut objet_associer( array('auteur' => 3), array('article' => 11) ); ``` Si aucun rôle n'est indiqué, le rôle par défaut est appliqué. Dans le cas d'une dissociation également, si aucun rôle n'est indiqué, seuls les liaisons avec le rôle par défaut seront supprimés ; pour supprimer tous les rôles, il faut à ce moment là indiquer '*' : ``` objet_dissocier( array('auteur' => 3), array('article' => 11), array('role' => 'correcteur') ); // utilisera le rôle par défaut objet_dissocier( array('auteur' => 3), array('article' => 11) ); // enlèvera tous les rôles objet_dissocier( array('auteur' => 3), array('article' => 11), array('role' => '*') ); ``` Le formulaire d'édition de liens n'utilisera pas les mêmes squelettes de liaison lorsqu'une colonne de rôle est déclarée. Ainsi dans cet exemple, au lieu de `prive/objets/liste/auteurs_lies.html` et `auteurs_associer.html`, cela utiliserait `prive/objets/liste/auteurs_roles_lies.html` et `auteurs_roles_associer.html`. Il faut donc créer ces squelettes. Ces squelettes peuvent poster les valeurs au formulaire pour insérer de nouveaux liens, de la forme `qualifier_lien[auteur-3-article-11][role]` en postant `redacteur` par exemple. Il est possible au passage de poster en plus d'autres valeurs, qui seront intégrées dans l'enregistrement du lien. Ainsi, poster en même temps `qualifier_lien[auteur-3-article-11][valeur]` = `50` enregistrera la valeur 50 dans la colonne `valeur` de la table de lien (qui doit exister !). D'autres informations sont présentes dans http://contrib.spip.net/Des-roles-sur-des-liens, http://zone.spip.org/trac/spip-zone/browser/_plugins_/roles_auteurs ou encore http://zone.spip.org/trac/spip-zone/browser/_plugins_/roles
7 years ago
Intégration dans SPIP de la possibilité de gérer des liens entre objets avec des rôles. On intègre l'API présente actuellement dans le plugin Rôles, en modifiant un peu les fonctions d'édition de liens. Celles-ci permettent maintenant d'éditer des liens ayant donc des rôles. Ces différents rôles et le nom de la colonne SQL qui les reçoit, s'ils sont utilisés, doivent être déclarés avec la déclaration de l'objet éditorial correspondant. Un exemple est donné avec le plugin «Roles auteurs» qui définit quelques rôles. Les champs décrivant les rôles : `roles_colonne`, `roles_titres` et `roles_objets` doivent être déclarés (via le pipeline declarer_tables_objets_sql). ``` "roles_colonne" => "role", "roles_titres" => array( 'redacteur' => 'info_statut_redacteur', 'traducteur' => 'roles_auteurs:traducteur', 'correcteur' => 'roles_auteurs:correcteur', 'relecteur' => 'roles_auteurs:relecteur', ), "roles_objets" => array( 'articles' => array( 'choix' => array('redacteur', 'traducteur', 'correcteur', 'relecteur'), 'defaut' => 'redacteur' ) #'*' => array() ) ``` Une fois déclaré, on peut appeler les fonctions d'édition de lien en transmettant des valeurs de rôles, tel que : ``` objet_associer( array('auteur' => 3), array('article' => 11), array('role' => 'correcteur') ); // utilisera le rôle par défaut objet_associer( array('auteur' => 3), array('article' => 11) ); ``` Si aucun rôle n'est indiqué, le rôle par défaut est appliqué. Dans le cas d'une dissociation également, si aucun rôle n'est indiqué, seuls les liaisons avec le rôle par défaut seront supprimés ; pour supprimer tous les rôles, il faut à ce moment là indiquer '*' : ``` objet_dissocier( array('auteur' => 3), array('article' => 11), array('role' => 'correcteur') ); // utilisera le rôle par défaut objet_dissocier( array('auteur' => 3), array('article' => 11) ); // enlèvera tous les rôles objet_dissocier( array('auteur' => 3), array('article' => 11), array('role' => '*') ); ``` Le formulaire d'édition de liens n'utilisera pas les mêmes squelettes de liaison lorsqu'une colonne de rôle est déclarée. Ainsi dans cet exemple, au lieu de `prive/objets/liste/auteurs_lies.html` et `auteurs_associer.html`, cela utiliserait `prive/objets/liste/auteurs_roles_lies.html` et `auteurs_roles_associer.html`. Il faut donc créer ces squelettes. Ces squelettes peuvent poster les valeurs au formulaire pour insérer de nouveaux liens, de la forme `qualifier_lien[auteur-3-article-11][role]` en postant `redacteur` par exemple. Il est possible au passage de poster en plus d'autres valeurs, qui seront intégrées dans l'enregistrement du lien. Ainsi, poster en même temps `qualifier_lien[auteur-3-article-11][valeur]` = `50` enregistrera la valeur 50 dans la colonne `valeur` de la table de lien (qui doit exister !). D'autres informations sont présentes dans http://contrib.spip.net/Des-roles-sur-des-liens, http://zone.spip.org/trac/spip-zone/browser/_plugins_/roles_auteurs ou encore http://zone.spip.org/trac/spip-zone/browser/_plugins_/roles
7 years ago
Intégration dans SPIP de la possibilité de gérer des liens entre objets avec des rôles. On intègre l'API présente actuellement dans le plugin Rôles, en modifiant un peu les fonctions d'édition de liens. Celles-ci permettent maintenant d'éditer des liens ayant donc des rôles. Ces différents rôles et le nom de la colonne SQL qui les reçoit, s'ils sont utilisés, doivent être déclarés avec la déclaration de l'objet éditorial correspondant. Un exemple est donné avec le plugin «Roles auteurs» qui définit quelques rôles. Les champs décrivant les rôles : `roles_colonne`, `roles_titres` et `roles_objets` doivent être déclarés (via le pipeline declarer_tables_objets_sql). ``` "roles_colonne" => "role", "roles_titres" => array( 'redacteur' => 'info_statut_redacteur', 'traducteur' => 'roles_auteurs:traducteur', 'correcteur' => 'roles_auteurs:correcteur', 'relecteur' => 'roles_auteurs:relecteur', ), "roles_objets" => array( 'articles' => array( 'choix' => array('redacteur', 'traducteur', 'correcteur', 'relecteur'), 'defaut' => 'redacteur' ) #'*' => array() ) ``` Une fois déclaré, on peut appeler les fonctions d'édition de lien en transmettant des valeurs de rôles, tel que : ``` objet_associer( array('auteur' => 3), array('article' => 11), array('role' => 'correcteur') ); // utilisera le rôle par défaut objet_associer( array('auteur' => 3), array('article' => 11) ); ``` Si aucun rôle n'est indiqué, le rôle par défaut est appliqué. Dans le cas d'une dissociation également, si aucun rôle n'est indiqué, seuls les liaisons avec le rôle par défaut seront supprimés ; pour supprimer tous les rôles, il faut à ce moment là indiquer '*' : ``` objet_dissocier( array('auteur' => 3), array('article' => 11), array('role' => 'correcteur') ); // utilisera le rôle par défaut objet_dissocier( array('auteur' => 3), array('article' => 11) ); // enlèvera tous les rôles objet_dissocier( array('auteur' => 3), array('article' => 11), array('role' => '*') ); ``` Le formulaire d'édition de liens n'utilisera pas les mêmes squelettes de liaison lorsqu'une colonne de rôle est déclarée. Ainsi dans cet exemple, au lieu de `prive/objets/liste/auteurs_lies.html` et `auteurs_associer.html`, cela utiliserait `prive/objets/liste/auteurs_roles_lies.html` et `auteurs_roles_associer.html`. Il faut donc créer ces squelettes. Ces squelettes peuvent poster les valeurs au formulaire pour insérer de nouveaux liens, de la forme `qualifier_lien[auteur-3-article-11][role]` en postant `redacteur` par exemple. Il est possible au passage de poster en plus d'autres valeurs, qui seront intégrées dans l'enregistrement du lien. Ainsi, poster en même temps `qualifier_lien[auteur-3-article-11][valeur]` = `50` enregistrera la valeur 50 dans la colonne `valeur` de la table de lien (qui doit exister !). D'autres informations sont présentes dans http://contrib.spip.net/Des-roles-sur-des-liens, http://zone.spip.org/trac/spip-zone/browser/_plugins_/roles_auteurs ou encore http://zone.spip.org/trac/spip-zone/browser/_plugins_/roles
7 years ago
Intégration dans SPIP de la possibilité de gérer des liens entre objets avec des rôles. On intègre l'API présente actuellement dans le plugin Rôles, en modifiant un peu les fonctions d'édition de liens. Celles-ci permettent maintenant d'éditer des liens ayant donc des rôles. Ces différents rôles et le nom de la colonne SQL qui les reçoit, s'ils sont utilisés, doivent être déclarés avec la déclaration de l'objet éditorial correspondant. Un exemple est donné avec le plugin «Roles auteurs» qui définit quelques rôles. Les champs décrivant les rôles : `roles_colonne`, `roles_titres` et `roles_objets` doivent être déclarés (via le pipeline declarer_tables_objets_sql). ``` "roles_colonne" => "role", "roles_titres" => array( 'redacteur' => 'info_statut_redacteur', 'traducteur' => 'roles_auteurs:traducteur', 'correcteur' => 'roles_auteurs:correcteur', 'relecteur' => 'roles_auteurs:relecteur', ), "roles_objets" => array( 'articles' => array( 'choix' => array('redacteur', 'traducteur', 'correcteur', 'relecteur'), 'defaut' => 'redacteur' ) #'*' => array() ) ``` Une fois déclaré, on peut appeler les fonctions d'édition de lien en transmettant des valeurs de rôles, tel que : ``` objet_associer( array('auteur' => 3), array('article' => 11), array('role' => 'correcteur') ); // utilisera le rôle par défaut objet_associer( array('auteur' => 3), array('article' => 11) ); ``` Si aucun rôle n'est indiqué, le rôle par défaut est appliqué. Dans le cas d'une dissociation également, si aucun rôle n'est indiqué, seuls les liaisons avec le rôle par défaut seront supprimés ; pour supprimer tous les rôles, il faut à ce moment là indiquer '*' : ``` objet_dissocier( array('auteur' => 3), array('article' => 11), array('role' => 'correcteur') ); // utilisera le rôle par défaut objet_dissocier( array('auteur' => 3), array('article' => 11) ); // enlèvera tous les rôles objet_dissocier( array('auteur' => 3), array('article' => 11), array('role' => '*') ); ``` Le formulaire d'édition de liens n'utilisera pas les mêmes squelettes de liaison lorsqu'une colonne de rôle est déclarée. Ainsi dans cet exemple, au lieu de `prive/objets/liste/auteurs_lies.html` et `auteurs_associer.html`, cela utiliserait `prive/objets/liste/auteurs_roles_lies.html` et `auteurs_roles_associer.html`. Il faut donc créer ces squelettes. Ces squelettes peuvent poster les valeurs au formulaire pour insérer de nouveaux liens, de la forme `qualifier_lien[auteur-3-article-11][role]` en postant `redacteur` par exemple. Il est possible au passage de poster en plus d'autres valeurs, qui seront intégrées dans l'enregistrement du lien. Ainsi, poster en même temps `qualifier_lien[auteur-3-article-11][valeur]` = `50` enregistrera la valeur 50 dans la colonne `valeur` de la table de lien (qui doit exister !). D'autres informations sont présentes dans http://contrib.spip.net/Des-roles-sur-des-liens, http://zone.spip.org/trac/spip-zone/browser/_plugins_/roles_auteurs ou encore http://zone.spip.org/trac/spip-zone/browser/_plugins_/roles
7 years ago
Intégration dans SPIP de la possibilité de gérer des liens entre objets avec des rôles. On intègre l'API présente actuellement dans le plugin Rôles, en modifiant un peu les fonctions d'édition de liens. Celles-ci permettent maintenant d'éditer des liens ayant donc des rôles. Ces différents rôles et le nom de la colonne SQL qui les reçoit, s'ils sont utilisés, doivent être déclarés avec la déclaration de l'objet éditorial correspondant. Un exemple est donné avec le plugin «Roles auteurs» qui définit quelques rôles. Les champs décrivant les rôles : `roles_colonne`, `roles_titres` et `roles_objets` doivent être déclarés (via le pipeline declarer_tables_objets_sql). ``` "roles_colonne" => "role", "roles_titres" => array( 'redacteur' => 'info_statut_redacteur', 'traducteur' => 'roles_auteurs:traducteur', 'correcteur' => 'roles_auteurs:correcteur', 'relecteur' => 'roles_auteurs:relecteur', ), "roles_objets" => array( 'articles' => array( 'choix' => array('redacteur', 'traducteur', 'correcteur', 'relecteur'), 'defaut' => 'redacteur' ) #'*' => array() ) ``` Une fois déclaré, on peut appeler les fonctions d'édition de lien en transmettant des valeurs de rôles, tel que : ``` objet_associer( array('auteur' => 3), array('article' => 11), array('role' => 'correcteur') ); // utilisera le rôle par défaut objet_associer( array('auteur' => 3), array('article' => 11) ); ``` Si aucun rôle n'est indiqué, le rôle par défaut est appliqué. Dans le cas d'une dissociation également, si aucun rôle n'est indiqué, seuls les liaisons avec le rôle par défaut seront supprimés ; pour supprimer tous les rôles, il faut à ce moment là indiquer '*' : ``` objet_dissocier( array('auteur' => 3), array('article' => 11), array('role' => 'correcteur') ); // utilisera le rôle par défaut objet_dissocier( array('auteur' => 3), array('article' => 11) ); // enlèvera tous les rôles objet_dissocier( array('auteur' => 3), array('article' => 11), array('role' => '*') ); ``` Le formulaire d'édition de liens n'utilisera pas les mêmes squelettes de liaison lorsqu'une colonne de rôle est déclarée. Ainsi dans cet exemple, au lieu de `prive/objets/liste/auteurs_lies.html` et `auteurs_associer.html`, cela utiliserait `prive/objets/liste/auteurs_roles_lies.html` et `auteurs_roles_associer.html`. Il faut donc créer ces squelettes. Ces squelettes peuvent poster les valeurs au formulaire pour insérer de nouveaux liens, de la forme `qualifier_lien[auteur-3-article-11][role]` en postant `redacteur` par exemple. Il est possible au passage de poster en plus d'autres valeurs, qui seront intégrées dans l'enregistrement du lien. Ainsi, poster en même temps `qualifier_lien[auteur-3-article-11][valeur]` = `50` enregistrera la valeur 50 dans la colonne `valeur` de la table de lien (qui doit exister !). D'autres informations sont présentes dans http://contrib.spip.net/Des-roles-sur-des-liens, http://zone.spip.org/trac/spip-zone/browser/_plugins_/roles_auteurs ou encore http://zone.spip.org/trac/spip-zone/browser/_plugins_/roles
7 years ago
Intégration dans SPIP de la possibilité de gérer des liens entre objets avec des rôles. On intègre l'API présente actuellement dans le plugin Rôles, en modifiant un peu les fonctions d'édition de liens. Celles-ci permettent maintenant d'éditer des liens ayant donc des rôles. Ces différents rôles et le nom de la colonne SQL qui les reçoit, s'ils sont utilisés, doivent être déclarés avec la déclaration de l'objet éditorial correspondant. Un exemple est donné avec le plugin «Roles auteurs» qui définit quelques rôles. Les champs décrivant les rôles : `roles_colonne`, `roles_titres` et `roles_objets` doivent être déclarés (via le pipeline declarer_tables_objets_sql). ``` "roles_colonne" => "role", "roles_titres" => array( 'redacteur' => 'info_statut_redacteur', 'traducteur' => 'roles_auteurs:traducteur', 'correcteur' => 'roles_auteurs:correcteur', 'relecteur' => 'roles_auteurs:relecteur', ), "roles_objets" => array( 'articles' => array( 'choix' => array('redacteur', 'traducteur', 'correcteur', 'relecteur'), 'defaut' => 'redacteur' ) #'*' => array() ) ``` Une fois déclaré, on peut appeler les fonctions d'édition de lien en transmettant des valeurs de rôles, tel que : ``` objet_associer( array('auteur' => 3), array('article' => 11), array('role' => 'correcteur') ); // utilisera le rôle par défaut objet_associer( array('auteur' => 3), array('article' => 11) ); ``` Si aucun rôle n'est indiqué, le rôle par défaut est appliqué. Dans le cas d'une dissociation également, si aucun rôle n'est indiqué, seuls les liaisons avec le rôle par défaut seront supprimés ; pour supprimer tous les rôles, il faut à ce moment là indiquer '*' : ``` objet_dissocier( array('auteur' => 3), array('article' => 11), array('role' => 'correcteur') ); // utilisera le rôle par défaut objet_dissocier( array('auteur' => 3), array('article' => 11) ); // enlèvera tous les rôles objet_dissocier( array('auteur' => 3), array('article' => 11), array('role' => '*') ); ``` Le formulaire d'édition de liens n'utilisera pas les mêmes squelettes de liaison lorsqu'une colonne de rôle est déclarée. Ainsi dans cet exemple, au lieu de `prive/objets/liste/auteurs_lies.html` et `auteurs_associer.html`, cela utiliserait `prive/objets/liste/auteurs_roles_lies.html` et `auteurs_roles_associer.html`. Il faut donc créer ces squelettes. Ces squelettes peuvent poster les valeurs au formulaire pour insérer de nouveaux liens, de la forme `qualifier_lien[auteur-3-article-11][role]` en postant `redacteur` par exemple. Il est possible au passage de poster en plus d'autres valeurs, qui seront intégrées dans l'enregistrement du lien. Ainsi, poster en même temps `qualifier_lien[auteur-3-article-11][valeur]` = `50` enregistrera la valeur 50 dans la colonne `valeur` de la table de lien (qui doit exister !). D'autres informations sont présentes dans http://contrib.spip.net/Des-roles-sur-des-liens, http://zone.spip.org/trac/spip-zone/browser/_plugins_/roles_auteurs ou encore http://zone.spip.org/trac/spip-zone/browser/_plugins_/roles
7 years ago
Intégration dans SPIP de la possibilité de gérer des liens entre objets avec des rôles. On intègre l'API présente actuellement dans le plugin Rôles, en modifiant un peu les fonctions d'édition de liens. Celles-ci permettent maintenant d'éditer des liens ayant donc des rôles. Ces différents rôles et le nom de la colonne SQL qui les reçoit, s'ils sont utilisés, doivent être déclarés avec la déclaration de l'objet éditorial correspondant. Un exemple est donné avec le plugin «Roles auteurs» qui définit quelques rôles. Les champs décrivant les rôles : `roles_colonne`, `roles_titres` et `roles_objets` doivent être déclarés (via le pipeline declarer_tables_objets_sql). ``` "roles_colonne" => "role", "roles_titres" => array( 'redacteur' => 'info_statut_redacteur', 'traducteur' => 'roles_auteurs:traducteur', 'correcteur' => 'roles_auteurs:correcteur', 'relecteur' => 'roles_auteurs:relecteur', ), "roles_objets" => array( 'articles' => array( 'choix' => array('redacteur', 'traducteur', 'correcteur', 'relecteur'), 'defaut' => 'redacteur' ) #'*' => array() ) ``` Une fois déclaré, on peut appeler les fonctions d'édition de lien en transmettant des valeurs de rôles, tel que : ``` objet_associer( array('auteur' => 3), array('article' => 11), array('role' => 'correcteur') ); // utilisera le rôle par défaut objet_associer( array('auteur' => 3), array('article' => 11) ); ``` Si aucun rôle n'est indiqué, le rôle par défaut est appliqué. Dans le cas d'une dissociation également, si aucun rôle n'est indiqué, seuls les liaisons avec le rôle par défaut seront supprimés ; pour supprimer tous les rôles, il faut à ce moment là indiquer '*' : ``` objet_dissocier( array('auteur' => 3), array('article' => 11), array('role' => 'correcteur') ); // utilisera le rôle par défaut objet_dissocier( array('auteur' => 3), array('article' => 11) ); // enlèvera tous les rôles objet_dissocier( array('auteur' => 3), array('article' => 11), array('role' => '*') ); ``` Le formulaire d'édition de liens n'utilisera pas les mêmes squelettes de liaison lorsqu'une colonne de rôle est déclarée. Ainsi dans cet exemple, au lieu de `prive/objets/liste/auteurs_lies.html` et `auteurs_associer.html`, cela utiliserait `prive/objets/liste/auteurs_roles_lies.html` et `auteurs_roles_associer.html`. Il faut donc créer ces squelettes. Ces squelettes peuvent poster les valeurs au formulaire pour insérer de nouveaux liens, de la forme `qualifier_lien[auteur-3-article-11][role]` en postant `redacteur` par exemple. Il est possible au passage de poster en plus d'autres valeurs, qui seront intégrées dans l'enregistrement du lien. Ainsi, poster en même temps `qualifier_lien[auteur-3-article-11][valeur]` = `50` enregistrera la valeur 50 dans la colonne `valeur` de la table de lien (qui doit exister !). D'autres informations sont présentes dans http://contrib.spip.net/Des-roles-sur-des-liens, http://zone.spip.org/trac/spip-zone/browser/_plugins_/roles_auteurs ou encore http://zone.spip.org/trac/spip-zone/browser/_plugins_/roles
7 years ago
Intégration dans SPIP de la possibilité de gérer des liens entre objets avec des rôles. On intègre l'API présente actuellement dans le plugin Rôles, en modifiant un peu les fonctions d'édition de liens. Celles-ci permettent maintenant d'éditer des liens ayant donc des rôles. Ces différents rôles et le nom de la colonne SQL qui les reçoit, s'ils sont utilisés, doivent être déclarés avec la déclaration de l'objet éditorial correspondant. Un exemple est donné avec le plugin «Roles auteurs» qui définit quelques rôles. Les champs décrivant les rôles : `roles_colonne`, `roles_titres` et `roles_objets` doivent être déclarés (via le pipeline declarer_tables_objets_sql). ``` "roles_colonne" => "role", "roles_titres" => array( 'redacteur' => 'info_statut_redacteur', 'traducteur' => 'roles_auteurs:traducteur', 'correcteur' => 'roles_auteurs:correcteur', 'relecteur' => 'roles_auteurs:relecteur', ), "roles_objets" => array( 'articles' => array( 'choix' => array('redacteur', 'traducteur', 'correcteur', 'relecteur'), 'defaut' => 'redacteur' ) #'*' => array() ) ``` Une fois déclaré, on peut appeler les fonctions d'édition de lien en transmettant des valeurs de rôles, tel que : ``` objet_associer( array('auteur' => 3), array('article' => 11), array('role' => 'correcteur') ); // utilisera le rôle par défaut objet_associer( array('auteur' => 3), array('article' => 11) ); ``` Si aucun rôle n'est indiqué, le rôle par défaut est appliqué. Dans le cas d'une dissociation également, si aucun rôle n'est indiqué, seuls les liaisons avec le rôle par défaut seront supprimés ; pour supprimer tous les rôles, il faut à ce moment là indiquer '*' : ``` objet_dissocier( array('auteur' => 3), array('article' => 11), array('role' => 'correcteur') ); // utilisera le rôle par défaut objet_dissocier( array('auteur' => 3), array('article' => 11) ); // enlèvera tous les rôles objet_dissocier( array('auteur' => 3), array('article' => 11), array('role' => '*') ); ``` Le formulaire d'édition de liens n'utilisera pas les mêmes squelettes de liaison lorsqu'une colonne de rôle est déclarée. Ainsi dans cet exemple, au lieu de `prive/objets/liste/auteurs_lies.html` et `auteurs_associer.html`, cela utiliserait `prive/objets/liste/auteurs_roles_lies.html` et `auteurs_roles_associer.html`. Il faut donc créer ces squelettes. Ces squelettes peuvent poster les valeurs au formulaire pour insérer de nouveaux liens, de la forme `qualifier_lien[auteur-3-article-11][role]` en postant `redacteur` par exemple. Il est possible au passage de poster en plus d'autres valeurs, qui seront intégrées dans l'enregistrement du lien. Ainsi, poster en même temps `qualifier_lien[auteur-3-article-11][valeur]` = `50` enregistrera la valeur 50 dans la colonne `valeur` de la table de lien (qui doit exister !). D'autres informations sont présentes dans http://contrib.spip.net/Des-roles-sur-des-liens, http://zone.spip.org/trac/spip-zone/browser/_plugins_/roles_auteurs ou encore http://zone.spip.org/trac/spip-zone/browser/_plugins_/roles
7 years ago
Intégration dans SPIP de la possibilité de gérer des liens entre objets avec des rôles. On intègre l'API présente actuellement dans le plugin Rôles, en modifiant un peu les fonctions d'édition de liens. Celles-ci permettent maintenant d'éditer des liens ayant donc des rôles. Ces différents rôles et le nom de la colonne SQL qui les reçoit, s'ils sont utilisés, doivent être déclarés avec la déclaration de l'objet éditorial correspondant. Un exemple est donné avec le plugin «Roles auteurs» qui définit quelques rôles. Les champs décrivant les rôles : `roles_colonne`, `roles_titres` et `roles_objets` doivent être déclarés (via le pipeline declarer_tables_objets_sql). ``` "roles_colonne" => "role", "roles_titres" => array( 'redacteur' => 'info_statut_redacteur', 'traducteur' => 'roles_auteurs:traducteur', 'correcteur' => 'roles_auteurs:correcteur', 'relecteur' => 'roles_auteurs:relecteur', ), "roles_objets" => array( 'articles' => array( 'choix' => array('redacteur', 'traducteur', 'correcteur', 'relecteur'), 'defaut' => 'redacteur' ) #'*' => array() ) ``` Une fois déclaré, on peut appeler les fonctions d'édition de lien en transmettant des valeurs de rôles, tel que : ``` objet_associer( array('auteur' => 3), array('article' => 11), array('role' => 'correcteur') ); // utilisera le rôle par défaut objet_associer( array('auteur' => 3), array('article' => 11) ); ``` Si aucun rôle n'est indiqué, le rôle par défaut est appliqué. Dans le cas d'une dissociation également, si aucun rôle n'est indiqué, seuls les liaisons avec le rôle par défaut seront supprimés ; pour supprimer tous les rôles, il faut à ce moment là indiquer '*' : ``` objet_dissocier( array('auteur' => 3), array('article' => 11), array('role' => 'correcteur') ); // utilisera le rôle par défaut objet_dissocier( array('auteur' => 3), array('article' => 11) ); // enlèvera tous les rôles objet_dissocier( array('auteur' => 3), array('article' => 11), array('role' => '*') ); ``` Le formulaire d'édition de liens n'utilisera pas les mêmes squelettes de liaison lorsqu'une colonne de rôle est déclarée. Ainsi dans cet exemple, au lieu de `prive/objets/liste/auteurs_lies.html` et `auteurs_associer.html`, cela utiliserait `prive/objets/liste/auteurs_roles_lies.html` et `auteurs_roles_associer.html`. Il faut donc créer ces squelettes. Ces squelettes peuvent poster les valeurs au formulaire pour insérer de nouveaux liens, de la forme `qualifier_lien[auteur-3-article-11][role]` en postant `redacteur` par exemple. Il est possible au passage de poster en plus d'autres valeurs, qui seront intégrées dans l'enregistrement du lien. Ainsi, poster en même temps `qualifier_lien[auteur-3-article-11][valeur]` = `50` enregistrera la valeur 50 dans la colonne `valeur` de la table de lien (qui doit exister !). D'autres informations sont présentes dans http://contrib.spip.net/Des-roles-sur-des-liens, http://zone.spip.org/trac/spip-zone/browser/_plugins_/roles_auteurs ou encore http://zone.spip.org/trac/spip-zone/browser/_plugins_/roles
7 years ago
Intégration dans SPIP de la possibilité de gérer des liens entre objets avec des rôles. On intègre l'API présente actuellement dans le plugin Rôles, en modifiant un peu les fonctions d'édition de liens. Celles-ci permettent maintenant d'éditer des liens ayant donc des rôles. Ces différents rôles et le nom de la colonne SQL qui les reçoit, s'ils sont utilisés, doivent être déclarés avec la déclaration de l'objet éditorial correspondant. Un exemple est donné avec le plugin «Roles auteurs» qui définit quelques rôles. Les champs décrivant les rôles : `roles_colonne`, `roles_titres` et `roles_objets` doivent être déclarés (via le pipeline declarer_tables_objets_sql). ``` "roles_colonne" => "role", "roles_titres" => array( 'redacteur' => 'info_statut_redacteur', 'traducteur' => 'roles_auteurs:traducteur', 'correcteur' => 'roles_auteurs:correcteur', 'relecteur' => 'roles_auteurs:relecteur', ), "roles_objets" => array( 'articles' => array( 'choix' => array('redacteur', 'traducteur', 'correcteur', 'relecteur'), 'defaut' => 'redacteur' ) #'*' => array() ) ``` Une fois déclaré, on peut appeler les fonctions d'édition de lien en transmettant des valeurs de rôles, tel que : ``` objet_associer( array('auteur' => 3), array('article' => 11), array('role' => 'correcteur') ); // utilisera le rôle par défaut objet_associer( array('auteur' => 3), array('article' => 11) ); ``` Si aucun rôle n'est indiqué, le rôle par défaut est appliqué. Dans le cas d'une dissociation également, si aucun rôle n'est indiqué, seuls les liaisons avec le rôle par défaut seront supprimés ; pour supprimer tous les rôles, il faut à ce moment là indiquer '*' : ``` objet_dissocier( array('auteur' => 3), array('article' => 11), array('role' => 'correcteur') ); // utilisera le rôle par défaut objet_dissocier( array('auteur' => 3), array('article' => 11) ); // enlèvera tous les rôles objet_dissocier( array('auteur' => 3), array('article' => 11), array('role' => '*') ); ``` Le formulaire d'édition de liens n'utilisera pas les mêmes squelettes de liaison lorsqu'une colonne de rôle est déclarée. Ainsi dans cet exemple, au lieu de `prive/objets/liste/auteurs_lies.html` et `auteurs_associer.html`, cela utiliserait `prive/objets/liste/auteurs_roles_lies.html` et `auteurs_roles_associer.html`. Il faut donc créer ces squelettes. Ces squelettes peuvent poster les valeurs au formulaire pour insérer de nouveaux liens, de la forme `qualifier_lien[auteur-3-article-11][role]` en postant `redacteur` par exemple. Il est possible au passage de poster en plus d'autres valeurs, qui seront intégrées dans l'enregistrement du lien. Ainsi, poster en même temps `qualifier_lien[auteur-3-article-11][valeur]` = `50` enregistrera la valeur 50 dans la colonne `valeur` de la table de lien (qui doit exister !). D'autres informations sont présentes dans http://contrib.spip.net/Des-roles-sur-des-liens, http://zone.spip.org/trac/spip-zone/browser/_plugins_/roles_auteurs ou encore http://zone.spip.org/trac/spip-zone/browser/_plugins_/roles
7 years ago
Intégration dans SPIP de la possibilité de gérer des liens entre objets avec des rôles. On intègre l'API présente actuellement dans le plugin Rôles, en modifiant un peu les fonctions d'édition de liens. Celles-ci permettent maintenant d'éditer des liens ayant donc des rôles. Ces différents rôles et le nom de la colonne SQL qui les reçoit, s'ils sont utilisés, doivent être déclarés avec la déclaration de l'objet éditorial correspondant. Un exemple est donné avec le plugin «Roles auteurs» qui définit quelques rôles. Les champs décrivant les rôles : `roles_colonne`, `roles_titres` et `roles_objets` doivent être déclarés (via le pipeline declarer_tables_objets_sql). ``` "roles_colonne" => "role", "roles_titres" => array( 'redacteur' => 'info_statut_redacteur', 'traducteur' => 'roles_auteurs:traducteur', 'correcteur' => 'roles_auteurs:correcteur', 'relecteur' => 'roles_auteurs:relecteur', ), "roles_objets" => array( 'articles' => array( 'choix' => array('redacteur', 'traducteur', 'correcteur', 'relecteur'), 'defaut' => 'redacteur' ) #'*' => array() ) ``` Une fois déclaré, on peut appeler les fonctions d'édition de lien en transmettant des valeurs de rôles, tel que : ``` objet_associer( array('auteur' => 3), array('article' => 11), array('role' => 'correcteur') ); // utilisera le rôle par défaut objet_associer( array('auteur' => 3), array('article' => 11) ); ``` Si aucun rôle n'est indiqué, le rôle par défaut est appliqué. Dans le cas d'une dissociation également, si aucun rôle n'est indiqué, seuls les liaisons avec le rôle par défaut seront supprimés ; pour supprimer tous les rôles, il faut à ce moment là indiquer '*' : ``` objet_dissocier( array('auteur' => 3), array('article' => 11), array('role' => 'correcteur') ); // utilisera le rôle par défaut objet_dissocier( array('auteur' => 3), array('article' => 11) ); // enlèvera tous les rôles objet_dissocier( array('auteur' => 3), array('article' => 11), array('role' => '*') ); ``` Le formulaire d'édition de liens n'utilisera pas les mêmes squelettes de liaison lorsqu'une colonne de rôle est déclarée. Ainsi dans cet exemple, au lieu de `prive/objets/liste/auteurs_lies.html` et `auteurs_associer.html`, cela utiliserait `prive/objets/liste/auteurs_roles_lies.html` et `auteurs_roles_associer.html`. Il faut donc créer ces squelettes. Ces squelettes peuvent poster les valeurs au formulaire pour insérer de nouveaux liens, de la forme `qualifier_lien[auteur-3-article-11][role]` en postant `redacteur` par exemple. Il est possible au passage de poster en plus d'autres valeurs, qui seront intégrées dans l'enregistrement du lien. Ainsi, poster en même temps `qualifier_lien[auteur-3-article-11][valeur]` = `50` enregistrera la valeur 50 dans la colonne `valeur` de la table de lien (qui doit exister !). D'autres informations sont présentes dans http://contrib.spip.net/Des-roles-sur-des-liens, http://zone.spip.org/trac/spip-zone/browser/_plugins_/roles_auteurs ou encore http://zone.spip.org/trac/spip-zone/browser/_plugins_/roles
7 years ago
Intégration dans SPIP de la possibilité de gérer des liens entre objets avec des rôles. On intègre l'API présente actuellement dans le plugin Rôles, en modifiant un peu les fonctions d'édition de liens. Celles-ci permettent maintenant d'éditer des liens ayant donc des rôles. Ces différents rôles et le nom de la colonne SQL qui les reçoit, s'ils sont utilisés, doivent être déclarés avec la déclaration de l'objet éditorial correspondant. Un exemple est donné avec le plugin «Roles auteurs» qui définit quelques rôles. Les champs décrivant les rôles : `roles_colonne`, `roles_titres` et `roles_objets` doivent être déclarés (via le pipeline declarer_tables_objets_sql). ``` "roles_colonne" => "role", "roles_titres" => array( 'redacteur' => 'info_statut_redacteur', 'traducteur' => 'roles_auteurs:traducteur', 'correcteur' => 'roles_auteurs:correcteur', 'relecteur' => 'roles_auteurs:relecteur', ), "roles_objets" => array( 'articles' => array( 'choix' => array('redacteur', 'traducteur', 'correcteur', 'relecteur'), 'defaut' => 'redacteur' ) #'*' => array() ) ``` Une fois déclaré, on peut appeler les fonctions d'édition de lien en transmettant des valeurs de rôles, tel que : ``` objet_associer( array('auteur' => 3), array('article' => 11), array('role' => 'correcteur') ); // utilisera le rôle par défaut objet_associer( array('auteur' => 3), array('article' => 11) ); ``` Si aucun rôle n'est indiqué, le rôle par défaut est appliqué. Dans le cas d'une dissociation également, si aucun rôle n'est indiqué, seuls les liaisons avec le rôle par défaut seront supprimés ; pour supprimer tous les rôles, il faut à ce moment là indiquer '*' : ``` objet_dissocier( array('auteur' => 3), array('article' => 11), array('role' => 'correcteur') ); // utilisera le rôle par défaut objet_dissocier( array('auteur' => 3), array('article' => 11) ); // enlèvera tous les rôles objet_dissocier( array('auteur' => 3), array('article' => 11), array('role' => '*') ); ``` Le formulaire d'édition de liens n'utilisera pas les mêmes squelettes de liaison lorsqu'une colonne de rôle est déclarée. Ainsi dans cet exemple, au lieu de `prive/objets/liste/auteurs_lies.html` et `auteurs_associer.html`, cela utiliserait `prive/objets/liste/auteurs_roles_lies.html` et `auteurs_roles_associer.html`. Il faut donc créer ces squelettes. Ces squelettes peuvent poster les valeurs au formulaire pour insérer de nouveaux liens, de la forme `qualifier_lien[auteur-3-article-11][role]` en postant `redacteur` par exemple. Il est possible au passage de poster en plus d'autres valeurs, qui seront intégrées dans l'enregistrement du lien. Ainsi, poster en même temps `qualifier_lien[auteur-3-article-11][valeur]` = `50` enregistrera la valeur 50 dans la colonne `valeur` de la table de lien (qui doit exister !). D'autres informations sont présentes dans http://contrib.spip.net/Des-roles-sur-des-liens, http://zone.spip.org/trac/spip-zone/browser/_plugins_/roles_auteurs ou encore http://zone.spip.org/trac/spip-zone/browser/_plugins_/roles
7 years ago
Intégration dans SPIP de la possibilité de gérer des liens entre objets avec des rôles. On intègre l'API présente actuellement dans le plugin Rôles, en modifiant un peu les fonctions d'édition de liens. Celles-ci permettent maintenant d'éditer des liens ayant donc des rôles. Ces différents rôles et le nom de la colonne SQL qui les reçoit, s'ils sont utilisés, doivent être déclarés avec la déclaration de l'objet éditorial correspondant. Un exemple est donné avec le plugin «Roles auteurs» qui définit quelques rôles. Les champs décrivant les rôles : `roles_colonne`, `roles_titres` et `roles_objets` doivent être déclarés (via le pipeline declarer_tables_objets_sql). ``` "roles_colonne" => "role", "roles_titres" => array( 'redacteur' => 'info_statut_redacteur', 'traducteur' => 'roles_auteurs:traducteur', 'correcteur' => 'roles_auteurs:correcteur', 'relecteur' => 'roles_auteurs:relecteur', ), "roles_objets" => array( 'articles' => array( 'choix' => array('redacteur', 'traducteur', 'correcteur', 'relecteur'), 'defaut' => 'redacteur' ) #'*' => array() ) ``` Une fois déclaré, on peut appeler les fonctions d'édition de lien en transmettant des valeurs de rôles, tel que : ``` objet_associer( array('auteur' => 3), array('article' => 11), array('role' => 'correcteur') ); // utilisera le rôle par défaut objet_associer( array('auteur' => 3), array('article' => 11) ); ``` Si aucun rôle n'est indiqué, le rôle par défaut est appliqué. Dans le cas d'une dissociation également, si aucun rôle n'est indiqué, seuls les liaisons avec le rôle par défaut seront supprimés ; pour supprimer tous les rôles, il faut à ce moment là indiquer '*' : ``` objet_dissocier( array('auteur' => 3), array('article' => 11), array('role' => 'correcteur') ); // utilisera le rôle par défaut objet_dissocier( array('auteur' => 3), array('article' => 11) ); // enlèvera tous les rôles objet_dissocier( array('auteur' => 3), array('article' => 11), array('role' => '*') ); ``` Le formulaire d'édition de liens n'utilisera pas les mêmes squelettes de liaison lorsqu'une colonne de rôle est déclarée. Ainsi dans cet exemple, au lieu de `prive/objets/liste/auteurs_lies.html` et `auteurs_associer.html`, cela utiliserait `prive/objets/liste/auteurs_roles_lies.html` et `auteurs_roles_associer.html`. Il faut donc créer ces squelettes. Ces squelettes peuvent poster les valeurs au formulaire pour insérer de nouveaux liens, de la forme `qualifier_lien[auteur-3-article-11][role]` en postant `redacteur` par exemple. Il est possible au passage de poster en plus d'autres valeurs, qui seront intégrées dans l'enregistrement du lien. Ainsi, poster en même temps `qualifier_lien[auteur-3-article-11][valeur]` = `50` enregistrera la valeur 50 dans la colonne `valeur` de la table de lien (qui doit exister !). D'autres informations sont présentes dans http://contrib.spip.net/Des-roles-sur-des-liens, http://zone.spip.org/trac/spip-zone/browser/_plugins_/roles_auteurs ou encore http://zone.spip.org/trac/spip-zone/browser/_plugins_/roles
7 years ago
Intégration dans SPIP de la possibilité de gérer des liens entre objets avec des rôles. On intègre l'API présente actuellement dans le plugin Rôles, en modifiant un peu les fonctions d'édition de liens. Celles-ci permettent maintenant d'éditer des liens ayant donc des rôles. Ces différents rôles et le nom de la colonne SQL qui les reçoit, s'ils sont utilisés, doivent être déclarés avec la déclaration de l'objet éditorial correspondant. Un exemple est donné avec le plugin «Roles auteurs» qui définit quelques rôles. Les champs décrivant les rôles : `roles_colonne`, `roles_titres` et `roles_objets` doivent être déclarés (via le pipeline declarer_tables_objets_sql). ``` "roles_colonne" => "role", "roles_titres" => array( 'redacteur' => 'info_statut_redacteur', 'traducteur' => 'roles_auteurs:traducteur', 'correcteur' => 'roles_auteurs:correcteur', 'relecteur' => 'roles_auteurs:relecteur', ), "roles_objets" => array( 'articles' => array( 'choix' => array('redacteur', 'traducteur', 'correcteur', 'relecteur'), 'defaut' => 'redacteur' ) #'*' => array() ) ``` Une fois déclaré, on peut appeler les fonctions d'édition de lien en transmettant des valeurs de rôles, tel que : ``` objet_associer( array('auteur' => 3), array('article' => 11), array('role' => 'correcteur') ); // utilisera le rôle par défaut objet_associer( array('auteur' => 3), array('article' => 11) ); ``` Si aucun rôle n'est indiqué, le rôle par défaut est appliqué. Dans le cas d'une dissociation également, si aucun rôle n'est indiqué, seuls les liaisons avec le rôle par défaut seront supprimés ; pour supprimer tous les rôles, il faut à ce moment là indiquer '*' : ``` objet_dissocier( array('auteur' => 3), array('article' => 11), array('role' => 'correcteur') ); // utilisera le rôle par défaut objet_dissocier( array('auteur' => 3), array('article' => 11) ); // enlèvera tous les rôles objet_dissocier( array('auteur' => 3), array('article' => 11), array('role' => '*') ); ``` Le formulaire d'édition de liens n'utilisera pas les mêmes squelettes de liaison lorsqu'une colonne de rôle est déclarée. Ainsi dans cet exemple, au lieu de `prive/objets/liste/auteurs_lies.html` et `auteurs_associer.html`, cela utiliserait `prive/objets/liste/auteurs_roles_lies.html` et `auteurs_roles_associer.html`. Il faut donc créer ces squelettes. Ces squelettes peuvent poster les valeurs au formulaire pour insérer de nouveaux liens, de la forme `qualifier_lien[auteur-3-article-11][role]` en postant `redacteur` par exemple. Il est possible au passage de poster en plus d'autres valeurs, qui seront intégrées dans l'enregistrement du lien. Ainsi, poster en même temps `qualifier_lien[auteur-3-article-11][valeur]` = `50` enregistrera la valeur 50 dans la colonne `valeur` de la table de lien (qui doit exister !). D'autres informations sont présentes dans http://contrib.spip.net/Des-roles-sur-des-liens, http://zone.spip.org/trac/spip-zone/browser/_plugins_/roles_auteurs ou encore http://zone.spip.org/trac/spip-zone/browser/_plugins_/roles
7 years ago
Intégration dans SPIP de la possibilité de gérer des liens entre objets avec des rôles. On intègre l'API présente actuellement dans le plugin Rôles, en modifiant un peu les fonctions d'édition de liens. Celles-ci permettent maintenant d'éditer des liens ayant donc des rôles. Ces différents rôles et le nom de la colonne SQL qui les reçoit, s'ils sont utilisés, doivent être déclarés avec la déclaration de l'objet éditorial correspondant. Un exemple est donné avec le plugin «Roles auteurs» qui définit quelques rôles. Les champs décrivant les rôles : `roles_colonne`, `roles_titres` et `roles_objets` doivent être déclarés (via le pipeline declarer_tables_objets_sql). ``` "roles_colonne" => "role", "roles_titres" => array( 'redacteur' => 'info_statut_redacteur', 'traducteur' => 'roles_auteurs:traducteur', 'correcteur' => 'roles_auteurs:correcteur', 'relecteur' => 'roles_auteurs:relecteur', ), "roles_objets" => array( 'articles' => array( 'choix' => array('redacteur', 'traducteur', 'correcteur', 'relecteur'), 'defaut' => 'redacteur' ) #'*' => array() ) ``` Une fois déclaré, on peut appeler les fonctions d'édition de lien en transmettant des valeurs de rôles, tel que : ``` objet_associer( array('auteur' => 3), array('article' => 11), array('role' => 'correcteur') ); // utilisera le rôle par défaut objet_associer( array('auteur' => 3), array('article' => 11) ); ``` Si aucun rôle n'est indiqué, le rôle par défaut est appliqué. Dans le cas d'une dissociation également, si aucun rôle n'est indiqué, seuls les liaisons avec le rôle par défaut seront supprimés ; pour supprimer tous les rôles, il faut à ce moment là indiquer '*' : ``` objet_dissocier( array('auteur' => 3), array('article' => 11), array('role' => 'correcteur') ); // utilisera le rôle par défaut objet_dissocier( array('auteur' => 3), array('article' => 11) ); // enlèvera tous les rôles objet_dissocier( array('auteur' => 3), array('article' => 11), array('role' => '*') ); ``` Le formulaire d'édition de liens n'utilisera pas les mêmes squelettes de liaison lorsqu'une colonne de rôle est déclarée. Ainsi dans cet exemple, au lieu de `prive/objets/liste/auteurs_lies.html` et `auteurs_associer.html`, cela utiliserait `prive/objets/liste/auteurs_roles_lies.html` et `auteurs_roles_associer.html`. Il faut donc créer ces squelettes. Ces squelettes peuvent poster les valeurs au formulaire pour insérer de nouveaux liens, de la forme `qualifier_lien[auteur-3-article-11][role]` en postant `redacteur` par exemple. Il est possible au passage de poster en plus d'autres valeurs, qui seront intégrées dans l'enregistrement du lien. Ainsi, poster en même temps `qualifier_lien[auteur-3-article-11][valeur]` = `50` enregistrera la valeur 50 dans la colonne `valeur` de la table de lien (qui doit exister !). D'autres informations sont présentes dans http://contrib.spip.net/Des-roles-sur-des-liens, http://zone.spip.org/trac/spip-zone/browser/_plugins_/roles_auteurs ou encore http://zone.spip.org/trac/spip-zone/browser/_plugins_/roles
7 years ago
Intégration dans SPIP de la possibilité de gérer des liens entre objets avec des rôles. On intègre l'API présente actuellement dans le plugin Rôles, en modifiant un peu les fonctions d'édition de liens. Celles-ci permettent maintenant d'éditer des liens ayant donc des rôles. Ces différents rôles et le nom de la colonne SQL qui les reçoit, s'ils sont utilisés, doivent être déclarés avec la déclaration de l'objet éditorial correspondant. Un exemple est donné avec le plugin «Roles auteurs» qui définit quelques rôles. Les champs décrivant les rôles : `roles_colonne`, `roles_titres` et `roles_objets` doivent être déclarés (via le pipeline declarer_tables_objets_sql). ``` "roles_colonne" => "role", "roles_titres" => array( 'redacteur' => 'info_statut_redacteur', 'traducteur' => 'roles_auteurs:traducteur', 'correcteur' => 'roles_auteurs:correcteur', 'relecteur' => 'roles_auteurs:relecteur', ), "roles_objets" => array( 'articles' => array( 'choix' => array('redacteur', 'traducteur', 'correcteur', 'relecteur'), 'defaut' => 'redacteur' ) #'*' => array() ) ``` Une fois déclaré, on peut appeler les fonctions d'édition de lien en transmettant des valeurs de rôles, tel que : ``` objet_associer( array('auteur' => 3), array('article' => 11), array('role' => 'correcteur') ); // utilisera le rôle par défaut objet_associer( array('auteur' => 3), array('article' => 11) ); ``` Si aucun rôle n'est indiqué, le rôle par défaut est appliqué. Dans le cas d'une dissociation également, si aucun rôle n'est indiqué, seuls les liaisons avec le rôle par défaut seront supprimés ; pour supprimer tous les rôles, il faut à ce moment là indiquer '*' : ``` objet_dissocier( array('auteur' => 3), array('article' => 11), array('role' => 'correcteur') ); // utilisera le rôle par défaut objet_dissocier( array('auteur' => 3), array('article' => 11) ); // enlèvera tous les rôles objet_dissocier( array('auteur' => 3), array('article' => 11), array('role' => '*') ); ``` Le formulaire d'édition de liens n'utilisera pas les mêmes squelettes de liaison lorsqu'une colonne de rôle est déclarée. Ainsi dans cet exemple, au lieu de `prive/objets/liste/auteurs_lies.html` et `auteurs_associer.html`, cela utiliserait `prive/objets/liste/auteurs_roles_lies.html` et `auteurs_roles_associer.html`. Il faut donc créer ces squelettes. Ces squelettes peuvent poster les valeurs au formulaire pour insérer de nouveaux liens, de la forme `qualifier_lien[auteur-3-article-11][role]` en postant `redacteur` par exemple. Il est possible au passage de poster en plus d'autres valeurs, qui seront intégrées dans l'enregistrement du lien. Ainsi, poster en même temps `qualifier_lien[auteur-3-article-11][valeur]` = `50` enregistrera la valeur 50 dans la colonne `valeur` de la table de lien (qui doit exister !). D'autres informations sont présentes dans http://contrib.spip.net/Des-roles-sur-des-liens, http://zone.spip.org/trac/spip-zone/browser/_plugins_/roles_auteurs ou encore http://zone.spip.org/trac/spip-zone/browser/_plugins_/roles
7 years ago
Intégration dans SPIP de la possibilité de gérer des liens entre objets avec des rôles. On intègre l'API présente actuellement dans le plugin Rôles, en modifiant un peu les fonctions d'édition de liens. Celles-ci permettent maintenant d'éditer des liens ayant donc des rôles. Ces différents rôles et le nom de la colonne SQL qui les reçoit, s'ils sont utilisés, doivent être déclarés avec la déclaration de l'objet éditorial correspondant. Un exemple est donné avec le plugin «Roles auteurs» qui définit quelques rôles. Les champs décrivant les rôles : `roles_colonne`, `roles_titres` et `roles_objets` doivent être déclarés (via le pipeline declarer_tables_objets_sql). ``` "roles_colonne" => "role", "roles_titres" => array( 'redacteur' => 'info_statut_redacteur', 'traducteur' => 'roles_auteurs:traducteur', 'correcteur' => 'roles_auteurs:correcteur', 'relecteur' => 'roles_auteurs:relecteur', ), "roles_objets" => array( 'articles' => array( 'choix' => array('redacteur', 'traducteur', 'correcteur', 'relecteur'), 'defaut' => 'redacteur' ) #'*' => array() ) ``` Une fois déclaré, on peut appeler les fonctions d'édition de lien en transmettant des valeurs de rôles, tel que : ``` objet_associer( array('auteur' => 3), array('article' => 11), array('role' => 'correcteur') ); // utilisera le rôle par défaut objet_associer( array('auteur' => 3), array('article' => 11) ); ``` Si aucun rôle n'est indiqué, le rôle par défaut est appliqué. Dans le cas d'une dissociation également, si aucun rôle n'est indiqué, seuls les liaisons avec le rôle par défaut seront supprimés ; pour supprimer tous les rôles, il faut à ce moment là indiquer '*' : ``` objet_dissocier( array('auteur' => 3), array('article' => 11), array('role' => 'correcteur') ); // utilisera le rôle par défaut objet_dissocier( array('auteur' => 3), array('article' => 11) ); // enlèvera tous les rôles objet_dissocier( array('auteur' => 3), array('article' => 11), array('role' => '*') ); ``` Le formulaire d'édition de liens n'utilisera pas les mêmes squelettes de liaison lorsqu'une colonne de rôle est déclarée. Ainsi dans cet exemple, au lieu de `prive/objets/liste/auteurs_lies.html` et `auteurs_associer.html`, cela utiliserait `prive/objets/liste/auteurs_roles_lies.html` et `auteurs_roles_associer.html`. Il faut donc créer ces squelettes. Ces squelettes peuvent poster les valeurs au formulaire pour insérer de nouveaux liens, de la forme `qualifier_lien[auteur-3-article-11][role]` en postant `redacteur` par exemple. Il est possible au passage de poster en plus d'autres valeurs, qui seront intégrées dans l'enregistrement du lien. Ainsi, poster en même temps `qualifier_lien[auteur-3-article-11][valeur]` = `50` enregistrera la valeur 50 dans la colonne `valeur` de la table de lien (qui doit exister !). D'autres informations sont présentes dans http://contrib.spip.net/Des-roles-sur-des-liens, http://zone.spip.org/trac/spip-zone/browser/_plugins_/roles_auteurs ou encore http://zone.spip.org/trac/spip-zone/browser/_plugins_/roles
7 years ago
Intégration dans SPIP de la possibilité de gérer des liens entre objets avec des rôles. On intègre l'API présente actuellement dans le plugin Rôles, en modifiant un peu les fonctions d'édition de liens. Celles-ci permettent maintenant d'éditer des liens ayant donc des rôles. Ces différents rôles et le nom de la colonne SQL qui les reçoit, s'ils sont utilisés, doivent être déclarés avec la déclaration de l'objet éditorial correspondant. Un exemple est donné avec le plugin «Roles auteurs» qui définit quelques rôles. Les champs décrivant les rôles : `roles_colonne`, `roles_titres` et `roles_objets` doivent être déclarés (via le pipeline declarer_tables_objets_sql). ``` "roles_colonne" => "role", "roles_titres" => array( 'redacteur' => 'info_statut_redacteur', 'traducteur' => 'roles_auteurs:traducteur', 'correcteur' => 'roles_auteurs:correcteur', 'relecteur' => 'roles_auteurs:relecteur', ), "roles_objets" => array( 'articles' => array( 'choix' => array('redacteur', 'traducteur', 'correcteur', 'relecteur'), 'defaut' => 'redacteur' ) #'*' => array() ) ``` Une fois déclaré, on peut appeler les fonctions d'édition de lien en transmettant des valeurs de rôles, tel que : ``` objet_associer( array('auteur' => 3), array('article' => 11), array('role' => 'correcteur') ); // utilisera le rôle par défaut objet_associer( array('auteur' => 3), array('article' => 11) ); ``` Si aucun rôle n'est indiqué, le rôle par défaut est appliqué. Dans le cas d'une dissociation également, si aucun rôle n'est indiqué, seuls les liaisons avec le rôle par défaut seront supprimés ; pour supprimer tous les rôles, il faut à ce moment là indiquer '*' : ``` objet_dissocier( array('auteur' => 3), array('article' => 11), array('role' => 'correcteur') ); // utilisera le rôle par défaut objet_dissocier( array('auteur' => 3), array('article' => 11) ); // enlèvera tous les rôles objet_dissocier( array('auteur' => 3), array('article' => 11), array('role' => '*') ); ``` Le formulaire d'édition de liens n'utilisera pas les mêmes squelettes de liaison lorsqu'une colonne de rôle est déclarée. Ainsi dans cet exemple, au lieu de `prive/objets/liste/auteurs_lies.html` et `auteurs_associer.html`, cela utiliserait `prive/objets/liste/auteurs_roles_lies.html` et `auteurs_roles_associer.html`. Il faut donc créer ces squelettes. Ces squelettes peuvent poster les valeurs au formulaire pour insérer de nouveaux liens, de la forme `qualifier_lien[auteur-3-article-11][role]` en postant `redacteur` par exemple. Il est possible au passage de poster en plus d'autres valeurs, qui seront intégrées dans l'enregistrement du lien. Ainsi, poster en même temps `qualifier_lien[auteur-3-article-11][valeur]` = `50` enregistrera la valeur 50 dans la colonne `valeur` de la table de lien (qui doit exister !). D'autres informations sont présentes dans http://contrib.spip.net/Des-roles-sur-des-liens, http://zone.spip.org/trac/spip-zone/browser/_plugins_/roles_auteurs ou encore http://zone.spip.org/trac/spip-zone/browser/_plugins_/roles
7 years ago
Intégration dans SPIP de la possibilité de gérer des liens entre objets avec des rôles. On intègre l'API présente actuellement dans le plugin Rôles, en modifiant un peu les fonctions d'édition de liens. Celles-ci permettent maintenant d'éditer des liens ayant donc des rôles. Ces différents rôles et le nom de la colonne SQL qui les reçoit, s'ils sont utilisés, doivent être déclarés avec la déclaration de l'objet éditorial correspondant. Un exemple est donné avec le plugin «Roles auteurs» qui définit quelques rôles. Les champs décrivant les rôles : `roles_colonne`, `roles_titres` et `roles_objets` doivent être déclarés (via le pipeline declarer_tables_objets_sql). ``` "roles_colonne" => "role", "roles_titres" => array( 'redacteur' => 'info_statut_redacteur', 'traducteur' => 'roles_auteurs:traducteur', 'correcteur' => 'roles_auteurs:correcteur', 'relecteur' => 'roles_auteurs:relecteur', ), "roles_objets" => array( 'articles' => array( 'choix' => array('redacteur', 'traducteur', 'correcteur', 'relecteur'), 'defaut' => 'redacteur' ) #'*' => array() ) ``` Une fois déclaré, on peut appeler les fonctions d'édition de lien en transmettant des valeurs de rôles, tel que : ``` objet_associer( array('auteur' => 3), array('article' => 11), array('role' => 'correcteur') ); // utilisera le rôle par défaut objet_associer( array('auteur' => 3), array('article' => 11) ); ``` Si aucun rôle n'est indiqué, le rôle par défaut est appliqué. Dans le cas d'une dissociation également, si aucun rôle n'est indiqué, seuls les liaisons avec le rôle par défaut seront supprimés ; pour supprimer tous les rôles, il faut à ce moment là indiquer '*' : ``` objet_dissocier( array('auteur' => 3), array('article' => 11), array('role' => 'correcteur') ); // utilisera le rôle par défaut objet_dissocier( array('auteur' => 3), array('article' => 11) ); // enlèvera tous les rôles objet_dissocier( array('auteur' => 3), array('article' => 11), array('role' => '*') ); ``` Le formulaire d'édition de liens n'utilisera pas les mêmes squelettes de liaison lorsqu'une colonne de rôle est déclarée. Ainsi dans cet exemple, au lieu de `prive/objets/liste/auteurs_lies.html` et `auteurs_associer.html`, cela utiliserait `prive/objets/liste/auteurs_roles_lies.html` et `auteurs_roles_associer.html`. Il faut donc créer ces squelettes. Ces squelettes peuvent poster les valeurs au formulaire pour insérer de nouveaux liens, de la forme `qualifier_lien[auteur-3-article-11][role]` en postant `redacteur` par exemple. Il est possible au passage de poster en plus d'autres valeurs, qui seront intégrées dans l'enregistrement du lien. Ainsi, poster en même temps `qualifier_lien[auteur-3-article-11][valeur]` = `50` enregistrera la valeur 50 dans la colonne `valeur` de la table de lien (qui doit exister !). D'autres informations sont présentes dans http://contrib.spip.net/Des-roles-sur-des-liens, http://zone.spip.org/trac/spip-zone/browser/_plugins_/roles_auteurs ou encore http://zone.spip.org/trac/spip-zone/browser/_plugins_/roles
7 years ago
Intégration dans SPIP de la possibilité de gérer des liens entre objets avec des rôles. On intègre l'API présente actuellement dans le plugin Rôles, en modifiant un peu les fonctions d'édition de liens. Celles-ci permettent maintenant d'éditer des liens ayant donc des rôles. Ces différents rôles et le nom de la colonne SQL qui les reçoit, s'ils sont utilisés, doivent être déclarés avec la déclaration de l'objet éditorial correspondant. Un exemple est donné avec le plugin «Roles auteurs» qui définit quelques rôles. Les champs décrivant les rôles : `roles_colonne`, `roles_titres` et `roles_objets` doivent être déclarés (via le pipeline declarer_tables_objets_sql). ``` "roles_colonne" => "role", "roles_titres" => array( 'redacteur' => 'info_statut_redacteur', 'traducteur' => 'roles_auteurs:traducteur', 'correcteur' => 'roles_auteurs:correcteur', 'relecteur' => 'roles_auteurs:relecteur', ), "roles_objets" => array( 'articles' => array( 'choix' => array('redacteur', 'traducteur', 'correcteur', 'relecteur'), 'defaut' => 'redacteur' ) #'*' => array() ) ``` Une fois déclaré, on peut appeler les fonctions d'édition de lien en transmettant des valeurs de rôles, tel que : ``` objet_associer( array('auteur' => 3), array('article' => 11), array('role' => 'correcteur') ); // utilisera le rôle par défaut objet_associer( array('auteur' => 3), array('article' => 11) ); ``` Si aucun rôle n'est indiqué, le rôle par défaut est appliqué. Dans le cas d'une dissociation également, si aucun rôle n'est indiqué, seuls les liaisons avec le rôle par défaut seront supprimés ; pour supprimer tous les rôles, il faut à ce moment là indiquer '*' : ``` objet_dissocier( array('auteur' => 3), array('article' => 11), array('role' => 'correcteur') ); // utilisera le rôle par défaut objet_dissocier( array('auteur' => 3), array('article' => 11) ); // enlèvera tous les rôles objet_dissocier( array('auteur' => 3), array('article' => 11), array('role' => '*') ); ``` Le formulaire d'édition de liens n'utilisera pas les mêmes squelettes de liaison lorsqu'une colonne de rôle est déclarée. Ainsi dans cet exemple, au lieu de `prive/objets/liste/auteurs_lies.html` et `auteurs_associer.html`, cela utiliserait `prive/objets/liste/auteurs_roles_lies.html` et `auteurs_roles_associer.html`. Il faut donc créer ces squelettes. Ces squelettes peuvent poster les valeurs au formulaire pour insérer de nouveaux liens, de la forme `qualifier_lien[auteur-3-article-11][role]` en postant `redacteur` par exemple. Il est possible au passage de poster en plus d'autres valeurs, qui seront intégrées dans l'enregistrement du lien. Ainsi, poster en même temps `qualifier_lien[auteur-3-article-11][valeur]` = `50` enregistrera la valeur 50 dans la colonne `valeur` de la table de lien (qui doit exister !). D'autres informations sont présentes dans http://contrib.spip.net/Des-roles-sur-des-liens, http://zone.spip.org/trac/spip-zone/browser/_plugins_/roles_auteurs ou encore http://zone.spip.org/trac/spip-zone/browser/_plugins_/roles
7 years ago
Intégration dans SPIP de la possibilité de gérer des liens entre objets avec des rôles. On intègre l'API présente actuellement dans le plugin Rôles, en modifiant un peu les fonctions d'édition de liens. Celles-ci permettent maintenant d'éditer des liens ayant donc des rôles. Ces différents rôles et le nom de la colonne SQL qui les reçoit, s'ils sont utilisés, doivent être déclarés avec la déclaration de l'objet éditorial correspondant. Un exemple est donné avec le plugin «Roles auteurs» qui définit quelques rôles. Les champs décrivant les rôles : `roles_colonne`, `roles_titres` et `roles_objets` doivent être déclarés (via le pipeline declarer_tables_objets_sql). ``` "roles_colonne" => "role", "roles_titres" => array( 'redacteur' => 'info_statut_redacteur', 'traducteur' => 'roles_auteurs:traducteur', 'correcteur' => 'roles_auteurs:correcteur', 'relecteur' => 'roles_auteurs:relecteur', ), "roles_objets" => array( 'articles' => array( 'choix' => array('redacteur', 'traducteur', 'correcteur', 'relecteur'), 'defaut' => 'redacteur' ) #'*' => array() ) ``` Une fois déclaré, on peut appeler les fonctions d'édition de lien en transmettant des valeurs de rôles, tel que : ``` objet_associer( array('auteur' => 3), array('article' => 11), array('role' => 'correcteur') ); // utilisera le rôle par défaut objet_associer( array('auteur' => 3), array('article' => 11) ); ``` Si aucun rôle n'est indiqué, le rôle par défaut est appliqué. Dans le cas d'une dissociation également, si aucun rôle n'est indiqué, seuls les liaisons avec le rôle par défaut seront supprimés ; pour supprimer tous les rôles, il faut à ce moment là indiquer '*' : ``` objet_dissocier( array('auteur' => 3), array('article' => 11), array('role' => 'correcteur') ); // utilisera le rôle par défaut objet_dissocier( array('auteur' => 3), array('article' => 11) ); // enlèvera tous les rôles objet_dissocier( array('auteur' => 3), array('article' => 11), array('role' => '*') ); ``` Le formulaire d'édition de liens n'utilisera pas les mêmes squelettes de liaison lorsqu'une colonne de rôle est déclarée. Ainsi dans cet exemple, au lieu de `prive/objets/liste/auteurs_lies.html` et `auteurs_associer.html`, cela utiliserait `prive/objets/liste/auteurs_roles_lies.html` et `auteurs_roles_associer.html`. Il faut donc créer ces squelettes. Ces squelettes peuvent poster les valeurs au formulaire pour insérer de nouveaux liens, de la forme `qualifier_lien[auteur-3-article-11][role]` en postant `redacteur` par exemple. Il est possible au passage de poster en plus d'autres valeurs, qui seront intégrées dans l'enregistrement du lien. Ainsi, poster en même temps `qualifier_lien[auteur-3-article-11][valeur]` = `50` enregistrera la valeur 50 dans la colonne `valeur` de la table de lien (qui doit exister !). D'autres informations sont présentes dans http://contrib.spip.net/Des-roles-sur-des-liens, http://zone.spip.org/trac/spip-zone/browser/_plugins_/roles_auteurs ou encore http://zone.spip.org/trac/spip-zone/browser/_plugins_/roles
7 years ago
Intégration dans SPIP de la possibilité de gérer des liens entre objets avec des rôles. On intègre l'API présente actuellement dans le plugin Rôles, en modifiant un peu les fonctions d'édition de liens. Celles-ci permettent maintenant d'éditer des liens ayant donc des rôles. Ces différents rôles et le nom de la colonne SQL qui les reçoit, s'ils sont utilisés, doivent être déclarés avec la déclaration de l'objet éditorial correspondant. Un exemple est donné avec le plugin «Roles auteurs» qui définit quelques rôles. Les champs décrivant les rôles : `roles_colonne`, `roles_titres` et `roles_objets` doivent être déclarés (via le pipeline declarer_tables_objets_sql). ``` "roles_colonne" => "role", "roles_titres" => array( 'redacteur' => 'info_statut_redacteur', 'traducteur' => 'roles_auteurs:traducteur', 'correcteur' => 'roles_auteurs:correcteur', 'relecteur' => 'roles_auteurs:relecteur', ), "roles_objets" => array( 'articles' => array( 'choix' => array('redacteur', 'traducteur', 'correcteur', 'relecteur'), 'defaut' => 'redacteur' ) #'*' => array() ) ``` Une fois déclaré, on peut appeler les fonctions d'édition de lien en transmettant des valeurs de rôles, tel que : ``` objet_associer( array('auteur' => 3), array('article' => 11), array('role' => 'correcteur') ); // utilisera le rôle par défaut objet_associer( array('auteur' => 3), array('article' => 11) ); ``` Si aucun rôle n'est indiqué, le rôle par défaut est appliqué. Dans le cas d'une dissociation également, si aucun rôle n'est indiqué, seuls les liaisons avec le rôle par défaut seront supprimés ; pour supprimer tous les rôles, il faut à ce moment là indiquer '*' : ``` objet_dissocier( array('auteur' => 3), array('article' => 11), array('role' => 'correcteur') ); // utilisera le rôle par défaut objet_dissocier( array('auteur' => 3), array('article' => 11) ); // enlèvera tous les rôles objet_dissocier( array('auteur' => 3), array('article' => 11), array('role' => '*') ); ``` Le formulaire d'édition de liens n'utilisera pas les mêmes squelettes de liaison lorsqu'une colonne de rôle est déclarée. Ainsi dans cet exemple, au lieu de `prive/objets/liste/auteurs_lies.html` et `auteurs_associer.html`, cela utiliserait `prive/objets/liste/auteurs_roles_lies.html` et `auteurs_roles_associer.html`. Il faut donc créer ces squelettes. Ces squelettes peuvent poster les valeurs au formulaire pour insérer de nouveaux liens, de la forme `qualifier_lien[auteur-3-article-11][role]` en postant `redacteur` par exemple. Il est possible au passage de poster en plus d'autres valeurs, qui seront intégrées dans l'enregistrement du lien. Ainsi, poster en même temps `qualifier_lien[auteur-3-article-11][valeur]` = `50` enregistrera la valeur 50 dans la colonne `valeur` de la table de lien (qui doit exister !). D'autres informations sont présentes dans http://contrib.spip.net/Des-roles-sur-des-liens, http://zone.spip.org/trac/spip-zone/browser/_plugins_/roles_auteurs ou encore http://zone.spip.org/trac/spip-zone/browser/_plugins_/roles
7 years ago
Intégration dans SPIP de la possibilité de gérer des liens entre objets avec des rôles. On intègre l'API présente actuellement dans le plugin Rôles, en modifiant un peu les fonctions d'édition de liens. Celles-ci permettent maintenant d'éditer des liens ayant donc des rôles. Ces différents rôles et le nom de la colonne SQL qui les reçoit, s'ils sont utilisés, doivent être déclarés avec la déclaration de l'objet éditorial correspondant. Un exemple est donné avec le plugin «Roles auteurs» qui définit quelques rôles. Les champs décrivant les rôles : `roles_colonne`, `roles_titres` et `roles_objets` doivent être déclarés (via le pipeline declarer_tables_objets_sql). ``` "roles_colonne" => "role", "roles_titres" => array( 'redacteur' => 'info_statut_redacteur', 'traducteur' => 'roles_auteurs:traducteur', 'correcteur' => 'roles_auteurs:correcteur', 'relecteur' => 'roles_auteurs:relecteur', ), "roles_objets" => array( 'articles' => array( 'choix' => array('redacteur', 'traducteur', 'correcteur', 'relecteur'), 'defaut' => 'redacteur' ) #'*' => array() ) ``` Une fois déclaré, on peut appeler les fonctions d'édition de lien en transmettant des valeurs de rôles, tel que : ``` objet_associer( array('auteur' => 3), array('article' => 11), array('role' => 'correcteur') ); // utilisera le rôle par défaut objet_associer( array('auteur' => 3), array('article' => 11) ); ``` Si aucun rôle n'est indiqué, le rôle par défaut est appliqué. Dans le cas d'une dissociation également, si aucun rôle n'est indiqué, seuls les liaisons avec le rôle par défaut seront supprimés ; pour supprimer tous les rôles, il faut à ce moment là indiquer '*' : ``` objet_dissocier( array('auteur' => 3), array('article' => 11), array('role' => 'correcteur') ); // utilisera le rôle par défaut objet_dissocier( array('auteur' => 3), array('article' => 11) ); // enlèvera tous les rôles objet_dissocier( array('auteur' => 3), array('article' => 11), array('role' => '*') ); ``` Le formulaire d'édition de liens n'utilisera pas les mêmes squelettes de liaison lorsqu'une colonne de rôle est déclarée. Ainsi dans cet exemple, au lieu de `prive/objets/liste/auteurs_lies.html` et `auteurs_associer.html`, cela utiliserait `prive/objets/liste/auteurs_roles_lies.html` et `auteurs_roles_associer.html`. Il faut donc créer ces squelettes. Ces squelettes peuvent poster les valeurs au formulaire pour insérer de nouveaux liens, de la forme `qualifier_lien[auteur-3-article-11][role]` en postant `redacteur` par exemple. Il est possible au passage de poster en plus d'autres valeurs, qui seront intégrées dans l'enregistrement du lien. Ainsi, poster en même temps `qualifier_lien[auteur-3-article-11][valeur]` = `50` enregistrera la valeur 50 dans la colonne `valeur` de la table de lien (qui doit exister !). D'autres informations sont présentes dans http://contrib.spip.net/Des-roles-sur-des-liens, http://zone.spip.org/trac/spip-zone/browser/_plugins_/roles_auteurs ou encore http://zone.spip.org/trac/spip-zone/browser/_plugins_/roles
7 years ago
Intégration dans SPIP de la possibilité de gérer des liens entre objets avec des rôles. On intègre l'API présente actuellement dans le plugin Rôles, en modifiant un peu les fonctions d'édition de liens. Celles-ci permettent maintenant d'éditer des liens ayant donc des rôles. Ces différents rôles et le nom de la colonne SQL qui les reçoit, s'ils sont utilisés, doivent être déclarés avec la déclaration de l'objet éditorial correspondant. Un exemple est donné avec le plugin «Roles auteurs» qui définit quelques rôles. Les champs décrivant les rôles : `roles_colonne`, `roles_titres` et `roles_objets` doivent être déclarés (via le pipeline declarer_tables_objets_sql). ``` "roles_colonne" => "role", "roles_titres" => array( 'redacteur' => 'info_statut_redacteur', 'traducteur' => 'roles_auteurs:traducteur', 'correcteur' => 'roles_auteurs:correcteur', 'relecteur' => 'roles_auteurs:relecteur', ), "roles_objets" => array( 'articles' => array( 'choix' => array('redacteur', 'traducteur', 'correcteur', 'relecteur'), 'defaut' => 'redacteur' ) #'*' => array() ) ``` Une fois déclaré, on peut appeler les fonctions d'édition de lien en transmettant des valeurs de rôles, tel que : ``` objet_associer( array('auteur' => 3), array('article' => 11), array('role' => 'correcteur') ); // utilisera le rôle par défaut objet_associer( array('auteur' => 3), array('article' => 11) ); ``` Si aucun rôle n'est indiqué, le rôle par défaut est appliqué. Dans le cas d'une dissociation également, si aucun rôle n'est indiqué, seuls les liaisons avec le rôle par défaut seront supprimés ; pour supprimer tous les rôles, il faut à ce moment là indiquer '*' : ``` objet_dissocier( array('auteur' => 3), array('article' => 11), array('role' => 'correcteur') ); // utilisera le rôle par défaut objet_dissocier( array('auteur' => 3), array('article' => 11) ); // enlèvera tous les rôles objet_dissocier( array('auteur' => 3), array('article' => 11), array('role' => '*') ); ``` Le formulaire d'édition de liens n'utilisera pas les mêmes squelettes de liaison lorsqu'une colonne de rôle est déclarée. Ainsi dans cet exemple, au lieu de `prive/objets/liste/auteurs_lies.html` et `auteurs_associer.html`, cela utiliserait `prive/objets/liste/auteurs_roles_lies.html` et `auteurs_roles_associer.html`. Il faut donc créer ces squelettes. Ces squelettes peuvent poster les valeurs au formulaire pour insérer de nouveaux liens, de la forme `qualifier_lien[auteur-3-article-11][role]` en postant `redacteur` par exemple. Il est possible au passage de poster en plus d'autres valeurs, qui seront intégrées dans l'enregistrement du lien. Ainsi, poster en même temps `qualifier_lien[auteur-3-article-11][valeur]` = `50` enregistrera la valeur 50 dans la colonne `valeur` de la table de lien (qui doit exister !). D'autres informations sont présentes dans http://contrib.spip.net/Des-roles-sur-des-liens, http://zone.spip.org/trac/spip-zone/browser/_plugins_/roles_auteurs ou encore http://zone.spip.org/trac/spip-zone/browser/_plugins_/roles
7 years ago
Intégration dans SPIP de la possibilité de gérer des liens entre objets avec des rôles. On intègre l'API présente actuellement dans le plugin Rôles, en modifiant un peu les fonctions d'édition de liens. Celles-ci permettent maintenant d'éditer des liens ayant donc des rôles. Ces différents rôles et le nom de la colonne SQL qui les reçoit, s'ils sont utilisés, doivent être déclarés avec la déclaration de l'objet éditorial correspondant. Un exemple est donné avec le plugin «Roles auteurs» qui définit quelques rôles. Les champs décrivant les rôles : `roles_colonne`, `roles_titres` et `roles_objets` doivent être déclarés (via le pipeline declarer_tables_objets_sql). ``` "roles_colonne" => "role", "roles_titres" => array( 'redacteur' => 'info_statut_redacteur', 'traducteur' => 'roles_auteurs:traducteur', 'correcteur' => 'roles_auteurs:correcteur', 'relecteur' => 'roles_auteurs:relecteur', ), "roles_objets" => array( 'articles' => array( 'choix' => array('redacteur', 'traducteur', 'correcteur', 'relecteur'), 'defaut' => 'redacteur' ) #'*' => array() ) ``` Une fois déclaré, on peut appeler les fonctions d'édition de lien en transmettant des valeurs de rôles, tel que : ``` objet_associer( array('auteur' => 3), array('article' => 11), array('role' => 'correcteur') ); // utilisera le rôle par défaut objet_associer( array('auteur' => 3), array('article' => 11) ); ``` Si aucun rôle n'est indiqué, le rôle par défaut est appliqué. Dans le cas d'une dissociation également, si aucun rôle n'est indiqué, seuls les liaisons avec le rôle par défaut seront supprimés ; pour supprimer tous les rôles, il faut à ce moment là indiquer '*' : ``` objet_dissocier( array('auteur' => 3), array('article' => 11), array('role' => 'correcteur') ); // utilisera le rôle par défaut objet_dissocier( array('auteur' => 3), array('article' => 11) ); // enlèvera tous les rôles objet_dissocier( array('auteur' => 3), array('article' => 11), array('role' => '*') ); ``` Le formulaire d'édition de liens n'utilisera pas les mêmes squelettes de liaison lorsqu'une colonne de rôle est déclarée. Ainsi dans cet exemple, au lieu de `prive/objets/liste/auteurs_lies.html` et `auteurs_associer.html`, cela utiliserait `prive/objets/liste/auteurs_roles_lies.html` et `auteurs_roles_associer.html`. Il faut donc créer ces squelettes. Ces squelettes peuvent poster les valeurs au formulaire pour insérer de nouveaux liens, de la forme `qualifier_lien[auteur-3-article-11][role]` en postant `redacteur` par exemple. Il est possible au passage de poster en plus d'autres valeurs, qui seront intégrées dans l'enregistrement du lien. Ainsi, poster en même temps `qualifier_lien[auteur-3-article-11][valeur]` = `50` enregistrera la valeur 50 dans la colonne `valeur` de la table de lien (qui doit exister !). D'autres informations sont présentes dans http://contrib.spip.net/Des-roles-sur-des-liens, http://zone.spip.org/trac/spip-zone/browser/_plugins_/roles_auteurs ou encore http://zone.spip.org/trac/spip-zone/browser/_plugins_/roles
7 years ago
Intégration dans SPIP de la possibilité de gérer des liens entre objets avec des rôles. On intègre l'API présente actuellement dans le plugin Rôles, en modifiant un peu les fonctions d'édition de liens. Celles-ci permettent maintenant d'éditer des liens ayant donc des rôles. Ces différents rôles et le nom de la colonne SQL qui les reçoit, s'ils sont utilisés, doivent être déclarés avec la déclaration de l'objet éditorial correspondant. Un exemple est donné avec le plugin «Roles auteurs» qui définit quelques rôles. Les champs décrivant les rôles : `roles_colonne`, `roles_titres` et `roles_objets` doivent être déclarés (via le pipeline declarer_tables_objets_sql). ``` "roles_colonne" => "role", "roles_titres" => array( 'redacteur' => 'info_statut_redacteur', 'traducteur' => 'roles_auteurs:traducteur', 'correcteur' => 'roles_auteurs:correcteur', 'relecteur' => 'roles_auteurs:relecteur', ), "roles_objets" => array( 'articles' => array( 'choix' => array('redacteur', 'traducteur', 'correcteur', 'relecteur'), 'defaut' => 'redacteur' ) #'*' => array() ) ``` Une fois déclaré, on peut appeler les fonctions d'édition de lien en transmettant des valeurs de rôles, tel que : ``` objet_associer( array('auteur' => 3), array('article' => 11), array('role' => 'correcteur') ); // utilisera le rôle par défaut objet_associer( array('auteur' => 3), array('article' => 11) ); ``` Si aucun rôle n'est indiqué, le rôle par défaut est appliqué. Dans le cas d'une dissociation également, si aucun rôle n'est indiqué, seuls les liaisons avec le rôle par défaut seront supprimés ; pour supprimer tous les rôles, il faut à ce moment là indiquer '*' : ``` objet_dissocier( array('auteur' => 3), array('article' => 11), array('role' => 'correcteur') ); // utilisera le rôle par défaut objet_dissocier( array('auteur' => 3), array('article' => 11) ); // enlèvera tous les rôles objet_dissocier( array('auteur' => 3), array('article' => 11), array('role' => '*') ); ``` Le formulaire d'édition de liens n'utilisera pas les mêmes squelettes de liaison lorsqu'une colonne de rôle est déclarée. Ainsi dans cet exemple, au lieu de `prive/objets/liste/auteurs_lies.html` et `auteurs_associer.html`, cela utiliserait `prive/objets/liste/auteurs_roles_lies.html` et `auteurs_roles_associer.html`. Il faut donc créer ces squelettes. Ces squelettes peuvent poster les valeurs au formulaire pour insérer de nouveaux liens, de la forme `qualifier_lien[auteur-3-article-11][role]` en postant `redacteur` par exemple. Il est possible au passage de poster en plus d'autres valeurs, qui seront intégrées dans l'enregistrement du lien. Ainsi, poster en même temps `qualifier_lien[auteur-3-article-11][valeur]` = `50` enregistrera la valeur 50 dans la colonne `valeur` de la table de lien (qui doit exister !). D'autres informations sont présentes dans http://contrib.spip.net/Des-roles-sur-des-liens, http://zone.spip.org/trac/spip-zone/browser/_plugins_/roles_auteurs ou encore http://zone.spip.org/trac/spip-zone/browser/_plugins_/roles
7 years ago
Intégration dans SPIP de la possibilité de gérer des liens entre objets avec des rôles. On intègre l'API présente actuellement dans le plugin Rôles, en modifiant un peu les fonctions d'édition de liens. Celles-ci permettent maintenant d'éditer des liens ayant donc des rôles. Ces différents rôles et le nom de la colonne SQL qui les reçoit, s'ils sont utilisés, doivent être déclarés avec la déclaration de l'objet éditorial correspondant. Un exemple est donné avec le plugin «Roles auteurs» qui définit quelques rôles. Les champs décrivant les rôles : `roles_colonne`, `roles_titres` et `roles_objets` doivent être déclarés (via le pipeline declarer_tables_objets_sql). ``` "roles_colonne" => "role", "roles_titres" => array( 'redacteur' => 'info_statut_redacteur', 'traducteur' => 'roles_auteurs:traducteur', 'correcteur' => 'roles_auteurs:correcteur', 'relecteur' => 'roles_auteurs:relecteur', ), "roles_objets" => array( 'articles' => array( 'choix' => array('redacteur', 'traducteur', 'correcteur', 'relecteur'), 'defaut' => 'redacteur' ) #'*' => array() ) ``` Une fois déclaré, on peut appeler les fonctions d'édition de lien en transmettant des valeurs de rôles, tel que : ``` objet_associer( array('auteur' => 3), array('article' => 11), array('role' => 'correcteur') ); // utilisera le rôle par défaut objet_associer( array('auteur' => 3), array('article' => 11) ); ``` Si aucun rôle n'est indiqué, le rôle par défaut est appliqué. Dans le cas d'une dissociation également, si aucun rôle n'est indiqué, seuls les liaisons avec le rôle par défaut seront supprimés ; pour supprimer tous les rôles, il faut à ce moment là indiquer '*' : ``` objet_dissocier( array('auteur' => 3), array('article' => 11), array('role' => 'correcteur') ); // utilisera le rôle par défaut objet_dissocier( array('auteur' => 3), array('article' => 11) ); // enlèvera tous les rôles objet_dissocier( array('auteur' => 3), array('article' => 11), array('role' => '*') ); ``` Le formulaire d'édition de liens n'utilisera pas les mêmes squelettes de liaison lorsqu'une colonne de rôle est déclarée. Ainsi dans cet exemple, au lieu de `prive/objets/liste/auteurs_lies.html` et `auteurs_associer.html`, cela utiliserait `prive/objets/liste/auteurs_roles_lies.html` et `auteurs_roles_associer.html`. Il faut donc créer ces squelettes. Ces squelettes peuvent poster les valeurs au formulaire pour insérer de nouveaux liens, de la forme `qualifier_lien[auteur-3-article-11][role]` en postant `redacteur` par exemple. Il est possible au passage de poster en plus d'autres valeurs, qui seront intégrées dans l'enregistrement du lien. Ainsi, poster en même temps `qualifier_lien[auteur-3-article-11][valeur]` = `50` enregistrera la valeur 50 dans la colonne `valeur` de la table de lien (qui doit exister !). D'autres informations sont présentes dans http://contrib.spip.net/Des-roles-sur-des-liens, http://zone.spip.org/trac/spip-zone/browser/_plugins_/roles_auteurs ou encore http://zone.spip.org/trac/spip-zone/browser/_plugins_/roles
7 years ago
Intégration dans SPIP de la possibilité de gérer des liens entre objets avec des rôles. On intègre l'API présente actuellement dans le plugin Rôles, en modifiant un peu les fonctions d'édition de liens. Celles-ci permettent maintenant d'éditer des liens ayant donc des rôles. Ces différents rôles et le nom de la colonne SQL qui les reçoit, s'ils sont utilisés, doivent être déclarés avec la déclaration de l'objet éditorial correspondant. Un exemple est donné avec le plugin «Roles auteurs» qui définit quelques rôles. Les champs décrivant les rôles : `roles_colonne`, `roles_titres` et `roles_objets` doivent être déclarés (via le pipeline declarer_tables_objets_sql). ``` "roles_colonne" => "role", "roles_titres" => array( 'redacteur' => 'info_statut_redacteur', 'traducteur' => 'roles_auteurs:traducteur', 'correcteur' => 'roles_auteurs:correcteur', 'relecteur' => 'roles_auteurs:relecteur', ), "roles_objets" => array( 'articles' => array( 'choix' => array('redacteur', 'traducteur', 'correcteur', 'relecteur'), 'defaut' => 'redacteur' ) #'*' => array() ) ``` Une fois déclaré, on peut appeler les fonctions d'édition de lien en transmettant des valeurs de rôles, tel que : ``` objet_associer( array('auteur' => 3), array('article' => 11), array('role' => 'correcteur') ); // utilisera le rôle par défaut objet_associer( array('auteur' => 3), array('article' => 11) ); ``` Si aucun rôle n'est indiqué, le rôle par défaut est appliqué. Dans le cas d'une dissociation également, si aucun rôle n'est indiqué, seuls les liaisons avec le rôle par défaut seront supprimés ; pour supprimer tous les rôles, il faut à ce moment là indiquer '*' : ``` objet_dissocier( array('auteur' => 3), array('article' => 11), array('role' => 'correcteur') ); // utilisera le rôle par défaut objet_dissocier( array('auteur' => 3), array('article' => 11) ); // enlèvera tous les rôles objet_dissocier( array('auteur' => 3), array('article' => 11), array('role' => '*') ); ``` Le formulaire d'édition de liens n'utilisera pas les mêmes squelettes de liaison lorsqu'une colonne de rôle est déclarée. Ainsi dans cet exemple, au lieu de `prive/objets/liste/auteurs_lies.html` et `auteurs_associer.html`, cela utiliserait `prive/objets/liste/auteurs_roles_lies.html` et `auteurs_roles_associer.html`. Il faut donc créer ces squelettes. Ces squelettes peuvent poster les valeurs au formulaire pour insérer de nouveaux liens, de la forme `qualifier_lien[auteur-3-article-11][role]` en postant `redacteur` par exemple. Il est possible au passage de poster en plus d'autres valeurs, qui seront intégrées dans l'enregistrement du lien. Ainsi, poster en même temps `qualifier_lien[auteur-3-article-11][valeur]` = `50` enregistrera la valeur 50 dans la colonne `valeur` de la table de lien (qui doit exister !). D'autres informations sont présentes dans http://contrib.spip.net/Des-roles-sur-des-liens, http://zone.spip.org/trac/spip-zone/browser/_plugins_/roles_auteurs ou encore http://zone.spip.org/trac/spip-zone/browser/_plugins_/roles
7 years ago
Intégration dans SPIP de la possibilité de gérer des liens entre objets avec des rôles. On intègre l'API présente actuellement dans le plugin Rôles, en modifiant un peu les fonctions d'édition de liens. Celles-ci permettent maintenant d'éditer des liens ayant donc des rôles. Ces différents rôles et le nom de la colonne SQL qui les reçoit, s'ils sont utilisés, doivent être déclarés avec la déclaration de l'objet éditorial correspondant. Un exemple est donné avec le plugin «Roles auteurs» qui définit quelques rôles. Les champs décrivant les rôles : `roles_colonne`, `roles_titres` et `roles_objets` doivent être déclarés (via le pipeline declarer_tables_objets_sql). ``` "roles_colonne" => "role", "roles_titres" => array( 'redacteur' => 'info_statut_redacteur', 'traducteur' => 'roles_auteurs:traducteur', 'correcteur' => 'roles_auteurs:correcteur', 'relecteur' => 'roles_auteurs:relecteur', ), "roles_objets" => array( 'articles' => array( 'choix' => array('redacteur', 'traducteur', 'correcteur', 'relecteur'), 'defaut' => 'redacteur' ) #'*' => array() ) ``` Une fois déclaré, on peut appeler les fonctions d'édition de lien en transmettant des valeurs de rôles, tel que : ``` objet_associer( array('auteur' => 3), array('article' => 11), array('role' => 'correcteur') ); // utilisera le rôle par défaut objet_associer( array('auteur' => 3), array('article' => 11) ); ``` Si aucun rôle n'est indiqué, le rôle par défaut est appliqué. Dans le cas d'une dissociation également, si aucun rôle n'est indiqué, seuls les liaisons avec le rôle par défaut seront supprimés ; pour supprimer tous les rôles, il faut à ce moment là indiquer '*' : ``` objet_dissocier( array('auteur' => 3), array('article' => 11), array('role' => 'correcteur') ); // utilisera le rôle par défaut objet_dissocier( array('auteur' => 3), array('article' => 11) ); // enlèvera tous les rôles objet_dissocier( array('auteur' => 3), array('article' => 11), array('role' => '*') ); ``` Le formulaire d'édition de liens n'utilisera pas les mêmes squelettes de liaison lorsqu'une colonne de rôle est déclarée. Ainsi dans cet exemple, au lieu de `prive/objets/liste/auteurs_lies.html` et `auteurs_associer.html`, cela utiliserait `prive/objets/liste/auteurs_roles_lies.html` et `auteurs_roles_associer.html`. Il faut donc créer ces squelettes. Ces squelettes peuvent poster les valeurs au formulaire pour insérer de nouveaux liens, de la forme `qualifier_lien[auteur-3-article-11][role]` en postant `redacteur` par exemple. Il est possible au passage de poster en plus d'autres valeurs, qui seront intégrées dans l'enregistrement du lien. Ainsi, poster en même temps `qualifier_lien[auteur-3-article-11][valeur]` = `50` enregistrera la valeur 50 dans la colonne `valeur` de la table de lien (qui doit exister !). D'autres informations sont présentes dans http://contrib.spip.net/Des-roles-sur-des-liens, http://zone.spip.org/trac/spip-zone/browser/_plugins_/roles_auteurs ou encore http://zone.spip.org/trac/spip-zone/browser/_plugins_/roles
7 years ago
Intégration dans SPIP de la possibilité de gérer des liens entre objets avec des rôles. On intègre l'API présente actuellement dans le plugin Rôles, en modifiant un peu les fonctions d'édition de liens. Celles-ci permettent maintenant d'éditer des liens ayant donc des rôles. Ces différents rôles et le nom de la colonne SQL qui les reçoit, s'ils sont utilisés, doivent être déclarés avec la déclaration de l'objet éditorial correspondant. Un exemple est donné avec le plugin «Roles auteurs» qui définit quelques rôles. Les champs décrivant les rôles : `roles_colonne`, `roles_titres` et `roles_objets` doivent être déclarés (via le pipeline declarer_tables_objets_sql). ``` "roles_colonne" => "role", "roles_titres" => array( 'redacteur' => 'info_statut_redacteur', 'traducteur' => 'roles_auteurs:traducteur', 'correcteur' => 'roles_auteurs:correcteur', 'relecteur' => 'roles_auteurs:relecteur', ), "roles_objets" => array( 'articles' => array( 'choix' => array('redacteur', 'traducteur', 'correcteur', 'relecteur'), 'defaut' => 'redacteur' ) #'*' => array() ) ``` Une fois déclaré, on peut appeler les fonctions d'édition de lien en transmettant des valeurs de rôles, tel que : ``` objet_associer( array('auteur' => 3), array('article' => 11), array('role' => 'correcteur') ); // utilisera le rôle par défaut objet_associer( array('auteur' => 3), array('article' => 11) ); ``` Si aucun rôle n'est indiqué, le rôle par défaut est appliqué. Dans le cas d'une dissociation également, si aucun rôle n'est indiqué, seuls les liaisons avec le rôle par défaut seront supprimés ; pour supprimer tous les rôles, il faut à ce moment là indiquer '*' : ``` objet_dissocier( array('auteur' => 3), array('article' => 11), array('role' => 'correcteur') ); // utilisera le rôle par défaut objet_dissocier( array('auteur' => 3), array('article' => 11) ); // enlèvera tous les rôles objet_dissocier( array('auteur' => 3), array('article' => 11), array('role' => '*') ); ``` Le formulaire d'édition de liens n'utilisera pas les mêmes squelettes de liaison lorsqu'une colonne de rôle est déclarée. Ainsi dans cet exemple, au lieu de `prive/objets/liste/auteurs_lies.html` et `auteurs_associer.html`, cela utiliserait `prive/objets/liste/auteurs_roles_lies.html` et `auteurs_roles_associer.html`. Il faut donc créer ces squelettes. Ces squelettes peuvent poster les valeurs au formulaire pour insérer de nouveaux liens, de la forme `qualifier_lien[auteur-3-article-11][role]` en postant `redacteur` par exemple. Il est possible au passage de poster en plus d'autres valeurs, qui seront intégrées dans l'enregistrement du lien. Ainsi, poster en même temps `qualifier_lien[auteur-3-article-11][valeur]` = `50` enregistrera la valeur 50 dans la colonne `valeur` de la table de lien (qui doit exister !). D'autres informations sont présentes dans http://contrib.spip.net/Des-roles-sur-des-liens, http://zone.spip.org/trac/spip-zone/browser/_plugins_/roles_auteurs ou encore http://zone.spip.org/trac/spip-zone/browser/_plugins_/roles
7 years ago
Intégration dans SPIP de la possibilité de gérer des liens entre objets avec des rôles. On intègre l'API présente actuellement dans le plugin Rôles, en modifiant un peu les fonctions d'édition de liens. Celles-ci permettent maintenant d'éditer des liens ayant donc des rôles. Ces différents rôles et le nom de la colonne SQL qui les reçoit, s'ils sont utilisés, doivent être déclarés avec la déclaration de l'objet éditorial correspondant. Un exemple est donné avec le plugin «Roles auteurs» qui définit quelques rôles. Les champs décrivant les rôles : `roles_colonne`, `roles_titres` et `roles_objets` doivent être déclarés (via le pipeline declarer_tables_objets_sql). ``` "roles_colonne" => "role", "roles_titres" => array( 'redacteur' => 'info_statut_redacteur', 'traducteur' => 'roles_auteurs:traducteur', 'correcteur' => 'roles_auteurs:correcteur', 'relecteur' => 'roles_auteurs:relecteur', ), "roles_objets" => array( 'articles' => array( 'choix' => array('redacteur', 'traducteur', 'correcteur', 'relecteur'), 'defaut' => 'redacteur' ) #'*' => array() ) ``` Une fois déclaré, on peut appeler les fonctions d'édition de lien en transmettant des valeurs de rôles, tel que : ``` objet_associer( array('auteur' => 3), array('article' => 11), array('role' => 'correcteur') ); // utilisera le rôle par défaut objet_associer( array('auteur' => 3), array('article' => 11) ); ``` Si aucun rôle n'est indiqué, le rôle par défaut est appliqué. Dans le cas d'une dissociation également, si aucun rôle n'est indiqué, seuls les liaisons avec le rôle par défaut seront supprimés ; pour supprimer tous les rôles, il faut à ce moment là indiquer '*' : ``` objet_dissocier( array('auteur' => 3), array('article' => 11), array('role' => 'correcteur') ); // utilisera le rôle par défaut objet_dissocier( array('auteur' => 3), array('article' => 11) ); // enlèvera tous les rôles objet_dissocier( array('auteur' => 3), array('article' => 11), array('role' => '*') ); ``` Le formulaire d'édition de liens n'utilisera pas les mêmes squelettes de liaison lorsqu'une colonne de rôle est déclarée. Ainsi dans cet exemple, au lieu de `prive/objets/liste/auteurs_lies.html` et `auteurs_associer.html`, cela utiliserait `prive/objets/liste/auteurs_roles_lies.html` et `auteurs_roles_associer.html`. Il faut donc créer ces squelettes. Ces squelettes peuvent poster les valeurs au formulaire pour insérer de nouveaux liens, de la forme `qualifier_lien[auteur-3-article-11][role]` en postant `redacteur` par exemple. Il est possible au passage de poster en plus d'autres valeurs, qui seront intégrées dans l'enregistrement du lien. Ainsi, poster en même temps `qualifier_lien[auteur-3-article-11][valeur]` = `50` enregistrera la valeur 50 dans la colonne `valeur` de la table de lien (qui doit exister !). D'autres informations sont présentes dans http://contrib.spip.net/Des-roles-sur-des-liens, http://zone.spip.org/trac/spip-zone/browser/_plugins_/roles_auteurs ou encore http://zone.spip.org/trac/spip-zone/browser/_plugins_/roles
7 years ago
Intégration dans SPIP de la possibilité de gérer des liens entre objets avec des rôles. On intègre l'API présente actuellement dans le plugin Rôles, en modifiant un peu les fonctions d'édition de liens. Celles-ci permettent maintenant d'éditer des liens ayant donc des rôles. Ces différents rôles et le nom de la colonne SQL qui les reçoit, s'ils sont utilisés, doivent être déclarés avec la déclaration de l'objet éditorial correspondant. Un exemple est donné avec le plugin «Roles auteurs» qui définit quelques rôles. Les champs décrivant les rôles : `roles_colonne`, `roles_titres` et `roles_objets` doivent être déclarés (via le pipeline declarer_tables_objets_sql). ``` "roles_colonne" => "role", "roles_titres" => array( 'redacteur' => 'info_statut_redacteur', 'traducteur' => 'roles_auteurs:traducteur', 'correcteur' => 'roles_auteurs:correcteur', 'relecteur' => 'roles_auteurs:relecteur', ), "roles_objets" => array( 'articles' => array( 'choix' => array('redacteur', 'traducteur', 'correcteur', 'relecteur'), 'defaut' => 'redacteur' ) #'*' => array() ) ``` Une fois déclaré, on peut appeler les fonctions d'édition de lien en transmettant des valeurs de rôles, tel que : ``` objet_associer( array('auteur' => 3), array('article' => 11), array('role' => 'correcteur') ); // utilisera le rôle par défaut objet_associer( array('auteur' => 3), array('article' => 11) ); ``` Si aucun rôle n'est indiqué, le rôle par défaut est appliqué. Dans le cas d'une dissociation également, si aucun rôle n'est indiqué, seuls les liaisons avec le rôle par défaut seront supprimés ; pour supprimer tous les rôles, il faut à ce moment là indiquer '*' : ``` objet_dissocier( array('auteur' => 3), array('article' => 11), array('role' => 'correcteur') ); // utilisera le rôle par défaut objet_dissocier( array('auteur' => 3), array('article' => 11) ); // enlèvera tous les rôles objet_dissocier( array('auteur' => 3), array('article' => 11), array('role' => '*') ); ``` Le formulaire d'édition de liens n'utilisera pas les mêmes squelettes de liaison lorsqu'une colonne de rôle est déclarée. Ainsi dans cet exemple, au lieu de `prive/objets/liste/auteurs_lies.html` et `auteurs_associer.html`, cela utiliserait `prive/objets/liste/auteurs_roles_lies.html` et `auteurs_roles_associer.html`. Il faut donc créer ces squelettes. Ces squelettes peuvent poster les valeurs au formulaire pour insérer de nouveaux liens, de la forme `qualifier_lien[auteur-3-article-11][role]` en postant `redacteur` par exemple. Il est possible au passage de poster en plus d'autres valeurs, qui seront intégrées dans l'enregistrement du lien. Ainsi, poster en même temps `qualifier_lien[auteur-3-article-11][valeur]` = `50` enregistrera la valeur 50 dans la colonne `valeur` de la table de lien (qui doit exister !). D'autres informations sont présentes dans http://contrib.spip.net/Des-roles-sur-des-liens, http://zone.spip.org/trac/spip-zone/browser/_plugins_/roles_auteurs ou encore http://zone.spip.org/trac/spip-zone/browser/_plugins_/roles
7 years ago
Intégration dans SPIP de la possibilité de gérer des liens entre objets avec des rôles. On intègre l'API présente actuellement dans le plugin Rôles, en modifiant un peu les fonctions d'édition de liens. Celles-ci permettent maintenant d'éditer des liens ayant donc des rôles. Ces différents rôles et le nom de la colonne SQL qui les reçoit, s'ils sont utilisés, doivent être déclarés avec la déclaration de l'objet éditorial correspondant. Un exemple est donné avec le plugin «Roles auteurs» qui définit quelques rôles. Les champs décrivant les rôles : `roles_colonne`, `roles_titres` et `roles_objets` doivent être déclarés (via le pipeline declarer_tables_objets_sql). ``` "roles_colonne" => "role", "roles_titres" => array( 'redacteur' => 'info_statut_redacteur', 'traducteur' => 'roles_auteurs:traducteur', 'correcteur' => 'roles_auteurs:correcteur', 'relecteur' => 'roles_auteurs:relecteur', ), "roles_objets" => array( 'articles' => array( 'choix' => array('redacteur', 'traducteur', 'correcteur', 'relecteur'), 'defaut' => 'redacteur' ) #'*' => array() ) ``` Une fois déclaré, on peut appeler les fonctions d'édition de lien en transmettant des valeurs de rôles, tel que : ``` objet_associer( array('auteur' => 3), array('article' => 11), array('role' => 'correcteur') ); // utilisera le rôle par défaut objet_associer( array('auteur' => 3), array('article' => 11) ); ``` Si aucun rôle n'est indiqué, le rôle par défaut est appliqué. Dans le cas d'une dissociation également, si aucun rôle n'est indiqué, seuls les liaisons avec le rôle par défaut seront supprimés ; pour supprimer tous les rôles, il faut à ce moment là indiquer '*' : ``` objet_dissocier( array('auteur' => 3), array('article' => 11), array('role' => 'correcteur') ); // utilisera le rôle par défaut objet_dissocier( array('auteur' => 3), array('article' => 11) ); // enlèvera tous les rôles objet_dissocier( array('auteur' => 3), array('article' => 11), array('role' => '*') ); ``` Le formulaire d'édition de liens n'utilisera pas les mêmes squelettes de liaison lorsqu'une colonne de rôle est déclarée. Ainsi dans cet exemple, au lieu de `prive/objets/liste/auteurs_lies.html` et `auteurs_associer.html`, cela utiliserait `prive/objets/liste/auteurs_roles_lies.html` et `auteurs_roles_associer.html`. Il faut donc créer ces squelettes. Ces squelettes peuvent poster les valeurs au formulaire pour insérer de nouveaux liens, de la forme `qualifier_lien[auteur-3-article-11][role]` en postant `redacteur` par exemple. Il est possible au passage de poster en plus d'autres valeurs, qui seront intégrées dans l'enregistrement du lien. Ainsi, poster en même temps `qualifier_lien[auteur-3-article-11][valeur]` = `50` enregistrera la valeur 50 dans la colonne `valeur` de la table de lien (qui doit exister !). D'autres informations sont présentes dans http://contrib.spip.net/Des-roles-sur-des-liens, http://zone.spip.org/trac/spip-zone/browser/_plugins_/roles_auteurs ou encore http://zone.spip.org/trac/spip-zone/browser/_plugins_/roles
7 years ago
Intégration dans SPIP de la possibilité de gérer des liens entre objets avec des rôles. On intègre l'API présente actuellement dans le plugin Rôles, en modifiant un peu les fonctions d'édition de liens. Celles-ci permettent maintenant d'éditer des liens ayant donc des rôles. Ces différents rôles et le nom de la colonne SQL qui les reçoit, s'ils sont utilisés, doivent être déclarés avec la déclaration de l'objet éditorial correspondant. Un exemple est donné avec le plugin «Roles auteurs» qui définit quelques rôles. Les champs décrivant les rôles : `roles_colonne`, `roles_titres` et `roles_objets` doivent être déclarés (via le pipeline declarer_tables_objets_sql). ``` "roles_colonne" => "role", "roles_titres" => array( 'redacteur' => 'info_statut_redacteur', 'traducteur' => 'roles_auteurs:traducteur', 'correcteur' => 'roles_auteurs:correcteur', 'relecteur' => 'roles_auteurs:relecteur', ), "roles_objets" => array( 'articles' => array( 'choix' => array('redacteur', 'traducteur', 'correcteur', 'relecteur'), 'defaut' => 'redacteur' ) #'*' => array() ) ``` Une fois déclaré, on peut appeler les fonctions d'édition de lien en transmettant des valeurs de rôles, tel que : ``` objet_associer( array('auteur' => 3), array('article' => 11), array('role' => 'correcteur') ); // utilisera le rôle par défaut objet_associer( array('auteur' => 3), array('article' => 11) ); ``` Si aucun rôle n'est indiqué, le rôle par défaut est appliqué. Dans le cas d'une dissociation également, si aucun rôle n'est indiqué, seuls les liaisons avec le rôle par défaut seront supprimés ; pour supprimer tous les rôles, il faut à ce moment là indiquer '*' : ``` objet_dissocier( array('auteur' => 3), array('article' => 11), array('role' => 'correcteur') ); // utilisera le rôle par défaut objet_dissocier( array('auteur' => 3), array('article' => 11) ); // enlèvera tous les rôles objet_dissocier( array('auteur' => 3), array('article' => 11), array('role' => '*') ); ``` Le formulaire d'édition de liens n'utilisera pas les mêmes squelettes de liaison lorsqu'une colonne de rôle est déclarée. Ainsi dans cet exemple, au lieu de `prive/objets/liste/auteurs_lies.html` et `auteurs_associer.html`, cela utiliserait `prive/objets/liste/auteurs_roles_lies.html` et `auteurs_roles_associer.html`. Il faut donc créer ces squelettes. Ces squelettes peuvent poster les valeurs au formulaire pour insérer de nouveaux liens, de la forme `qualifier_lien[auteur-3-article-11][role]` en postant `redacteur` par exemple. Il est possible au passage de poster en plus d'autres valeurs, qui seront intégrées dans l'enregistrement du lien. Ainsi, poster en même temps `qualifier_lien[auteur-3-article-11][valeur]` = `50` enregistrera la valeur 50 dans la colonne `valeur` de la table de lien (qui doit exister !). D'autres informations sont présentes dans http://contrib.spip.net/Des-roles-sur-des-liens, http://zone.spip.org/trac/spip-zone/browser/_plugins_/roles_auteurs ou encore http://zone.spip.org/trac/spip-zone/browser/_plugins_/roles
7 years ago
Intégration dans SPIP de la possibilité de gérer des liens entre objets avec des rôles. On intègre l'API présente actuellement dans le plugin Rôles, en modifiant un peu les fonctions d'édition de liens. Celles-ci permettent maintenant d'éditer des liens ayant donc des rôles. Ces différents rôles et le nom de la colonne SQL qui les reçoit, s'ils sont utilisés, doivent être déclarés avec la déclaration de l'objet éditorial correspondant. Un exemple est donné avec le plugin «Roles auteurs» qui définit quelques rôles. Les champs décrivant les rôles : `roles_colonne`, `roles_titres` et `roles_objets` doivent être déclarés (via le pipeline declarer_tables_objets_sql). ``` "roles_colonne" => "role", "roles_titres" => array( 'redacteur' => 'info_statut_redacteur', 'traducteur' => 'roles_auteurs:traducteur', 'correcteur' => 'roles_auteurs:correcteur', 'relecteur' => 'roles_auteurs:relecteur', ), "roles_objets" => array( 'articles' => array( 'choix' => array('redacteur', 'traducteur', 'correcteur', 'relecteur'), 'defaut' => 'redacteur' ) #'*' => array() ) ``` Une fois déclaré, on peut appeler les fonctions d'édition de lien en transmettant des valeurs de rôles, tel que : ``` objet_associer( array('auteur' => 3), array('article' => 11), array('role' => 'correcteur') ); // utilisera le rôle par défaut objet_associer( array('auteur' => 3), array('article' => 11) ); ``` Si aucun rôle n'est indiqué, le rôle par défaut est appliqué. Dans le cas d'une dissociation également, si aucun rôle n'est indiqué, seuls les liaisons avec le rôle par défaut seront supprimés ; pour supprimer tous les rôles, il faut à ce moment là indiquer '*' : ``` objet_dissocier( array('auteur' => 3), array('article' => 11), array('role' => 'correcteur') ); // utilisera le rôle par défaut objet_dissocier( array('auteur' => 3), array('article' => 11) ); // enlèvera tous les rôles objet_dissocier( array('auteur' => 3), array('article' => 11), array('role' => '*') ); ``` Le formulaire d'édition de liens n'utilisera pas les mêmes squelettes de liaison lorsqu'une colonne de rôle est déclarée. Ainsi dans cet exemple, au lieu de `prive/objets/liste/auteurs_lies.html` et `auteurs_associer.html`, cela utiliserait `prive/objets/liste/auteurs_roles_lies.html` et `auteurs_roles_associer.html`. Il faut donc créer ces squelettes. Ces squelettes peuvent poster les valeurs au formulaire pour insérer de nouveaux liens, de la forme `qualifier_lien[auteur-3-article-11][role]` en postant `redacteur` par exemple. Il est possible au passage de poster en plus d'autres valeurs, qui seront intégrées dans l'enregistrement du lien. Ainsi, poster en même temps `qualifier_lien[auteur-3-article-11][valeur]` = `50` enregistrera la valeur 50 dans la colonne `valeur` de la table de lien (qui doit exister !). D'autres informations sont présentes dans http://contrib.spip.net/Des-roles-sur-des-liens, http://zone.spip.org/trac/spip-zone/browser/_plugins_/roles_auteurs ou encore http://zone.spip.org/trac/spip-zone/browser/_plugins_/roles
7 years ago
Intégration dans SPIP de la possibilité de gérer des liens entre objets avec des rôles. On intègre l'API présente actuellement dans le plugin Rôles, en modifiant un peu les fonctions d'édition de liens. Celles-ci permettent maintenant d'éditer des liens ayant donc des rôles. Ces différents rôles et le nom de la colonne SQL qui les reçoit, s'ils sont utilisés, doivent être déclarés avec la déclaration de l'objet éditorial correspondant. Un exemple est donné avec le plugin «Roles auteurs» qui définit quelques rôles. Les champs décrivant les rôles : `roles_colonne`, `roles_titres` et `roles_objets` doivent être déclarés (via le pipeline declarer_tables_objets_sql). ``` "roles_colonne" => "role", "roles_titres" => array( 'redacteur' => 'info_statut_redacteur', 'traducteur' => 'roles_auteurs:traducteur', 'correcteur' => 'roles_auteurs:correcteur', 'relecteur' => 'roles_auteurs:relecteur', ), "roles_objets" => array( 'articles' => array( 'choix' => array('redacteur', 'traducteur', 'correcteur', 'relecteur'), 'defaut' => 'redacteur' ) #'*' => array() ) ``` Une fois déclaré, on peut appeler les fonctions d'édition de lien en transmettant des valeurs de rôles, tel que : ``` objet_associer( array('auteur' => 3), array('article' => 11), array('role' => 'correcteur') ); // utilisera le rôle par défaut objet_associer( array('auteur' => 3), array('article' => 11) ); ``` Si aucun rôle n'est indiqué, le rôle par défaut est appliqué. Dans le cas d'une dissociation également, si aucun rôle n'est indiqué, seuls les liaisons avec le rôle par défaut seront supprimés ; pour supprimer tous les rôles, il faut à ce moment là indiquer '*' : ``` objet_dissocier( array('auteur' => 3), array('article' => 11), array('role' => 'correcteur') ); // utilisera le rôle par défaut objet_dissocier( array('auteur' => 3), array('article' => 11) ); // enlèvera tous les rôles objet_dissocier( array('auteur' => 3), array('article' => 11), array('role' => '*') ); ``` Le formulaire d'édition de liens n'utilisera pas les mêmes squelettes de liaison lorsqu'une colonne de rôle est déclarée. Ainsi dans cet exemple, au lieu de `prive/objets/liste/auteurs_lies.html` et `auteurs_associer.html`, cela utiliserait `prive/objets/liste/auteurs_roles_lies.html` et `auteurs_roles_associer.html`. Il faut donc créer ces squelettes. Ces squelettes peuvent poster les valeurs au formulaire pour insérer de nouveaux liens, de la forme `qualifier_lien[auteur-3-article-11][role]` en postant `redacteur` par exemple. Il est possible au passage de poster en plus d'autres valeurs, qui seront intégrées dans l'enregistrement du lien. Ainsi, poster en même temps `qualifier_lien[auteur-3-article-11][valeur]` = `50` enregistrera la valeur 50 dans la colonne `valeur` de la table de lien (qui doit exister !). D'autres informations sont présentes dans http://contrib.spip.net/Des-roles-sur-des-liens, http://zone.spip.org/trac/spip-zone/browser/_plugins_/roles_auteurs ou encore http://zone.spip.org/trac/spip-zone/browser/_plugins_/roles
7 years ago
Intégration dans SPIP de la possibilité de gérer des liens entre objets avec des rôles. On intègre l'API présente actuellement dans le plugin Rôles, en modifiant un peu les fonctions d'édition de liens. Celles-ci permettent maintenant d'éditer des liens ayant donc des rôles. Ces différents rôles et le nom de la colonne SQL qui les reçoit, s'ils sont utilisés, doivent être déclarés avec la déclaration de l'objet éditorial correspondant. Un exemple est donné avec le plugin «Roles auteurs» qui définit quelques rôles. Les champs décrivant les rôles : `roles_colonne`, `roles_titres` et `roles_objets` doivent être déclarés (via le pipeline declarer_tables_objets_sql). ``` "roles_colonne" => "role", "roles_titres" => array( 'redacteur' => 'info_statut_redacteur', 'traducteur' => 'roles_auteurs:traducteur', 'correcteur' => 'roles_auteurs:correcteur', 'relecteur' => 'roles_auteurs:relecteur', ), "roles_objets" => array( 'articles' => array( 'choix' => array('redacteur', 'traducteur', 'correcteur', 'relecteur'), 'defaut' => 'redacteur' ) #'*' => array() ) ``` Une fois déclaré, on peut appeler les fonctions d'édition de lien en transmettant des valeurs de rôles, tel que : ``` objet_associer( array('auteur' => 3), array('article' => 11), array('role' => 'correcteur') ); // utilisera le rôle par défaut objet_associer( array('auteur' => 3), array('article' => 11) ); ``` Si aucun rôle n'est indiqué, le rôle par défaut est appliqué. Dans le cas d'une dissociation également, si aucun rôle n'est indiqué, seuls les liaisons avec le rôle par défaut seront supprimés ; pour supprimer tous les rôles, il faut à ce moment là indiquer '*' : ``` objet_dissocier( array('auteur' => 3), array('article' => 11), array('role' => 'correcteur') ); // utilisera le rôle par défaut objet_dissocier( array('auteur' => 3), array('article' => 11) ); // enlèvera tous les rôles objet_dissocier( array('auteur' => 3), array('article' => 11), array('role' => '*') ); ``` Le formulaire d'édition de liens n'utilisera pas les mêmes squelettes de liaison lorsqu'une colonne de rôle est déclarée. Ainsi dans cet exemple, au lieu de `prive/objets/liste/auteurs_lies.html` et `auteurs_associer.html`, cela utiliserait `prive/objets/liste/auteurs_roles_lies.html` et `auteurs_roles_associer.html`. Il faut donc créer ces squelettes. Ces squelettes peuvent poster les valeurs au formulaire pour insérer de nouveaux liens, de la forme `qualifier_lien[auteur-3-article-11][role]` en postant `redacteur` par exemple. Il est possible au passage de poster en plus d'autres valeurs, qui seront intégrées dans l'enregistrement du lien. Ainsi, poster en même temps `qualifier_lien[auteur-3-article-11][valeur]` = `50` enregistrera la valeur 50 dans la colonne `valeur` de la table de lien (qui doit exister !). D'autres informations sont présentes dans http://contrib.spip.net/Des-roles-sur-des-liens, http://zone.spip.org/trac/spip-zone/browser/_plugins_/roles_auteurs ou encore http://zone.spip.org/trac/spip-zone/browser/_plugins_/roles
7 years ago
  1. <?php
  2. /***************************************************************************\
  3. * SPIP, Système de publication pour l'internet *
  4. * *
  5. * Copyright © avec tendresse depuis 2001 *
  6. * Arnaud Martin, Antoine Pitrou, Philippe Rivière, Emmanuel Saint-James *
  7. * *
  8. * Ce programme est un logiciel libre distribué sous licence GNU/GPL. *
  9. * Pour plus de détails voir le fichier COPYING.txt ou l'aide en ligne. *
  10. \***************************************************************************/
  11. /**
  12. * Gestion du formulaire d'édition de liens
  13. *
  14. * @package SPIP\Core\Formulaires
  15. **/
  16. if (!defined('_ECRIRE_INC_VERSION')) {
  17. return;
  18. }
  19. /**
  20. * Retrouve la source et l'objet de la liaison
  21. *
  22. * À partir des 3 premiers paramètres transmis au formulaire,
  23. * la fonction retrouve :
  24. * - l'objet dont on utilise sa table de liaison (table_source)
  25. * - l'objet et id_objet sur qui on lie des éléments (objet, id_objet)
  26. * - l'objet que l'on veut lier dessus (objet_lien)
  27. *
  28. * @param string $a
  29. * @param string|int $b
  30. * @param int|string $c
  31. * @return array
  32. * ($table_source,$objet,$id_objet,$objet_lien)
  33. */
  34. function determine_source_lien_objet($a, $b, $c) {
  35. $table_source = $objet_lien = $objet = $id_objet = null;
  36. // auteurs, article, 23 :
  37. // associer des auteurs à l'article 23, sur la table pivot spip_auteurs_liens
  38. if (is_numeric($c) and !is_numeric($b)) {
  39. $table_source = table_objet($a);
  40. $objet_lien = objet_type($a);
  41. $objet = objet_type($b);
  42. $id_objet = $c;
  43. }
  44. // article, 23, auteurs
  45. // associer des auteurs à l'article 23, sur la table pivot spip_articles_liens
  46. if (is_numeric($b) and !is_numeric($c)) {
  47. $table_source = table_objet($c);
  48. $objet_lien = objet_type($a);
  49. $objet = objet_type($a);
  50. $id_objet = $b;
  51. }
  52. return [$table_source, $objet, $id_objet, $objet_lien];
  53. }
  54. /**
  55. * Chargement du formulaire d'édition de liens
  56. *
  57. * #FORMULAIRE_EDITER_LIENS{auteurs,article,23}
  58. * pour associer des auteurs à l'article 23, sur la table pivot spip_auteurs_liens
  59. * #FORMULAIRE_EDITER_LIENS{article,23,auteurs}
  60. * pour associer des auteurs à l'article 23, sur la table pivot spip_articles_liens
  61. * #FORMULAIRE_EDITER_LIENS{articles,auteur,12}
  62. * pour associer des articles à l'auteur 12, sur la table pivot spip_articles_liens
  63. * #FORMULAIRE_EDITER_LIENS{auteur,12,articles}
  64. * pour associer des articles à l'auteur 12, sur la table pivot spip_auteurs_liens
  65. *
  66. * @param string $a
  67. * @param string|int $b
  68. * @param int|string $c
  69. * @param array|bool $options
  70. * - Si array, tableau d'options
  71. * - Si bool : valeur de l'option 'editable' uniquement
  72. *
  73. * @return array
  74. */
  75. function formulaires_editer_liens_charger_dist($a, $b, $c, $options = []) {
  76. // compat avec ancienne signature ou le 4eme argument est $editable
  77. if (!is_array($options)) {
  78. $options = ['editable' => $options];
  79. } elseif (!isset($options['editable'])) {
  80. $options['editable'] = true;
  81. }
  82. $editable = $options['editable'];
  83. list($table_source, $objet, $id_objet, $objet_lien) = determine_source_lien_objet($a, $b, $c);
  84. if (!$table_source or !$objet or !$objet_lien or !$id_objet) {
  85. return false;
  86. }
  87. $objet_source = objet_type($table_source);
  88. $table_sql_source = table_objet_sql($objet_source);
  89. // verifier existence de la table xxx_liens
  90. include_spip('action/editer_liens');
  91. if (!objet_associable($objet_lien)) {
  92. return false;
  93. }
  94. // L'éditabilité :) est définie par un test permanent (par exemple "associermots") ET le 4ème argument
  95. include_spip('inc/autoriser');
  96. $editable = ($editable and autoriser('associer' . $table_source, $objet, $id_objet)
  97. and autoriser('modifier', $objet, $id_objet));
  98. if (
  99. !$editable and !count(objet_trouver_liens(
  100. [$objet_lien => '*'],
  101. [($objet_lien == $objet_source ? $objet : $objet_source) => $id_objet]
  102. ))
  103. ) {
  104. return false;
  105. }
  106. // squelettes de vue et de d'association
  107. // ils sont différents si des rôles sont définis.
  108. $skel_vue = $table_source . '_lies';
  109. $skel_ajout = $table_source . '_associer';
  110. // description des roles
  111. include_spip('inc/roles');
  112. if ($roles = roles_presents($objet_source, $objet)) {
  113. // on demande de nouveaux squelettes en conséquence
  114. $skel_vue = $table_source . '_roles_lies';
  115. $skel_ajout = $table_source . '_roles_associer';
  116. }
  117. $oups = _request('_oups');
  118. if (unserialize(base64_decode($oups))) {
  119. // on est bon, rien a faire
  120. }
  121. elseif (unserialize($oups)) {
  122. // il faut encoder
  123. $oups = base64_encode($oups);
  124. }
  125. else {
  126. $oups = '';
  127. }
  128. $valeurs = [
  129. 'id' => "$table_source-$objet-$id_objet-$objet_lien", // identifiant unique pour les id du form
  130. '_vue_liee' => $skel_vue,
  131. '_vue_ajout' => $skel_ajout,
  132. '_objet_lien' => $objet_lien,
  133. 'id_lien_ajoute' => _request('id_lien_ajoute'),
  134. 'objet' => $objet,
  135. 'id_objet' => $id_objet,
  136. 'objet_source' => $objet_source,
  137. 'table_source' => $table_source,
  138. 'recherche' => '',
  139. 'visible' => 0,
  140. 'ajouter_lien' => '',
  141. 'supprimer_lien' => '',
  142. 'qualifier_lien' => '',
  143. 'ordonner_lien' => '',
  144. 'desordonner_liens' => '',
  145. '_roles' => $roles, # description des roles
  146. '_oups' => $oups,
  147. 'editable' => $editable,
  148. ];
  149. // les options non definies dans $valeurs sont passees telles quelles au formulaire html
  150. $valeurs = array_merge($options, $valeurs);
  151. return $valeurs;
  152. }
  153. /**
  154. * Traiter le post des informations d'édition de liens
  155. *
  156. * Les formulaires peuvent poster dans quatre variables
  157. * - ajouter_lien et supprimer_lien
  158. * - remplacer_lien
  159. * - qualifier_lien
  160. * - ordonner_lien
  161. * - desordonner_liens
  162. *
  163. * Les deux premières peuvent être de trois formes différentes :
  164. * ajouter_lien[]="objet1-id1-objet2-id2"
  165. * ajouter_lien[objet1-id1-objet2-id2]="nimportequoi"
  166. * ajouter_lien['clenonnumerique']="objet1-id1-objet2-id2"
  167. * Dans ce dernier cas, la valeur ne sera prise en compte
  168. * que si _request('clenonnumerique') est vrai (submit associé a l'input)
  169. *
  170. * remplacer_lien doit être de la forme
  171. * remplacer_lien[objet1-id1-objet2-id2]="objet3-id3-objet2-id2"
  172. * ou objet1-id1 est celui qu'on enleve et objet3-id3 celui qu'on ajoute
  173. *
  174. * qualifier_lien doit être de la forme, et sert en complément de ajouter_lien
  175. * qualifier_lien[objet1-id1-objet2-id2][role] = array("role1", "autre_role")
  176. * qualifier_lien[objet1-id1-objet2-id2][valeur] = array("truc", "chose")
  177. * produira 2 liens chacun avec array("role"=>"role1","valeur"=>"truc") et array("role"=>"autre_role","valeur"=>"chose")
  178. *
  179. * ordonner_lien doit être de la forme, et sert pour trier les liens
  180. * ordonner_lien[objet1-id1-objet2-id2] = nouveau_rang
  181. *
  182. * desordonner_liens n'a pas de forme précise, il doit simplement être non nul/non vide
  183. *
  184. * @param string $a
  185. * @param string|int $b
  186. * @param int|string $c
  187. * @param array|bool $options
  188. * - Si array, tableau d'options
  189. * - Si bool : valeur de l'option 'editable' uniquement
  190. *
  191. * @return array
  192. */
  193. function formulaires_editer_liens_traiter_dist($a, $b, $c, $options = []) {
  194. // compat avec ancienne signature ou le 4eme argument est $editable
  195. if (!is_array($options)) {
  196. $options = ['editable' => $options];
  197. } elseif (!isset($options['editable'])) {
  198. $options['editable'] = true;
  199. }
  200. $editable = $options['editable'];
  201. $res = ['editable' => $editable ? true : false];
  202. list($table_source, $objet, $id_objet, $objet_lien) = determine_source_lien_objet($a, $b, $c);
  203. if (!$table_source or !$objet or !$objet_lien) {
  204. return $res;
  205. }
  206. if (_request('tout_voir')) {
  207. set_request('recherche', '');
  208. }
  209. include_spip('inc/autoriser');
  210. if (autoriser('modifier', $objet, $id_objet)) {
  211. // annuler les suppressions du coup d'avant !
  212. if (
  213. _request('annuler_oups')
  214. and $oups = _request('_oups')
  215. and $oups = base64_decode($oups)
  216. and $oups = unserialize($oups)
  217. ) {
  218. if ($oups_objets = charger_fonction("editer_liens_oups_{$table_source}_{$objet}_{$objet_lien}", 'action', true)) {
  219. $oups_objets($oups);
  220. } else {
  221. $objet_source = objet_type($table_source);
  222. include_spip('action/editer_liens');
  223. foreach ($oups as $oup) {
  224. if ($objet_lien == $objet_source) {
  225. objet_associer([$objet_source => $oup[$objet_source]], [$objet => $oup[$objet]], $oup);
  226. } else {
  227. objet_associer([$objet => $oup[$objet]], [$objet_source => $oup[$objet_source]], $oup);
  228. }
  229. }
  230. }
  231. # oups ne persiste que pour la derniere action, si suppression
  232. set_request('_oups');
  233. }
  234. $supprimer = _request('supprimer_lien');
  235. $ajouter = _request('ajouter_lien');
  236. $ordonner = _request('ordonner_lien');
  237. if (_request('desordonner_liens')) {
  238. include_spip('action/editer_liens');
  239. objet_qualifier_liens([$objet_lien => '*'], [$objet => $id_objet], ['rang_lien' => 0]);
  240. }
  241. // il est possible de preciser dans une seule variable un remplacement :
  242. // remplacer_lien[old][new]
  243. if ($remplacer = _request('remplacer_lien')) {
  244. foreach ($remplacer as $k => $v) {
  245. if ($old = lien_verifier_action($k, '')) {
  246. foreach (is_array($v) ? $v : [$v] as $kn => $vn) {
  247. if ($new = lien_verifier_action($kn, $vn)) {
  248. $supprimer[$old] = 'x';
  249. $ajouter[$new] = '+';
  250. }
  251. }
  252. }
  253. }
  254. }
  255. if ($supprimer) {
  256. if (
  257. $supprimer_objets = charger_fonction(
  258. "editer_liens_supprimer_{$table_source}_{$objet}_{$objet_lien}",
  259. 'action',
  260. true
  261. )
  262. ) {
  263. $oups = $supprimer_objets($supprimer);
  264. } else {
  265. include_spip('action/editer_liens');
  266. $oups = [];
  267. foreach ($supprimer as $k => $v) {
  268. if ($lien = lien_verifier_action($k, $v)) {
  269. $lien = explode('-', $lien);
  270. list($objet_source, $ids, $objet_lie, $idl, $role) = array_pad($lien, 5, null);
  271. // appliquer une condition sur le rôle si défini ('*' pour tous les roles)
  272. $cond = (!is_null($role) ? ['role' => $role] : []);
  273. if ($objet_lien == $objet_source) {
  274. $oups = array_merge(
  275. $oups,
  276. objet_trouver_liens([$objet_source => $ids], [$objet_lie => $idl], $cond)
  277. );
  278. objet_dissocier([$objet_source => $ids], [$objet_lie => $idl], $cond);
  279. } else {
  280. $oups = array_merge(
  281. $oups,
  282. objet_trouver_liens([$objet_lie => $idl], [$objet_source => $ids], $cond)
  283. );
  284. objet_dissocier([$objet_lie => $idl], [$objet_source => $ids], $cond);
  285. }
  286. }
  287. }
  288. }
  289. set_request('_oups', $oups ? base64_encode(serialize($oups)) : null);
  290. }
  291. if ($ajouter) {
  292. if (
  293. $ajouter_objets = charger_fonction("editer_liens_ajouter_{$table_source}_{$objet}_{$objet_lien}", 'action', true)
  294. ) {
  295. $ajout_ok = $ajouter_objets($ajouter);
  296. } else {
  297. $ajout_ok = false;
  298. include_spip('action/editer_liens');
  299. foreach ($ajouter as $k => $v) {
  300. if ($lien = lien_verifier_action($k, $v)) {
  301. $ajout_ok = true;
  302. list($objet1, $ids, $objet2, $idl) = explode('-', $lien);
  303. $qualifs = lien_retrouver_qualif($objet_lien, $lien);
  304. if ($objet_lien == $objet1) {
  305. lien_ajouter_liaisons($objet1, $ids, $objet2, $idl, $qualifs);
  306. } else {
  307. lien_ajouter_liaisons($objet2, $idl, $objet1, $ids, $qualifs);
  308. }
  309. set_request('id_lien_ajoute', $ids);
  310. }
  311. }
  312. }
  313. # oups ne persiste que pour la derniere action, si suppression
  314. # une suppression suivie d'un ajout dans le meme hit est un remplacement
  315. # non annulable !
  316. if ($ajout_ok) {
  317. set_request('_oups');
  318. }
  319. }
  320. if ($ordonner) {
  321. include_spip('action/editer_liens');
  322. foreach ($ordonner as $k => $rang_lien) {
  323. if ($lien = lien_verifier_action($k, '')) {
  324. list($objet1, $ids, $objet2, $idl) = explode('-', $lien);
  325. $qualif = ['rang_lien' => $rang_lien];
  326. if ($objet_lien == $objet1) {
  327. objet_qualifier_liens([$objet1 => $ids], [$objet2 => $idl], $qualif);
  328. } else {
  329. objet_qualifier_liens([$objet2 => $idl], [$objet1 => $ids], $qualif);
  330. }
  331. set_request('id_lien_ajoute', $ids);
  332. set_request('_oups');
  333. }
  334. }
  335. }
  336. }
  337. return $res;
  338. }
  339. /**
  340. * Retrouver l'action de liaision demandée
  341. *
  342. * Les formulaires envoient une action dans un tableau ajouter_lien
  343. * ou supprimer_lien
  344. *
  345. * L'action est de la forme : objet1-id1-objet2-id2
  346. * ou de la forme : objet1-id1-objet2-id2-role
  347. *
  348. * L'action peut-être indiquée dans la clé ou dans la valeur.
  349. * Si elle est indiquee dans la valeur et que la clé est non numérique,
  350. * on ne la prend en compte que si un submit avec la clé a été envoyé
  351. *
  352. * @internal
  353. * @param string $k Clé du tableau
  354. * @param string $v Valeur du tableau
  355. * @return string Action demandée si trouvée, sinon ''
  356. */
  357. function lien_verifier_action($k, $v) {
  358. $action = '';
  359. if (preg_match(',^\w+-[\w*]+-[\w*]+-[\w*]+(-[\w*])?,', $k)) {
  360. $action = $k;
  361. }
  362. if (preg_match(',^\w+-[\w*]+-[\w*]+-[\w*]+(-[\w*])?,', $v)) {
  363. if (is_numeric($k)) {
  364. $action = $v;
  365. }
  366. if (_request($k)) {
  367. $action = $v;
  368. }
  369. }
  370. // ajout un role null fictif (plus pratique) si pas défini
  371. if ($action and count(explode('-', $action)) == 4) {
  372. $action .= '-';
  373. }
  374. return $action;
  375. }
  376. /**
  377. * Retrouve le ou les qualificatifs postés avec une liaison demandée
  378. *
  379. * @internal
  380. * @param string $objet_lien
  381. * objet qui porte le lien
  382. * @param string $lien
  383. * Action du lien
  384. * @return array
  385. * Liste des qualifs pour chaque lien. Tableau vide s'il n'y en a pas.
  386. **/
  387. function lien_retrouver_qualif($objet_lien, $lien) {
  388. // un role est défini dans la liaison
  389. $defs = explode('-', $lien);
  390. list($objet1, , $objet2, , $role) = array_pad($defs, 5, null);
  391. if ($objet_lien == $objet1) {
  392. $colonne_role = roles_colonne($objet1, $objet2);
  393. } else {
  394. $colonne_role = roles_colonne($objet2, $objet1);
  395. }
  396. // cas ou le role est defini en 5e argument de l'action sur le lien (suppression, ajout rapide sans autre attribut)
  397. if ($role) {
  398. return [
  399. // un seul lien avec ce role
  400. [$colonne_role => $role]
  401. ];
  402. }
  403. // retrouver les rôles postés pour cette liaison, s'il y en a.
  404. $qualifier_lien = _request('qualifier_lien');
  405. if (!$qualifier_lien or !is_array($qualifier_lien)) {
  406. return [];
  407. }
  408. // pas avec l'action complete (incluant le role)
  409. $qualif = [];
  410. if (
  411. (!isset($qualifier_lien[$lien]) or !$qualif = $qualifier_lien[$lien])
  412. and count($defs) == 5
  413. ) {
  414. // on tente avec l'action sans le role
  415. array_pop($defs);
  416. $lien = implode('-', $defs);
  417. if (!isset($qualifier_lien[$lien]) or !$qualif = $qualifier_lien[$lien]) {
  418. $qualif = [];
  419. }
  420. }
  421. // $qualif de la forme array(role=>array(...),valeur=>array(...),....)
  422. // on le reforme en array(array(role=>..,valeur=>..,..),array(role=>..,valeur=>..,..),...)
  423. $qualifs = [];
  424. while (count($qualif)) {
  425. $q = [];
  426. foreach ($qualif as $att => $values) {
  427. if (is_array($values)) {
  428. $q[$att] = array_shift($qualif[$att]);
  429. if (!count($qualif[$att])) {
  430. unset($qualif[$att]);
  431. }
  432. } else {
  433. $q[$att] = $values;
  434. unset($qualif[$att]);
  435. }
  436. }
  437. // pas de rôle vide
  438. if (!$colonne_role or !isset($q[$colonne_role]) or $q[$colonne_role]) {
  439. $qualifs[] = $q;
  440. }
  441. }
  442. return $qualifs;
  443. }
  444. /**
  445. * Ajoute les liens demandés en prenant éventuellement en compte le rôle
  446. *
  447. * Appelle la fonction objet_associer. L'appelle autant de fois qu'il y
  448. * a de rôles demandés pour cette liaison.
  449. *
  450. * @internal
  451. * @param string $objet_source Objet source de la liaison (qui a la table de liaison)
  452. * @param array|string $ids Identifiants pour l'objet source
  453. * @param string $objet_lien Objet à lier
  454. * @param array|string $idl Identifiants pour l'objet lié
  455. * @param array $qualifs
  456. * @return void
  457. **/
  458. function lien_ajouter_liaisons($objet_source, $ids, $objet_lien, $idl, $qualifs) {
  459. // retrouver la colonne de roles s'il y en a a lier
  460. if (is_array($qualifs) and count($qualifs)) {
  461. foreach ($qualifs as $qualif) {
  462. objet_associer([$objet_source => $ids], [$objet_lien => $idl], $qualif);
  463. }
  464. } else {
  465. objet_associer([$objet_source => $ids], [$objet_lien => $idl]);
  466. }
  467. }