Le principe est simple : un Apache SOLR hébergé sur le cloud Amazon EC2.

Nous avons travaillé depuis plusieurs mois pour mettre en place une architecture d’haute disponibilité avec une optimisation des ressources EC2, pour en optimiser les coûts. Coté Drupal, rien de particulier à faire, car on se base sur le module Apache SOLR de base.

Les fonctionnalités d’Adyax Search

• Moteur basé sur Apache Lucene SOLR
• Lemmatisation des expressions françaises
• Recherche par facettes
• Recherche par catégories
• Liberté totale sur le paramétrage de la pertinence, catégories, types de contenus
• Indexation de fichiers PDF, XLS, DOC, RTF…
• Rapidité d’execution des requêtes
• Rapidité d’indexation

Adyax Cloud Search vs Apache SOLR installé chez vous

Haute disponibilité et gestion des piques de trafic :

• Le service de recherche est hébergé sur la plateforme Amazon EC2, ce qui offre un taux de disponibilité de 99,95%
• Par ailleurs grâce à notre système de load-balancing EC2 la plateforme est capable de prendre en charge n’importe quel pic de trafic

Economies importantes :

• Pas de frais d’infogérance
• Une intégration simplissime : vous activez un module Drupal et le moteur de recherche fonctionne !
• Vous ne payez que ce que vous consommez : pour tenir la charge durant les heures chargées ou lors d’un pic de trafic, vous ne payez que les ressources consommées, sans supporter le cout d’un matériel inutilisé le reste du temps
• Une structure de très prix simple
• Grace à un système de cache embarqué, les requêtes déjà effectuées ne sont pas payées !
• Totale transparence : une facture détaillée avec tous vos consommations mensuelles.

http://es.wfp.org/

Pour l’instant seule la version espagnole a été migrée (les autres langues allant vers les anciennes versions, en attendant la migration de tous les sites).

La principale difficulté aura été de gérer les fontes non standard pour les titres. Il a été particulièrement difficile de trouver une fonte qui corresponde graphiquement et qui contienne tous les jeux de caractères (coréen, russe, arabe, français, chinois….)

L’autre tâche complexe est liée au fait que les différentes sous-organisations ne rédigent pas le même volume de contenu, il a fallu donc adapter les pages d’accueil des différentes langues en fonction de la quantité de contenu disponible.

Longue vie à cette belle association qui oeuvre chaque jour contre la faim dans le monde.

WFP un site avec une dizaine de langues sous Drupal

Tendance confirmée, Wordpress, Drupal & Joomla! loin devant

On remarque aussi que Joomla! est devant Drupal sur pas mal de critères. Je ne suis pas vraiment étonné de ce positionnement, Drupal reste surtout utilisé par des professionnel pour des sites importants. On voit d’ailleurs, que le rapport place ezPublish & Typo3 loin derrière, alors que ces CMS sont souvent des concurrents sérieux de Drupal sur les appels d’offres d’envergure.

En revanche, petite surprise, Drupal est largement en tête pour les mesures de marque.

CMS sur le micro-blogging, domination écrasante des 3 leaders

Par ailleurs, et cela confirme mon sentiment vis-à-vis des divers CMS,  Drupal est devant Joomla!, Typo, ezPublish en termes de qualité. En effet, les personnes ont généralement tendance à préférer Drupal, une fois le logiciel installé et utilisé.

Rouge = negatif, Vert = positif

Petite difficulté - la gestion du menu assez imposant et très sympa avec des images et pas mal de contenu. Ici on massivement utilisé Views, le menu classique de Drupal étant laissé pour la gestion des liens dans le footer.

La gestion de l’agenda et des inscriptions utilise le module Sign-up. L’export PDF de tous les articles du site est assuré par le module Print avec l’utilisation d’un template spécial, adapté à l’impression.

Après plusieurs mois d’efforts, les deux cotés du tunnel se sont enfin rejoint : un module Magento pour Drupal et une extension Drupal pour Magento.

En installant les deux, vous aurez la possibilité d’utiliser Magento comme back office de gestion de votre boutique et Drupal pour le front office.

