Site Officiel
Afin d'ordonner les modules Drupal pour choisir l'ordre de chargement de ceux-ci, il suffit d'implémenter le hook install du module et de changer le poids associé.
Pour être plus clair, il faut créer un fichier nom_module.install ayant pour contenu ceci :
function NOM_MODULE_install() {
db_query("UPDATE {system} SET weight = '-1' WHERE name = 'NOM_MODULE' AND type = 'module'");
}
Récemment, j'ai fait face au casse-tête suivant : comment prévenir la création de doublons pour un type de contenu (tdc) spécifique. Par exemple, comnent empêcher un utilisateur de remplir le même formulaire deux fois, de créer une 2e inscription pour un même événement. La question vaut son pesant d'or surtout s'il s'agit d'un événement payant. Sans compter que la chasse aux doublons pollueurs n'a rien de bien divertissant.
On le sait, Drupal permet que deux noeuds aient exactement le même nom ou titre. On fait comment alors?
Récemment, j'ai fait face au casse-tête suivant : comment prévenir la création de doublons pour un type de contenu (tdc) spécifique. Par exemple, comnent empêcher un utilisateur de remplir le même formulaire deux fois, de créer une 2e inscription pour un même événement. La question vaut son pesant d'or surtout s'il s'agit d'un événement payant. Sans compter que la chasse aux doublons pollueurs n'a rien de bien divertissant.
On le sait, Drupal permet que deux noeuds aient exactement le même nom ou titre. On fait comment alors?
Récemment, j'ai fait face au casse-tête suivant : comment prévenir la création de doublons pour un type de contenu (tdc) spécifique. Par exemple, comnent empêcher un utilisateur de remplir le même formulaire deux fois, de créer une 2e inscription pour un même événement. La question vaut son pesant d'or surtout s'il s'agit d'un événement payant. Sans compter que la chasse aux doublons pollueurs n'a rien de bien divertissant.
On le sait, Drupal permet que deux noeuds aient exactement le même nom ou titre. On fait comment alors?
Quand on écrit un "Livre" via le module book de Drupal, on a une génération automatique du menu (sommaire), ou plûtot des enfants d'une page.
Or, on ne peut pas modifier la profondeur de cet affichage, qui affiche donc seulement les enfants directs de la page en cours, mais pas ses "petits-fils" (ou alors je suis preneur de la solution).
Voilà donc la solution pour modifier la profondeur du sommaire :
1- télécharger le module booktree (dispo en attachement aussi)
2- l'installer et l'activer
3- dans le fichier template.php de votre thème, ajouter le hook template_preprocess_book_navigation(&$variables), avec comme contenu :
function THEME_preprocess_book_navigation(&$variables) {
$book_link = $variables['book_link'];
Pour créer un groupe de champs multiple sous Drupal 6, la fonction n'est pas disponible de base avec le module CCK 2.
En fait, celle-ci a seulement été ajoutée dans CCK 3, qui est en béta, et non stable à l'heure actuelle. Mais on peut simplement l'ajouter dans CCK 2, en téléchargeant le module CCK3, en le décompressant, et en ajoutant le contenu du répertoire cck/modules/content_multigroup à CCK2, au même endroit.
Il faut en plus copier le répertoire cck/js du module CCK3 dans le répertoire du module CCK2, et ça fonctionne parfaitement.
Maintenant, vous avez un nouveau type de champs CCK "Multigroup", à utiliser comme un "Group", avec le même principe d'arborescence.
Une erreur est cependant visible : si vous utilisez un champ de type Wysiwyg dans le multigroup, le contenu de ce champ est supprimé lors du click sur "Add more values", ce qui est vraiment pénible.
Pour ça, 1 solution qui m'a prit du temps :
Sometimes you lose your master password. Won't describe here how you managed to do it, since distraction that lead to that kind of errors is a burden to carry for all of us. Drupal 6 was quite easy to recover, because its passwords were encrypted using the well known MD5 digest algorithm, while Drupal 7 uses SHA512 and a custom seed depending on the site. This statement makes us unable to use well known functions for that. In order to recover your password, there are two easy steps.
Voila comment modifier le formulaire de recherche Drupal pour ajouter les CSS et le texte que l'on souhaite :
/**
* Override or insert PHPTemplate variables into the search_theme_form template.
*
* @param $vars
* A sequential array of variables to pass to the theme template.
* @param $hook
* The name of the theme function being called (not used in this case.)
*/
function montheme_preprocess_search_theme_form(&$vars, $hook) {
// Modify elements of the search form
$vars['form']['search_theme_form']['#title'] = t('Recherche sur mon site');
// Set a default value for the search box
$vars['form']['search_theme_form']['#value'] = t('Entrez ici votre recherche');
// Add a custom class to the search box
$vars['form']['search_theme_form']['#attributes'] = array('class' => t('customsearch'));
Vous avez un problème avec le module Captcha, qui vous refuse à chaque fois les soumissions de vos modules custom?
Vous avez un message du genre "La réponse saisie pour le CAPTCHA est incorrecte.", ou "The answer you entered for the CAPTCHA was not correct." ?
Voici peut-être une solution qui règle le problème (en tout cas, qui a marché pour moi après de nombreuses heures de recherche) :
Il a "suffit" que je rajoute dans mon formulaire la valeur "#tree"=>0, en code cela donne :
Apres la sortie de Drupal 7, tout se met en place pour preparer la version 8.
Un des gros changements dans le cycle de développement qui va être mis en place pour Drupal 8 concerne l'apparition des "initiatives". On ne connait pas encore toutes les initiatives qui vont être mises en place, mais celles-ci concerneront sans doute les gros axes de Drupal 8 que Dries a évoqué lors de sa keynote.
La première initiative a été officiellement dévoilée le 28 mars dernier (oui, je sais, j'ai du retard) et concerne la gestion de la configuration de Drupal ("Configuration management" en anglais).
Le terme de "configuration management" peut sembler un peu abstrait pour beaucoup. Dans les faits, il s'agirait, dans l'idéal, d'une sorte de "Settings API" qui permetterait de pouvoir stocker toute la configuration de Drupal de manière plus "propre" qu'actuellement. En deux mots, avoir une sorte de fichier de configuration global.
Depuis features, on se raproche peu-à-peu de ce St Graal Drupalien, néanmoins, features ne couvre pas l'ensemble de nos besoins. Bien sûr, il est désormais facile d'exporter des views, des panels ... et même des variables si on passe via Strongarm. Mais il ne faut pas oublier que ceci n'est possible uniquement si l'auteur du module a pensé à integrer son code avec features.
Le vrai but du "Configuration management" est de proposer un mécanisme permettant de maintenir l'intégrité et la tracabilitée des changements de configuration dans la vie du site. Il serait par exemple possible de :
Ces changements ouvriront également la voie un meilleur contrôle du "content staging". Pouvoir fusionner facilement des changements effectués par les utilisateurs du site (les commentaires, les votes, ...) et la configuration d'une instance de dev par exemple, pour y apporter les mises à jour souhaitées, puis ensuite pouvoir reverser tout ceci vers la prod sans soucis majeur.
Comme Dries l'a evoqué lors de sa Keynote, des "Initiative Owner" sont nommé afin de suivre les avancements des ces projets.
C'est Greg Dunlap (heyrocker sur drupal.org) qui sera responsable de cette initiative.
Greg est déjà connu pour avoir énormément contribuer au module Deployment et a déjà beaucoup réfléchi à toutes les problématiques de staging et de déploiement de code.
Espérons qu'il saura réaliser ce que nous attendons tous.
Il sera épaulé par David Strauss, qui sera en charge du suivi de l'architecture et des API à mettre en place.
En attendant, n'oubliez pas de suivre les avancements et reflexions autour de ce projet sur le groups, http://groups.drupal.org/build-systems-change-management
Voici un petit bout de code et quelques explications afin de créer un champ texte avec auto-complétion pour vos formulaire en utilisant la form api de Drupal.
Dans l’exemple suivant nous allons créer un formulaire avec un champ texte qui permettra de sélectionner un noeud parmi tous les contenus publiés sur le site. Pour pimenter l’exercice on permettra à notre utilisateur de saisir plusieurs valeurs, comme il est possible de faire dans un champ tag de taxonomie.
La première chose à faire consiste à créer une fonction de callback afin de récupérer les titres des nodes en base de données que l’on renverra par la suite au format json.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
<span class='line'><span class="cm">/*</span>
</span><span class='line'><span class="cm">* Callback de récupération des titres des noeuds.</span>
</span><span class='line'><span class="cm">*/</span>
</span><span class='line'><span class="k">function</span> <span class="nf">mymodule_autocomplete_node_title</span><span class="p">(</span><span class="nv">$key</span> <span class="o">=</span> <span class="s1">''</span><span class="p">)</span> <span class="p">{</span>
</span><span class='line'> <span class="nv">$ret</span> <span class="o">=</span> <span class="k">array</span><span class="p">();</span>
</span><span class='line'>
</span><span class='line'> <span class="c1">// L'utilisateur insère une liste de tag séparés par des virgules et</span>
</span><span class='line'> <span class="c1">// on ne traite que le dernier tag.</span>
</span><span class='line'> <span class="nv">$keys</span> <span class="o">=</span> <span class="nx">drupal_explode_tags</span><span class="p">(</span><span class="nv">$key</span><span class="p">);</span>
</span><span class='line'>
</span><span class='line'> <span class="c1">// Récuperation du dernier tag en cour de saisie par l'utilisateur.</span>
</span><span class='line'> <span class="nv">$last_string</span> <span class="o">=</span> <span class="nx">trim</span><span class="p">(</span><span class="nb">array_pop</span><span class="p">(</span><span class="nv">$keys</span><span class="p">));</span>
</span><span class='line'>
</span><span class='line'> <span class="k">if</span> <span class="p">(</span><span class="o">!</span><span class="k">empty</span><span class="p">(</span><span class="nv">$last_string</span><span class="p">))</span> <span class="p">{</span>
</span><span class='line'> <span class="nv">$sql</span> <span class="o">=</span> <span class="s2">"SELECT DISTINCT (n.nid), n.title</span>
</span><span class='line'><span class="s2"> FROM {node} n</span>
</span><span class='line'><span class="s2"> WHERE status = 1</span>
</span><span class='line'><span class="s2"> AND UPPER(n.title) LIKE UPPER('%%%s%%')</span>
</span><span class='line'><span class="s2"> ORDER BY n.title ASC"</span><span class="p">;</span>
</span><span class='line'>
</span><span class='line'> <span class="nv">$query</span> <span class="o">=</span> <span class="nx">db_query_range</span><span class="p">(</span><span class="nv">$sql</span><span class="p">,</span> <span class="nv">$last_string</span><span class="p">,</span> <span class="mi">0</span><span class="p">,</span> <span class="mi">10</span><span class="p">);</span>
</span><span class='line'>
</span><span class='line'> <span class="c1">// Récupération des valeurs saisies précédemment.</span>
</span><span class='line'> <span class="nv">$prefix</span> <span class="o">=</span> <span class="o">!</span><span class="k">empty</span><span class="p">(</span><span class="nv">$keys</span><span class="p">)</span> <span class="o">?</span> <span class="nb">implode</span><span class="p">(</span><span class="s1">', '</span><span class="p">,</span> <span class="nv">$keys</span><span class="p">)</span> <span class="o">.</span> <span class="s1">', '</span> <span class="o">:</span> <span class="s1">''</span><span class="p">;</span>
</span><span class='line'>
</span><span class='line'> <span class="c1">// Génération de la liste de résultats à renvoyer.</span>
</span><span class='line'> <span class="k">while</span> <span class="p">(</span><span class="nv">$row</span> <span class="o">=</span> <span class="nx">db_fetch_array</span><span class="p">(</span><span class="nv">$query</span><span class="p">))</span> <span class="p">{</span>
</span><span class='line'> <span class="nv">$ret</span><span class="p">[</span><span class="nv">$prefix</span> <span class="o">.</span> <span class="nv">$row</span><span class="p">[</span><span class="s1">'nid'</span><span class="p">]]</span> <span class="o">=</span> <span class="nx">check_plain</span><span class="p">(</span><span class="nv">$row</span><span class="p">[</span><span class="s1">'title'</span><span class="p">]);</span>
</span><span class='line'> <span class="p">}</span>
</span><span class='line'>
</span><span class='line'> <span class="c1">// Transformation des résultats au format Json, suivi d'un exit pour</span>
</span><span class='line'> <span class="c1">// être sûr que l'on ne renverra rien du thème.</span>
</span><span class='line'> <span class="nx">drupal_json</span><span class="p">(</span><span class="nv">$ret</span><span class="p">);</span>
</span><span class='line'> <span class="k">exit</span><span class="p">();</span>
</span><span class='line'> <span class="p">}</span>
</span><span class='line'><span class="p">}</span>
</span>
Lorsque vous faites des comparaisons entres des chaînes de caractères pensez à tout mettre en minuscule ou majuscule si vous ne voulez pas prendre en compte la casse, ça vous permettra d’être plus tolérant sur l’orthographe.
Il est préférable de limiter le jeu de résultats obtenus, d’une part parce que ça ne nous servirait à rien d’afficher une liste de 400 titres et d’autre part, cela consommerait plus de ressources de base de données. Ainsi pour limiter ma requête j’ai utilisé la fonction db_query_range() au lieu de mettre directement une limite dans ma requête.
Maintenant que nous avons crée la récupération des titres des noeuds, il nous faut ajouter une entrée de menu pour que les données renvoyées par la fonction soit accessible depuis une url.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
<span class='line'><span class="sd">/**</span>
</span><span class='line'><span class="sd">* Implementation of hook_menu().</span>
</span><span class='line'><span class="sd">*</span>
</span><span class='line'><span class="sd">* @return An array of menu items.</span>
</span><span class='line'><span class="sd">*/</span>
</span><span class='line'><span class="k">function</span> <span class="nf">mymodule_menu</span><span class="p">()</span> <span class="p">{</span>
</span><span class='line'> <span class="nv">$items</span> <span class="o">=</span> <span class="k">array</span><span class="p">();</span>
</span><span class='line'> <span class="c1">// Url de récupération des titres des nodes pour l'auto-complétion.</span>
</span><span class='line'> <span class="nv">$items</span><span class="p">[</span><span class="s1">'mymodule/autocomplete/node_title'</span><span class="p">]</span> <span class="o">=</span> <span class="k">array</span><span class="p">(</span>
</span><span class='line'> <span class="s1">'page callback'</span> <span class="o">=></span> <span class="s1">'mymodule_autocomplete_node_title'</span><span class="p">,</span>
</span><span class='line'> <span class="s1">'access arguments'</span> <span class="o">=></span> <span class="k">array</span><span class="p">(</span><span class="s1">'access content'</span><span class="p">),</span>
</span><span class='line'> <span class="s1">'type'</span> <span class="o">=></span> <span class="nx">MENU_CALLBACK</span>
</span><span class='line'> <span class="p">);</span>
</span><span class='line'> <span class="k">return</span> <span class="nv">$items</span><span class="p">;</span>
</span><span class='line'><span class="p">}</span>
</span>
N’oubliez pas qu’après chaque modification du menu il est nécessaire de flusher le cache :)
Pour tester si vous obtenez bien des résultats, rendez-vous sur l’url que vous avez créée dans le hook_menu suivi d’un / et d’un caractère pour simuler la frappe d’un utilisateur. Ce qui donne par exemple : mymodule/autocomplete/node_title/a
La dernière étape, vous l’aurez deviné si vous avez tout suivi, c’est la création du formulaire.
1
2
3
4
5
6
7
8
9
10
11
12
13
<span class='line'><span class="cm">/*</span>
</span><span class='line'><span class="cm">* Formulaire custom de selection de nodes.</span>
</span><span class='line'><span class="cm">*/</span>
</span><span class='line'><span class="k">function</span> <span class="nf">mymodule_listing_nodes_form</span><span class="p">()</span> <span class="p">{</span>
</span><span class='line'> <span class="nv">$form</span> <span class="o">=</span> <span class="k">array</span><span class="p">();</span>
</span><span class='line'> <span class="nv">$form</span><span class="p">[</span><span class="s1">'nids'</span><span class="p">]</span> <span class="o">=</span> <span class="k">array</span><span class="p">(</span>
</span><span class='line'> <span class="s1">'#type'</span> <span class="o">=></span> <span class="s1">'textfield'</span><span class="p">,</span>
</span><span class='line'> <span class="s1">'#title'</span> <span class="o">=></span> <span class="nx">t</span><span class="p">(</span><span class="s1">'Sélectionnez vos contenus'</span><span class="p">),</span>
</span><span class='line'> <span class="c1">// Il est important de donner l'url de récupération des titres sinon ça ne marche pas...</span>
</span><span class='line'> <span class="s1">'#autocomplete_path'</span> <span class="o">=></span> <span class="s1">'mymodule/autocomplete/node_title'</span><span class="p">,</span>
</span><span class='line'> <span class="p">);</span>
</span><span class='line'> <span class="k">return</span> <span class="nv">$form</span><span class="p">;</span>
</span><span class='line'><span class="p">}</span>
</span>
Le secret réside dans le fait de configurer l’option #autocomplete_path du widget textfield en lui paramétrant une url et c’est tout!
Voilà, vous savez maintenant créer des champs textes avec auto-complétion et au final c’était pas bien compliqué! :)
Je suis sûr que vous avez déjà tout compris mais bon au cas où et histoire de rentabiliser l’espace disque de mon hébergement voici les sources de cet exemple (une grand première dans l’histoire de ce blog).
Petite astuce pendant que l’on parle d’auto-complétion. Certains naviguateurs proposent d’utiliser les réponses que vous avez déjà saisies auparavant comme votre nom, prénom et autres, mais parfois vous ne voulez pas autoriser ça dans vos forms. Et bien pour désactiver ça il vous suffit de définir la complétion du champ à off et le tour est joué.
1
2
3
4
<span class='line'><span class="nv">$form</span><span class="p">[</span><span class="s1">'name'</span><span class="p">]</span> <span class="o">=</span> <span class="k">array</span><span class="p">(</span>
</span><span class='line'> <span class="s1">'#type'</span> <span class="o">=></span> <span class="s1">'textfield'</span><span class="p">,</span>
</span><span class='line'> <span class="s1">'#attributes'</span> <span class="o">=></span> <span class="k">array</span><span class="p">(</span><span class="s1">'autocomplete'</span> <span class="o">=></span><span class="s1">'off'</span><span class="p">),</span>
</span><span class='line'><span class="p">);</span>
</span>
Vous avez un site Drupal qui est lent? Vous voulez l'optimiser? Voici un début de réponses :
Modules à installer :
Cache Drupal et config des 2 modules :
If you add a hook_boot() implementation in a module, you need to rebuild the Drupal's module cache
If you add a hook_boot() implementation in a module, you need to rebuild the Drupal's module cache
Diapositives de la session "Developing to the Views 7.3 API" aux Drupal Dev Days de Bruxelles.
Dans les épisodes précédents vous avez pu lire une première présentation de Rules, module très utile et avec qui vous allez devoir devenir meilleurs amis lorsque vous utiliserez Drupal Commerce.
Nous allons donc voir comment exposer vos propres événements, conditions et actions à Rules. Rules est très flexible et offre la possibilité par défaut de rajouter les briques dont vous pourriez avoir besoin pour vos développements.
Commençons par les événements qui déclenchent les rules. Nous allons déclencher un événement lorsqu’un type de contenu précis sera visualisé, nous pourrions le faire avec les composants de base de Rules mais cela permet d’avoir un exemple assez simple. N’hésitez pas à consulter la documentation rédigée par fago pour rules, elle est assez complète et à jour.
Pour déclarer un événement il suffit d’implementer le hook hook_rules_event_info() et de décrire tous vos événements avec leurs paramètres. Exemple :
<?php /** * Implements hook_rules_event_info(). * Déclaration d'un événement basé sur le type du node vu. */ function monmodule_rules_event_info() { return array( 'nodearticle_is_viewed' => array( // Nom de l'événement à invoquer via Rules. 'label' => t("Un node de type article est entrain d'être vu"), // Description de la rule. 'module' => 'Mon Module', // Groupe dans lequel faire apparaitre l'événement (node, utilisateur ou mon module). 'arguments' => array( // Tableau des paramètres à passer à la fonction. 'article' => array('type' => 'node', 'label' => t('Article visualisé.')), // Ici seulement le node. ), ), ); } ?>
Pour que l’implémentation de l’événement soit complète il ne reste plus qu’à signaler à rules que l’événement se produit. Pour cela il suffit d’appeler la fonction rules_invoke_event() au bon moment. Dans notre exemple il suffit de faire cela au sein du hook_nodeapi() si le node est affiché et qu’il a le type article.
/** * Implements hook_nodeapi(). */ function monmodule_nodeapi(&$node, $op) { if ($op == 'view' && $node->type == 'article') { rules_invoke_event('nodearticle_is_viewed', $node); // Invocation de l'événement. } }
Regardons maintenant comment déclarer de nouvelles conditions, l’exemple ici consiste à déterminer si le node que nous sommes entrain de visualiser possède un champ CCK précis (de type nodereférence )avec une valeur.
Cette fois ci il faut implémenter le hook hook_rules_condition_info() pour arriver à nos fins. Comme d’habitude un exemple est plus parlant.
/** * Implements hook_rules_condition_info(). */ function monmodule_rules_condition_info() { return array( 'monmodule_has_nodereference' => array( 'label' => t('Mon node a un node référence.'), 'arguments' => array( 'node' => array('type' => 'node', 'label' => t('Node à vérifier')), ), 'module' => 'User', ), ); }
Comme pour la déclaration d’un événement, les conditions font appel à une fonction de callback, ici monmodule_has_nodereference. Dans cette fonction nous allons implémenter concrètement effectuer le test de la condition à évaluer.
Ici nous évaluons la valeur d’un éventuel node reference pour le champ field_book mais le nom de ce champ pourrait être exposé dans la configuration de la condition, cette valeur se retrouverait dans le paramètre $settings. Pour voir comment configurer les conditions et actions, reportez à la documentation.
Une fois que les événements et conditions sont là, il ne reste qu’une chose à faire, écrire le code qui va être exécuté une fois notre évènement déclenché et notre condition remplie. Vous l’avez compris cette fois il faut exposer cette action via le hook hook_rules_action_info().
Et toujours sur le même principe, la fonction de callback que vous avez déclaré est appelée lorsque la rule est déclenchée et satisfait les conditions configurée.
function monmodule_domyaction(&$node) { drupal_set_message(t("Ce noeud est de type article et possède au moins un node comme node reference dans le champ field_book")); // Effectuer tous les traitements imaginables. }
Etendre Rules 1 est donc quelque chose de très simple, tout se passe principalement dans ces trois hooks et grâce à eux vous pouvez étendre les possibilités de Rules à l’infini. N’hésitez pas à consulter la documentation pour découvrir d’autres fonctionnalités offertes par Rules.
Rules 2 (Drupal 7) permet d’utiliser Rules comme une API de façon beaucoup plus simple, cette nouvelle version explore très facilement les types d’entités et si vous installé entity metadata, vous pourrez également exploiter la puissance des informations additionnelles mises à disposition (accès à toutes les données d’un type d’entity).
Combien de fois vous vous êtes dit, “si seulement j’avais pris le temps de faire un backup”, “si seulement ma dernière sauvegarde ne remontait pas si loin” ? Oui comme moi il y a un jour ou vous l’avez vraiment regretté… Avec ce qui suit, vous n’aurez plus d’excuses et vous pourrez dormir sur vos deux oreilles (enfin si votre serveur est sous Linux, sinon je ne peux rien pour vous).
Aujourd’hui c’est un donc un énième billet sur Drush, ou du moins sur la commande sql-dump et ce afin de créer des sauvegardes automatiques de votre base de données. Je vous l’avais dit, une fois qu’on a goûté à Drush il devient difficile de s’en passer.
Au cas où vous ne découvriez Drush que maintenant voici quelques sujets qui pourraient vous intéresser, à savoir, comment installer drush et comment créer des alias afin de vous faciliter la vie dans la gestion de vos sites.
Pas de Drush sans commande, du coup nous allons utiliser la commande drush sql-dump. Pour plus d’infos sur cette commande utilisez drush help sql-dump. Si vous utilisez la commande telle quelle, votre dump vous sera affiché dans votre terminal et comme nous, on aimerait bien garder ça dans un fichier, on va ajouter quelques options à notre commande.
1
<span class='line'><span class="nv">$ </span>drush @sandbox sql-dump --result-file --gzip
</span>
La commande sql-dump va faire une sauvegarde complète de la base or nous n’avons pas besoin de récupérer les informations des tables de caches par exemple. Pour spécifier des tables à ne pas sauvegarder ou à exclure il suffit de modifier le fichier drushrc.php. Petit rappel sur ce fichier, vous le trouverez par défaut dans le répertoire examples de votre installation de drush, regardez les premières lignes du fichier pour savoir où vous pourrez le placer.
Dans ce fichier on va pouvoir définir les tables dont on ne veut pas les données (ex: tables de caches) et les tables dont on ne veut même pas la structure (ex: tables maisons, tables de migrations). Pour cela il vous suffira de remplir le tableau $options[‘structure-tables’] ou $options[‘skip-tables’].
1
2
3
4
5
6
7
8
9
<span class='line'><span class="cm">/*</span>
</span><span class='line'><span class="cm"> * Customize this associative array with your own tables. This is the list of</span>
</span><span class='line'><span class="cm"> * tables whose *data* is skipped by the 'sql-dump' and 'sql-sync' commands when</span>
</span><span class='line'><span class="cm"> * a structure-tables-key is provided. You may add new tables to the existing</span>
</span><span class='line'><span class="cm"> * array or add a new element.</span>
</span><span class='line'><span class="cm"> */</span>
</span><span class='line'><span class="nv">$options</span><span class="p">[</span><span class="s1">'structure-tables'</span><span class="p">]</span> <span class="o">=</span> <span class="k">array</span><span class="p">(</span>
</span><span class='line'> <span class="s1">'common'</span> <span class="o">=></span> <span class="k">array</span><span class="p">(</span><span class="s1">'cache'</span><span class="p">,</span> <span class="s1">'cache_filter'</span><span class="p">,</span> <span class="s1">'cache_menu'</span><span class="p">,</span> <span class="s1">'cache_page'</span><span class="p">,</span> <span class="s1">'history'</span><span class="p">,</span> <span class="s1">'sessions'</span><span class="p">,</span> <span class="s1">'watchdog'</span><span class="p">),</span>
</span><span class='line'><span class="p">);</span>
</span>
Maintenant qu’on a spécifié les choses inutiles à sauvegarder il ne nous reste plus qu’à le renseigner dans notre commande:
1
<span class='line'><span class="nv">$ </span>drush @sandbox sql-dump --result-file --gzip --structure-table-key<span class="o">=</span>common
</span>
Vous pouvez essayer cette commande pour vérifier que l’export fonctionne bien
Il ne nous reste plus qu’à planifier l’exécution automatique de notre commande dans la crontab.
Pour visualiser ce qu’il y a dans la crontab il suffit d’éxecuter cette commande :
1
<span class='line'><span class="nv">$ </span>crontab -l
</span>
Pour modifier votre crontab exécutez celle-ci :
1
<span class='line'><span class="nv">$ </span>crontab -e
</span>
Voici un exemple qui va sauvegarder notre base tous les lundi à 4h15.
1
<span class='line'>04 15 * * 1 drush @sandbox sql-dump --result-file --gzip --structure-table-key<span class="o">=</span>common
</span>
C’est un exemple parmi tant d’autres à adapter en fonction de votre besoin. Pour plus d’infos sur la configuration de la crontab rendez-vous ici où là et si c’est encore trop compliqué à cette adresse.
Au final rien de bien compliqué, ça vous prendre plus de temps à lire cet article qu’à créer votre sauvegarde, mais maintenant vous n’avez plus d’excuse :)