Les avantages de cette solution sont nombreux :

• Totale souplesse sur le contenu : vous n’êtes plus limités par les lacunes ‘CMS’ de Magento. Vous bénéficiez de la toute puissance de Drupal pour gérer votre contenu, promouvoir vos produits et construire des solution eCommerce aussi complexes que vous le souhaitez
• Puissance de Magento : s’il existe des modules eCommerce pour Drupal (Ubercart, eCommerce), il n’en reste pas moins des extension du CMS. Les interfaces et fonctionnalités ne peuvent pas concurrencer Magento, surtout pour des sites d’envergure.
• Sécurité : les deux plateformes (front & back) peuvent résider sur deux serveurs distincts, le back n’est jamais directement atteint par les internautes. Enfin, une faille sur le front ne remet pas en danger l’intégralité de votre solution, votre catalogue, prix, règles de gestion et, surtout, vos clients sont protégés sur le back, éventuellement derrière un parfeu.
• Optimisation : Magento a souvent péché par la lenteur, ce qui n’est pas le cas de Drupal. Séparer les briques front & back permet d’optimiser l’utilisation des ressources, mais surtout offre une opportunité simple de mise en place d’architectures hautement distribuées (rien ne vous empêche d’avoir 3 front office Drupal avec 1 back office Magento.)

Modules Drupal : http://www.drupal.org/project/magento
Extension Magento : http://www.magentocommerce.com/extension/1020/drupal

Acquia a été fondé et est dirigé notamment par Dries Buytaert, le créateur de Drupal.

Après des semaines de discussions pendant lesquelles Acquia a vérifié nos références, interviewé nos clients, étudié notre expertise sur le CMS, le partenariat a été enfin signé.

Ce partenariat servira à nos clients les plus fortunés qui souhaitent bénéficier d’un support 24/24, multi-niveaux. Il servira aussi à rassurer les clients qui en ont encore besoin sur la pérennité de Drupal : Il est aujourd’hui possible d’avoir le support commercial d’un éditeur sur Drupal, comme ça peut déjà être le cas pour des solutions open source comme Linux ou MySql.

Plus d’infos sur www.acquia.com

Lets take look at one of the example features provided with cucumber package:

Feature: Cucumber
  In order to have a happy user base
  As a Cucumber user
  I don't want no stinkin bugs

  Scenario: Reading a table
    Given the following table
      | born  | working |
      | Oslo  | London  |

It doesn’t look like a normal test, isn’t it? Lets play with it a little bit more.

First of all we need to install (I assume that you already have ruby and rubygems packages installed) Cucumber running command:

sudo gem install cucumber mechanize

Create a directory tree for your example project:

mkdir cucumber_test/features/{step_definitions,support}

Now lets write our first scenario, describing search process in Google (I’m taking an idea for this test from Cucumber examples):

Feature: Search
  In order to learn more
  As an information seeker
  I want to find more information

  Scenario: Find what I'm looking for
    Given I am on the "http://google.com" page
    When I search for "drupal magento flex" in form with name "f"
    Then I should see a link to "Adyax :: Drupal Magento Flex Asterisk J2ME web mobile developement ...":http://www.adyax.com/

You’ll need a rake file to run your tests:

require 'rubygems'
require 'cucumber/rake/task'
 
Cucumber::Rake::Task.new do |t|
  t.cucumber_opts = "--format pretty"
end

Lets run it:

$ rake features

If there weren’t any errors then everything is OK; rake told us that we have no scenarios so lets create one. Create a file search.feature in features directory:

Feature: Search
  In order to learn more
  As an information seeker
  I want to find more information

  Scenario: Find what I'm looking for
    Given I am on the "http://google.com" page
    When I search for "drupal magento flex" in form with name "f"
    Then I should see a link to "Adyax :: Drupal Magento Flex Asterisk J2ME web mobile developement ...":http://www.adyax.com/

  Scenario: Find a module
    Given I am on the "http://drupal.org/project/Modules" page
    When I search for "xmlsitemap" in form with method "POST" and action "/project/Modules"
    Then I should see a link to "XML Sitemap":http://drupal.org/project/xmlsitemap

Now you can run “rake features” again:

Our next task is to create step definitions for our scenario but before we need to prepare our working environment. Create file env.rb in features/support directory:

require 'spec/expectations'
# We are using Mechanize library for navigating through pages
# Alternatively you can use any other library including: watir, webrat, selenium
# Check the full list and documentation here: http://wiki.github.com/aslakhellesoy/cucumber
# Examples of using Cucumber: http://github.com/aslakhellesoy/cucumber/tree/master/examples
require 'mechanize'
 
# before "all"
agent = WWW::Mechanize.new
agent.user_agent_alias = 'Mac Safari'
 
Before do
  @agent = agent
  @page = nil
end

Create file search_step.rb in step_definitions directory:

# These step definitions are far from being ready for common usage
# not depending on the site or page. It's just an example :)
# Parsing arguments with regexp
Given 'I am on the "(.*)" page' do |page|
  # browser goto
  @page = @agent.get(page)
end
 
# Google case
  When /I search for "(.*)" in form with name "(.*)"/ do |query, form_name|
  # search
  @page = @page.form_with(:name => form_name) do |search|
    search.q = query
  end.submit
end
 
# Drupal forms have no name
When /I search for "(.*)" in form with method "POST" and action "(.*)"/ do |query, form_action|
  # search
  @page = @page.form_with(:method => "POST", :action => form_action) do |search|
    search.field_with(:name => 'search_theme_form').value = query
  end.submit
end
 
Then /I should see a link to "(.*)":(.*)/ do |text, url|
  link = @page.link_with(:text => text)
  link.text == text && link.href == url
end

Lets run rake again and see what we will get:

Some more screenshots:

Scenario with misspelled argument

Misspelled argument

Of course, our step definitions are far from being common and site-independent but anyhow it wasn’t a goal of this article. Cucumber is a new approach in Ruby BDD which allows to describe behavior of the model with plain-text documents.

To find more examples and documentation visit home page of Cucumber, also check out Redmine plugin StuffToDo which is a nice real-world example of Cucumber usage.

• Expertise des formateurs
• Priorité donnée à la qualité de la prestation dans sa globalité
• Adaptation aux objectifs opérationnels du client
• Prise en compte des utilisations concrètes attendues

N’hésitez pas à prendre contact avec nous pour en savoir plus.

Ok, why not? Drupal is always helping you
At the beginning we need to install Node Auto Term [NAT] and enable Taxonomy core module. The NAT module is used to maintain node-term relationships, i.e. when a node is created, an equivalent taxonomy term is automatically created in any associated vocabularies. And as far as nodes can be extended with CCK fields - NAT is exactly what we need.

Let’s use new content types ‘Literary genre’ (genre) and ‘Store book’ (store_book) and new Taxonomy Vocabulary ‘Literary genres’, marked to tag this 2 content types. Next, go to NAT configuration - usually it can be found on this location: admin/settings/nat/settings.
Open field set for ‘Literary genre’ and select ‘Literary genres’ as a vocabulary which will contain node related term. Here you can configure 4 extra options - for our case I found important to enable ‘Associate node body with term description’ to be consistent in our task and keep same description for node and term. As far as Literary genres can be added manually in vocabulary as a terms (means that this genre doesn’t have any extra information and term page will contain only list of books belong to this genre) - ‘Delete associated term if a node is deleted’ was not enabled, so if you delete NAT node - term will be still available.

Lets add some genre nodes

Note: if you want to create a term not in the top of the hierarchy, but as a sub-genre you can do it easily: while creating new genre node - select term which you want to be parent for your new genre

or manually with sortable option on Taxonomy terms list page

While filling store catalogue with books you will mark them with proper literary genre. Usually people use block to display taxonomy hierarchy (block can be displayed in different regions of your website), that’s why I researched a bit and found a nice module that provides us with opportunity to create extremely customizable blocks for browsing through single hierarchy taxonomies based on JQuery Menu API - Advanced Taxonomy Blocks. I would not write a lot about configuration of this module, because you can find a helpful tutorial here. So I have created new block, display in it hierarchy of ‘Literary genres’ vocabulary and count only books that were tagged with genre.

Now when you click on one of the terms in the list - you go to the list of nodes which were marked with this genre.

Last issue that should be implemented is to make Advanced Taxonomy Blocks module treat ‘Literary genre’ node page as a landing page for taxonomy term if it was specified and default ‘taxonomy/term/%tid%’ page - if not.

For each taxonomy term we will verify if ‘Literary genre’ node exists and if yes - provide node page link.
Here are few tips that can help us. First of all we should know that Drupal allows us to specify which module controls specific taxonomy vocabulary (we can define that vocabulary ‘Literary genres’ was created for the sake of ‘book_store’ module). That’s why we should execute SQL query that will set this ‘hidden’ option for us:

1

UPDATE `vocabulary` SET `module` = 'book_store' WHERE vid = _vid_;

note: _vid_ is the vocabulary id of ‘Literary genres’

The second thing to know is that if module controls taxonomy vocabulary it means that it can provide rewritten URLs for each taxonomy term in it. For this we are going to implement hook_term_path().

1
2
3
4
5
6
7
8
9
10
11
12

/**
 * Implementation of hook_term_path()
 */
function book_store_term_path($term) {
  if (module_exists('nat') && $nids = nat_get_nids(array($term->tid))) {
     // we have strong linking between node and term
    // so only 1 node can be associated with 1 auto term
    $nid = key($nids);
    return 'node/'. $nid;
  }
  return 'taxonomy/term/'. $term->tid;
}

Oh, yes Now with the help of simple theming we will provide what we expect from genre landing page.

node-genre.tpl.php

1
2
3
4
5
6
7
8
9
10
11

<div class="node">
  <?php if ($page == 0) { ?><h2 class="title"><a href="<?php print $node_url?>"><?php print $title?></a></h2><?php }; ?>
  <div class="content">
     <?php print theme('image', $node->field_image[0]['filepath'], $node->field_image[0]['filename'], $node->field_image[0]['filename'], array('style' => 'float:left;'))?>
    <?php print $node->content['body']['#value']?>
 
    <div align="center"><?php print t('SOME CUSTOM TEXT/BLOCKS/LINS/ETC.'); ?></div>
 
    <div align="right"><?php print l(t('Books of this genre'), 'taxonomy/term/'. key($node->nat));?></div>
  </div>
</div>

(some of php code can be moved to appropriate theme preprocess methods, here I just wanted to show how easy things can be)

I hope this small tutorial was helpful for you. If you have any questions please don’t hesitate to ask - i will answer them with great pleasure.

Modules that were used :
- CCK v.6.x-2.1 -  http://drupal.org/project/cck
- Node Auto Term [NAT] v.6.x-1.1-beta3 - http://drupal.org/project/nat
- JQuery Menu v.6.x-2.3 - http://drupal.org/project/jquerymenu
- Advanced Taxonomy Blocks v.6.x-1.8 - http://drupal.org/project/taxonomyblocks

Okay, lets say Taxonomy and Token modules were enabled. Lets create new vocabulary called Tags and in settings mark it as Tag, ’story’ node type will be tagged.

Next step is to create simple settings form for administrator to define what tags should be inserted for new content. To help administrator, we can display him a list of all available tokens for nodes. For this we will use:

theme('token_help', $type);

in our case $type equals ‘node’, so the final code for helper administration form will be:

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

/**
* Menu callback for the token auto-tag settings form.
*/
function token_autotag_admin_settings() {
 
  $form['token_autotag']['token_autotag_pattern'] = array(
    '#type' => '<span class="misspell">textfield</span>',
    '#title' => t('Autotag pattern'),
    '#default_value' => variable_get('token_autotag_pattern', '[month], [language], token-autotag'),
  );
 
  if (module_exists('token')) {
    $form['token_autotag']['token_help'] = array(
      '#title' => t('Replacement patterns'),
      '#type' => '<span class="misspell">fieldset</span>',
      '#collapsible' => TRUE,
      '#collapsed' => TRUE,
      '#description' => t('Prefer raw-text replacements for text to avoid problems with HTML entities!'),
    );
 
    $form['token_autotag']['token_help']['help'] = array(
       '#value' => theme('token_help', 'node'),
    );
  }
 
  return system_settings_form($form);
}

Default value for tagging was set to: current month, language of the post and ‘token-autotag’, later we will define more ‘clever’ tags, because at the moment we don’t know how to provide them
So we should check user input in Tags field and if it is empty - fill it with predefined pattern, for this we are going to implement hook_nodeapi() and

1

token_replace($original, $type = 'global', $object = NULL, $leading = '[', $trailing = ']');

1
2
3
4
5
6
7
8
9
10

/**
* Implementation of hook_<span class="misspell">nodeapi</span>().
*/
function token_autotag_nodeapi($node, $op) {
  if ($op == 'presave') {
    if (module_exists('token') && $node-&gt;taxonomy['tags'][1] == '') {
      $node->taxonomy['tags'][1] = token_replace(variable_get('token_autotag_pattern', '[month], [language], token-autotag'), 'node', $node);
    }
  }
}

It was easy. What’s next? Lets provide few new tokens that will be used for tagging content.
We will implement Token API hooks:

1

hook_token_list($type = 'all');

This function is used to provide help and in-line documentation for all of the possible replacement tokens.
Note: $type indicates the context that token help is being generated for, so you should show ALL tokens at the same time if $type is ‘all’. As such, the help text should be keyed by the $type context your module will use when doing the actual replacements.

1

hook_token_values($type, $object = NULL);

This function should return a keyed array of placeholders, and their replacement values.
$type contains the current context — ‘node’, ‘user’, ‘global’, etc.
$object contains the specific node, user, etc. that should be used as the basis for the replacements.

For example, we are interested in :
1) what part of the day post was created
- 06:00 - 12:00 : ‘morning’;
- 12:00 - 20:00 : ‘day’;
- 20:00 - 24:00 : ‘evening’;
- 24:00 - 06:00 : ‘night’.

2) size of the post:
- less then 100 words : ‘note’;
- 100 - 1000 words : ‘article’;
- more then 1000 words : ‘narrative’.

1
2
3
4
5
6
7
8
9
10

/**
* Implementation of hook_token_list().
*/
function token_autotag_token_list($type = 'all') {
  if ($type == 'node' || $type == 'all') {
    $tokens['node']['day-part']            = t("Part of the day, when post was created ('morning', 'day', 'everning', 'night')");
    $tokens['node']['post-size-type']  = t("Node type based on size ('note', 'article', 'narrative')");
  }
  return $tokens;
}

2 new tokens - [day-part] and [post-size-type] appeared in the placeholder tokens list, so we update configuration pattern

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

/**
* Implementation of hook_token_values().
*/
function token_autotag_token_values($type, $object = NULL) {
  $values = array();
  switch ($type) {
    case 'node':
      $hour = (int)date('H', $date);
      $values['day-part'] = $hour < 6 ? 'night' : ($hour < 12 ? 'morning' : ($hour < 20 ? 'day' : ($hour < 24 ? 'everning' : 'night')));
      // _token_autotag_get_post_words_amount - method that counts amount of numbers based on some logic
      $words_amount = _token_autotag_get_post_words_amount($node);
      $values['post-size-type'] = $words_amount < 100 ? 'note' : ($words_amount < 1000 ? 'article' : 'narrative');
      break;
  }
  return $values;
}

That’s it! Now you can play with it and provide some new features like give a user opportunity to put placeholders into tag field, specify tag tokens which will mark all nodes even if user inputed few, etc.
If you need real relevant auto-tag utility you can take a look on Taxonomy Autotagger which can automatically tag a node with terms from a vocabulary that the node’s content type is associated with if the terms (or the terms’ synonyms) are found in the content of the node itself. And by the way, now you can build placeholder token that will call Taxonomy Autotagger methods to generate tags and put it in Tag field with your predefined tokens