Ouverture & Innovation

Gérer un site internet avec le WCM Alfresco

adrien — Fri, 13 Mar 2009 15:14:00 +0100

A travers cet article, nous allons étudier le fonctionnement de la partie Web Content Management d'Alfresco. Comme tout CMS, le WCM offre les fonctionnalités suivantes :

plusieurs personnes peuvent travailler sur un docuement
il existe une chaîne de publication
il y a un versioning des documents publiés
les opérations de gestion de forme et de contenu sont séparées

Le principe de fonctionnement du WCM est le suivant: un site internet peut-être enrichi de contenu grâce à l'utilisation de formulaires web classiques facilement utilisables pour des non-informaticiens et permettant de générer un résultat dans une multitude de formats (HTML, Texte, OpenOffice, PDF etc...).

D'un point de vue technique, le formulaire va générer un fichier XML et des templates seront chargés d'aller récupérer les informations qu'il contient pour créer l'affichage. Ces templates peuvent être codés en XSL, en XSL-FO ou bien en Freemarker.

Avant de se lancer dans la réalisation d'un site internet via Alfresco, il est nécessaire de répondre au moins à ces 3 questions :

Quel sera en détails le contenu du site internet, les rubriques à enrichir par des articles, des fiches etc...
Sous quels formats ces informations seront-elles disponibles ?
Quelles seront les personnes chargées d'écrire, de publier et de valider ces articles ?

Pour illustrer le fonctionnement, nous utiliserons un site web J2EE qui nous permettra de poster des informations puis nous verrons comment créer un formulaire web Alfresco et comment lier ces éléments pour gérer notre contenu en ligne.

Afin de faciliter la création du site web et permettre une gestion propre et facile quand il sera en ligne, il est intéressant de créer un répertoire propre à chaque catégorie d'informations où seront stockés les fichiers xml générés par les formulaires. Par exemple, pour une catégorie «informations », nous aurons un répertoire « infos / contenu».

Créer ensuite un Bean nommé "NewsReleaseBean", compilez-le et stockez-le dans le répertoire WEB-INF de votre application.

Une fois vos beans créés, créez un WAR de votre site web, il sera utilisé pour le déploiement par le WCM.

Passons maintenant au formulaire web. Ceux-ci sont générés via un schéma XSD :

<?xml version="1.0"?> 
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema" 
	   xmlns:news="http://www.versusmind.eu/alfresco/news" 
           targetNamespace="http://www.versusmind.eu/alfresco/news" 
           elementFormDefault="qualified"> 

<xs:simpleType name="category"> 
    <xs:restriction base="xs:normalizedString"> 
      <xs:enumeration value="Produits"/> 
      <xs:enumeration value="Entreprise"/> 
      <xs:enumeration value="Général"/> 
      <xs:enumeration value="Téléchargement"/> 
    </xs:restriction> 
  </xs:simpleType> 

  <xs:element name="news_release"> 
    <xs:complexType> 
      <xs:sequence> 
        <xs:element name="title" type="xs:normalizedString"/> 
        <xs:element name="head" type="xs:normalizedString"/> 
        <xs:element name="body" type="xs:string" minOccurs="1" maxOccurs="1"/> 
		<xs:element name="category" type="news:category" default="Général"/> 
		<xs:element name="launch_date" type="xs:date"/> 
      </xs:sequence> 
    </xs:complexType> 
  </xs:element> 
</xs:schema>

On note que l'on peut utiliser des éléments énumérés très facilement. Notre objet « news_release » est composé d'un titre, d'un chapeau d'article, du corps de l'article, d'une catégorie et d'une date de publication. Le nom de l'élément « news_release » sera utilisé dans les autres fichiers.

Modifiez ensuite votre fichier WEB.XML pour y mapper votre fichier TLD correspondant au namespace news déclaré ci-dessus.

Créez ensuite deux fichiers template, le premier codé en XSL permettra l'affichage des données XML au format HTML, le second, codé en freemarker, génèrera un fichier OpenOffice.

Nous disposons donc maintenant d'un fichier WAR contenant notre site web, d'un fichier XSD qui est le squelette du formulaire web permettant de poster du contenu de type "News", d'un fichier XSL pour afficher les news au format HTML et d'un fichier Freemarker qui créera un fichier OpenOffice.

Connectez-vous maintenant à Alfresco en tant qu'admin et allez dans "Data Dictionnary" puis dans "Web Forms"

Allez chercher votre fichier XSD

Dans name et title, vous pouvez laisser « news-release », dans « Description », mettez « Formulaire permettant de poster une news ». Dans « output path pattern », laissez « ${name}.xml », cliquez ensuite sur « Next »

On arrive ensuite sur l'interface permettant de sélectionner les templates. Commencez par aller chercher votre fichier « news-releases.xsl »

Alfresco a automatiquement détecté que le template est du « XSLT ». Laissez « name » et « title » tels quels. Donnez une description. Dans « Rendition mimetype », il faut sélectionner HTML, laissez « output path pattern » tel quel. Enfin, cliquez sur « Add to List »

Faites la même chose avec le fichier « news-release-odt.ftl » qui gère le template ODT et sélectionnez « OpenDocument Text ». Ajoutez à la liste puis cliquez sur « Next ».

La phase suivante offre la configuration du « workflow » qui sera appliqué par défaut à chaque fois que le formulaire sera appelé. Les formulaires étant réutilisables par plusieurs sites web, il faut essayer d'être généraliste et être certain que l'action par défaut ne posera pas de problèmes. Pour le moment, sélectionnez « no not now », on le configurera spécifiquement pour notre site web tout à l'heure. Cliquez sur « Next » et finalisez la création en cliquant sur « Finish ».

Maintenant, cliquez sur « Web Projects » dans le menu de gauche puis cliquez sur « Create » et « Create web project »

Dans « name », donnez un nom à votre site internet, dans « DNS name » mettez la même chose. Laissez « webapp » sur « ROOT ». Vous pouvez ensuite définir « Title » et « Description ». Laissez décochée la case « use as a template ».

La seconde étape permet de sélectionner la façon dont est créé le projet, soit on en crée un nouveau, soit on se base sur un projet déjà existant.

La troisième étape laisse la possibilité d'ajouter des serveurs de déploiement puis la quatrième étape va lier notre projet à des formulaires en les paramétrant. Cliquez sur « Add to List » pour ajouter le formulaire « news-release » à notre projet.

Cliquez sur "Web form details"

Dans « output pah pattern », il faut mettre le chemin vers le dossier dans lequel on stockera les fichiers XML.

${webapp} et ${name}.xml sont deux variables qui représentent le répertoire de l'application et le nom du fichier.

Dans « Workflow », sélectionnez celui proposé et validez.

On remarque que le bouton « Configure workflow » est devenu actif.

Ensuite, cliquez sur « Configure Templates »

Dans « output path pattern » il faut mettre les mêmes informations que précédemment mais on rajoute la variable ${extension} après le nom du fichier.

Validez et demandez ensuite à configurer le Workflow.

Il existe deux types de Workflow, « Serial » et « Parallel »

Le mode « Serial » va mettre en place une chaîne de validation du type « A valide, puis B valide, puis C valide etc... » où A, B et C sont des validateurs.

Le mode parallèle demande également une validation par A, B et C mais il n'y a pas d'ordre prédéfini.

Pour le moment, choisissez « Serial » puis cliquez sur « Search », la liste des utilisateurs apparaît. Sélectionnez ceux que vous souhaitez inclure dans la chaîne de validation et l'ordre dans lequel la validation se fera.

Ici, Adrien devra valider pour que Benoît reçoive une demande de validation. Lorsque Benoît aura validé, le processus sera terminé et le contenu sera en ligne.

L'étape cinq gère la configuration du workflow pour les éléments qui ne sont pas générés par des web-forms.

Faites « Add to list » puis « Configure workflow ». Comme précédemment, sélectionnez les utilisateurs qui devront valider les éléments. Le filename pattern match « .* » permet de configurer précisément les fichiers qui devront être validés par ce workflow en remplaçant l'étoile par l'extension du ou des fichiers.

Validez votre choix puis passez à l'étape 6 qui va gérer les liens utilisateurs / rôles.

Sélectionnez un utilisateur et un rôle puis « Add to List ».

Adrien va être « Content Manager » il peut publier des articles, éditer le contenu du site etc... Benoît est « Content Reviewer », il peut relire les articles mais ne peut pas en écrire. Pierre est « Content Publisher » et pourra écrire et éditer du contenu.

A chaque utilisateur sera liée une « sandbox ». Cette fonctionnalité est extrêmement intéressante et nécessaire pour assurer un bon travail d'équipe et réduire les erreurs. Chaque utilisateur va pouvoir accéder à une copie du site web sur laquelle il pourra tester ses modifications avant de les soumettre à la publication. Par exemple, les développeurs pourront tester leur code, les rédacteurs visualiser leurs articles etc... A chaque modification validée, la copie présente dans chaque sandbox est mise à jour.

L'étape finale de création propose d'envoyer un email aux différents utilisateurs pour leur faire savoir qu'ils vont participer au projet. Validez la création, Alfresco affiche alors la partie « Web projects » où notre site est désormais présent.

Cliquez sur le titre du site, on arrive alors sur la page présentant les différents « sandboxes ». La « staging SandBox » est celle qui contient le site web en ligne, « My Sandbox », comme son nom l'indique, est l'espace au sein duquel il est possible de tester les modifications.

Nous allons maintenant importer notre site web. Dans la partie « My Sandbox », cliquez sur « Browse Website », ensuite cliquez sur « Create » puis « Bulk import »

Allez chercher votre fichier WAR contenant le site web puis cliquez sur « Ok », patientez quelques secondes le temps qu'Alfresco réalise le déploiement. Si tout se déroule correctement, le squelette du site web apparaît.

En cliquant sur « Preview Website », le site web apparaît dans une nouvelle fenêtre.

Il faut maintenant soumettre le site à la validation, des utilisateurs. Pour se faire, retournez dans votre sandbox puis cliquez sur « Modified Items ».

Sélectionnez tous les items et cliquez sur « submit selected ». Une page d'information apparaît, elle permet d'informer les utilisateurs chargés de la validation et si besoin de modifier le workflow.

Validez l'envoi, déconnectez-vous d'Alfresco et reconnectez-vous avec le ou les utilisateurs chargés de valider le contenu hors « formulaires ».

Sur la page d'accueil, la liste des tâches à réaliser est affichée. Il doit y avoir celle que nous venons de soumettre. Cliquez sur le titre, une page de détails s'affiche. Celle-ci nous offre plusieurs options comme donner un statut à la présente validation, laisser des commentaires ou agir sur les fichiers. Le petit menu de droite permet de sauvegarder, d'approuver ou de rejeter directement le contenu. Cliquez sur « Approve ». Faites de même si vous avez d'autres utilisateurs et dans l'ordre de la chaîne de publication.

Connectez-vous maintenant avec un utilisateur chargé de gérer du contenu. Dans sa sandbox, cliquez sur « web forms », puis sur « Create Content » dans la ligne correspondant à votre formulaire.

Renseignez le champ « Name », ce sera le nom du fichier XML généré. Laissez les autres champs tels quels.

Notre fichier « news-release.xsd » est appelé par Alfresco qui, grâce à Xforms, va créer le formulaire.

Remplissez les champs puis validez.

Alfresco a créé le fichier XML ainsi que les deux templates pour la visualisation ODT et HTML.

Pour soumettre cet article, vous pouvez procéder comme précédemment avec le site web ou bien cochez la case « Submit these 3 files when wizard finishes ». Il ne vous reste plus qu'à effectuer la validation avec les différents utilisateurs.

Lancez ensuite une visualisation du site web puis allez dans la catégorie contenant l'article posté

Notre article est bien présent, en cliquant sur le titre, on peut le voir en détails

Enfin, cliquez sur le lien « Télécharger la news en ODT » pour charger le fichier OpenOffice correspondant.

Il ne reste plus qu'à répéter la procédure avec d'autres formulaires pour enrichir le site.

Analyse géographique sous Pentaho

adrien — Thu, 05 Mar 2009 17:26:00 +0100

Nous allons voir comment réaliser un tableau de bord avec l'API Google Maps sous la plateforme Pentaho. Ce tableau de bord devra permettre l'affichage sur la carte des différents clients d'une entreprise ainsi que le nombre de rendez-vous déjà effectués avec ceux-ci. Lorsque l'on cliquera sur un point de la carte, une petite fenêtre apparaîtra avec une jauge représentant le nombre de rendez-vous par rapport à un nombre maximal défini. Les points sur la carte pourront prendre 3 couleurs différentes selon la valeur du nombre de rendez-vous. Il sera possible de changer les valeurs des intervalles ce qui influera en temps réel sur la couleur des points.

Pour se faire, nous allons créer et modifier plusieurs fichiers. La première étape consiste à présenter succinctement la table qui contiendra nos données. Le modèle physique est le suivant :

TABLE client(id,org_name,adr_town,adr_one_locality,adr_one_postalcode,rdv) 
id : identifiant, clé primaire, ENTIER
org_name : nom du client, CHAINE
adr_town : adresse du client, CHAINE
adr_one_locality : ville du client, CHAINE
adr_one_postalcode : code postal, CHAINE
rdv : nombre de rendez-vous, ENTIER

Dans le répertoire d'installation de pentaho, allez sous « pentaho-solutions », puis dans le répertoire où vous souhaitez voir apparaître votre tableau de bord.

1.Créez un sous-répertoire « google »

2.A l'intérieur de celui-ci, créez un fichier « index.xml » qui contiendra le code suivant :

<index> 
	<name>%name</name> 
	<description>%description</description> 
	<icon></icon> 
	<visible>false</visible> 
	<display-type>list</display-type> 
</index>

3.Créez un fichier « index.properties » :

description=Google maps
name=Google

4.Dans le répertoire de niveau supérieur, créez un fichier google_map.url, ce fichier va nous permettre de spécifier le fichier à appeler pour l'affichage.

[InternetShortcut] 
URL=/pentaho/Map2 
[navigation] 
Name=%url_name 
Description=%url_description 
Icon=dashboard.jpg 
Target=google_map

5.Créez un fichier google_map.properties :

url_description= Pentaho google maps
url_name = Localisation clients

6.Editez le fichier « web.xml » et ajoutez l'appel à une page JSP que vous créerez pour l'occasion et qui sera une copie de celle fournie par Pentaho.

7.Créez un fichier Xaction et sauvegardez-le dans le sous-répertoire « google » sous map1.xaction

<?xml version="1.0" encoding="UTF-8"?> 
<action-sequence> 
  <name>CurrentPositionTitles.xaction</name> 
  <title>data for map</title> 
  <version>1</version> 
  <logging-level>debug</logging-level> 
  <documentation> 
    <author>Votre nome</author>  
    <description>description</description>  
    <help/>  
    <result-type>rule</result-type>  
    <icon></icon> 
  </documentation> 

  <inputs> 
    <dept type="string"> 
      <default-value>Google maps</default-value>  
      <sources> 
        <request>dept</request> 
      </sources> 
    </dept> 
  </inputs> 

  <outputs> 
    <data type="result-set"/> 
  </outputs> 

  <resources/> 
  
  <actions> 
    <action-definition> 
      <component-name>SQLLookupRule</component-name> 
      <action-type>Perform SQL Query</action-type> 
      <action-inputs> 
        <dept type="string"/> 
      </action-inputs> 
      <action-outputs> 
        <query-result type="result-set" mapping="data"/> 
      </action-outputs> 
      <component-definition> 
      <jndi>Nom du datasource</jndi>  
    	<query><![CDATA[votre requête SQL]]></query> 
      </component-definition> 
    </action-definition> 
 
  </actions> 
</action-sequence>

8. Ouvrez le fichier jsp créé à l'étape 6, nous allons y apporter quelques modifications et éclairer quelques points intéressants.

int topthreshold = 100000;
int bottomthresold = 50000;

correspondent aux deux seuils servant d'intervalles à la coloration des points.

<script language=\"javascript\" src=\"js/pentaho-ajax.js\"></script>\n
[...]
<script language=\"javascript\" src=\"js/google-demo.js\"></script>\n" ); 
[...]
"onload=\"load()\" onunload=\"GUnload()\"

Nous appelons ici deux fichiers javascript fournis par Pentaho : pentaho-ajax.js et google-demo.js

Faites une copie de google-demo.js et modifiez le lien ci-dessus.

Nous constatons qu'au chargement de la page, la fonction load() de google-demo est appelée.

runtime = SolutionHelper.doAction( "repertoire",  "sous-repertoire",  	"map1.xaction",  	"MyMap.jsp",  parameters,  userSession,  messages,  null 	);

Répertoire : votre répertoire de travail Sous-répertoire : le sous-répertoire où se trouve map1.xaction (par défaut google).

Par défaut sont déclarées les variables suivantes :

String customerNum = ""; 
String customer = ""; 
String city = ""; 
String state = ""; 
String zip = ""; 
String value = "";

Changeons-les en :

String id =""; 
String org_name=""; 
String adr_town=""; 
String adr_one_postalcode=""; 
String adr_one_locality=""; 
String rdv="";

Ensuite, nous arrivons sur la fonction « addPoints » qui va permettre l'ajout des points sur la carte via un enchaînement d'appel à des fonctions javascript. La boucle « for » va traiter chaque ligne retournée par la requête SQL de map1.xaction, il faut modifier le bloc d'attribution des variables de la façon suivante, afin de caster correctement les variables.

id  = results.getValueAt(row,0).toString(); 
org_name = (String)results.getValueAt(row,1); 
adr_town = (String)results.getValueAt(row,2);				 
adr_one_postalcode = (String)results.getValueAt(row,3); 
adr_one_locality = results.getValueAt(row,4).toString(); 
rdv = results.getValueAt(row,5).toString();

row est une ligne de résultat, l'indice correspond à la position de la valeur à rechercher dans row.

showAddress est ensuite utilisée. Cette fonction prend plusieurs paramètres :

l'adresse à trouver
le nom du client
l'identifiant
le nombre de rendez-vous
un booléen à laisser à faux

on a donc le code suivant :

showAddress( "<%= adr_town %>,<%= adr_one_locality %>, <	%=adr_one_postalcode %>,FRANCE", "<%= org_name %>", "<%= id %>", <%= rdv 	%>, false );

On peut bien évidemment changer « FRANCE » par un autre pays. Le reste du code est de l'HTML et va générer l'affichage. Vous pouvez le modifier comme bon vous semble. Il convient juste de garder un div ayant comme id la valeur « map », ce div contiendra la carte. Il y a deux select box qui permettent de changer à la volée les valeurs des intervalles. On peut bien évidemment modifier ces valeurs pour que cela corresponde au minimum et au maximum fournis par nos données.

Passons maintenant au fichier « google-demo.js ». Il faut commencer par changer les valeurs des variables : topThreshold et bottomThreshold pour qu'elles correspondent aux valeurs fournies dans le fichier jsp. Ensuite, nous déclarons trois types d'icônes qui vont être utilisés pour différencier les groupes de valeurs (vert, jaune, rouge).

La première fonction est load(), elle permet de charger une carte, de la centrer sur un point précis, d'y ajouter les contrôles de zoom et de switch d'affichage, et les points sur la carte via « addPoints ».

La seconde fonction, « customerClick » va gérer les actions lors du clic sur un point. On appelle la méthode ajax pentahoAction sur le fichier dial1.xaction en passant des paramètres : - le client - la valeur courante du nombre de rendez-vous - la valeur max du nombre de rendez-vous - la valeur du premier seuil - la valeur du second seuil Enfin, on indique que le callback se fera sur la méthode UpdateInfoWindow.

UpdateInfoWindow va afficher une petite boîte contenant les informations renvoyées par dial1.xaction, notamment le graphique type jauge.

Il faut ensuite commenter l'appel à chart.xaction qui lui, génère un ensemble de statistiques. Il ne nous intéresse pas dans notre exemple

La fonction showAddress que nous utilisons via le fichier JSP va générer un tableau contenant différentes informations puis appeler la fonction qui affiche le marqueur sur la carte. La fonction showMarker va permettre d'attribuer une couleur à chaque marqueur selon la valeur des intervalles et la valeur de l'enregistrement passé en paramètre.

Enfin, la méthode update, appelée lors du changement d'une valeur des select box, s'occupe de régénérer les points avec les bonnes couleurs de marqueurs en rapport aux nouvelles valeurs.

Nous avons fait le tour des principales fonctions et fichiers à utiliser pour créer notre tableau de bord et pouvons maintenant étudier une fonctionnalité intéressante de Google Maps, la création de zones de sélection cliquable.

Nous allons utiliser une surcouche javascript disponible sous licence Creative Commons. Ce fichier « epoly.js » est disponible sur le site suivant : http://econym.googlepages.com/index.htm

Ce fichier JS est à inclure dans le fichier JSP. Ensuite, il faut créer un fichier XML qui respecte la nomenclature suivante :

<states> 
<state name ="nom_pays" colour="couleur_carte" >
	<point lat=valeur lng=valeur />
	<point lat=valeur lng=valeur />
	etc...
</state>
<state>
...
</state>
</states>

Chaque polygone sera donc défini par un ensemble de points.

Dans le fichier JSP, il faut ajouter le code suivant :

 //<![CDATA[ 
  if (GBrowserIsCompatible()) { 
 
      var polys = []; 
      var labels = []; 

      // Récupération de la carte, ajout des contrôles et centrage
      var map = new GMap2(document.getElementById("map")); 
      map.addControl(new GLargeMapControl()); 
      map.addControl(new GMapTypeControl()); 
      map.setCenter(new GLatLng(42.16,-100.72),4); 

	// Définition de la méthode appelée lors du click sur une zone
      GEvent.addListener(map, "click", function(overlay,point) { 
        if (!overlay) { 
          for (var i=0; i<polys.length; i++) { 
            if (polys[i].Contains(point)) { 
              var area = polys[i].Area()/1000000; 
              var sqmiles = area/2.58998811; 
              map.openInfoWindowHtml(point,"You clicked on "+labels[i]+"<br>The 			area of "+labels[i]+" is "+parseInt(area) 
                 	+" sq km.<br>that's "+parseInt(sqmiles)+" square miles<br>" 
                  +"Its boundary is "+parseInt(polys[i].Distance()/1609.344)+" 			miles long" 
              );
              i = 999; // Jump out of loop 
            } 
          } 
        } 
      }); 

      // Lecture du fichier XML
      var request = GxmlHttp.create(); 

	// récupération du fichier XML
      request.open("GET", "jsp/states.xml", true); 
      request.onreadystatechange = function() { 
      if (request.readyState == 4) { 
          var xmlDoc = GXml.parse(request.responseText); 
	 
          // Récupération des élements « state »
          var states = xmlDoc.documentElement.getElementsByTagName("state"); 
	 
	    // Création des polygones
          for (var a = 0; a < states.length; a++) { 
            var label  = states[a].getAttribute("name"); 
            var colour = states[a].getAttribute("colour"); 
            var points = states[a].getElementsByTagName("point"); 
            var pts = []; 
            for (var i = 0; i < points.length; i++) { 
               pts[i] = new GLatLng(parseFloat(points[i].getAttribute("lat")), 
                                   parseFloat(points[i].getAttribute("lng"))); 
            } 
	 
            var poly = new Gpolygon(pts,"#000000",1,1,colour,0.5,					{clickable:false}); 
            polys.push(poly); 
            labels.push(label); 
            map.addOverlay(poly); 
          } 
          // ================================================           
        } 
      } 
      request.send(null); 
    } 

  
    
    // Si le navigateur n'est pas compatible
    else { 
      alert("Sorry, the Google Maps API is not compatible with this browser"); 
    } 

    // Ajout d'une icône sur la carte
    var tinyIcon = new GIcon(G_DEFAULT_ICON); 
    tinyIcon.image = "http://labs.google.com/ridefinder/images/mm_20_red.png"; 
    tinyIcon.iconSize = new GSize(12, 20); 
    tinyIcon.shadowSize = new GSize(22, 20); 

    var markerOptions = { icon:tinyIcon }; 
    var point = new GLatLng(35.8659,-108.5715); 
    map.addOverlay(new GMarker(point,markerOptions)); 
     
    //]]> 
    </script>

Ces exemples sont bien évidemment paramètrables à volonté, notamment via la requête SQL et les interactions que l'on souhaite offrir à l'utilisateur.

Workflow de demande de congés eGroupWare

Nicolas — Mon, 16 Jun 2008 14:55:00 +0200

Le module WorkFlow d'eGroupWare permet, comme son nom l'indique, de gérer des workflow, c'est à dire des processus internes au sein d'eGroupWare.

Ce module est basé sur le moteur de Workflow OpenSource Galaxia. La documentation sur le module WorkFlow d'eGroupWare est pour le moment très limitée, celle de Galaxia est donc d'une grande aide.

Les possibilités de création de processus sont nombreuses grâce à l'accès à l'API d'eGroupWare (langage PHP)

Principe et nomenclature

Les processus gérés par le module WorkFlow sont divisée en activités reliées par des transitions.
Une activité peut être interactive, c'est à dire qu'un utilisateur va devoir effectuer une action.
La gestion des droits s'effectue à l'aide de rôles.
Chaque lancement d'un processus est une instance.

Création d'un processus

La première étape de création d'un processus est sa modélisation:

assignation des rôles à des utilisateurs/groupes, des
création des activités (au minimum deux: start et end)
rattachement des activités entre elles

On peut alors visualiser le cheminement via un graphique

La deuxième étape consiste à développer les activités interactives à l'aide d'une interface donnant accès au code PHP et au template html.
Il est possible d'ajouter un agent SMTP à une au plusieurs activités d'un processus afin d'envoyer des mails.
Il est aussi possible d'interagir avec les autres modules d'eGroupWare. Par exemple, l'ajout d'un événement dans le calendrier.

Processus de demande de congés

Voici un exemple de processus de gestion d'une demande de congés:

L'utilisateur demande un congé en indiquant une plage de date sur eGroupWare.
Le validateur reçoit un email lui indiquant qu'une demande de congé a été effectuée. (agent mail_smtp)
Le validateur valide, ou non, cette demande sur eGroupWare.
Si la demande est validée, la plage de congés est incluse dans le calendrier eGroupWare.
L'utilisateur reçoit un email lui indiquant que sa demande de congé a été traitée. (agent mail_smtp)

Graphique:

Interfaces graphiques avec AutoIT3 et KODA

Pierre — Fri, 02 May 2008 18:07:00 +0200

Suite à notre article sur le langage de script AutoIT 3 (lire l'article), cet article a pour but de présenter le programme permettant de créer rapidement des interfaces graphiques avec AutoIT, à la manière du Form Designer du Visual Basic.

Rappel

AutoIT3 (adresse) est un langage de script concurrent du langage KiXtart utilisé notamment pour l'administration de parc Windows. Il présente un langage simple à appréhender, puissant et de nombreux modules ont été créés pour ajouter de nouvelles fonctionnalités. Certaines de ces fonctionnalités feront l'objet d'un article.

Présentation

KODA est un programme additionnel à AutoIT3 pour concevoir ses IHM de manière graphique. Vous pouvez le télécharger à partir du forum d'AutoIT3 : http://www.autoitscript.com/forum/index.php?showtopic=32299&hl=koda. L'interface peut être sauvegardée au format kxf (xml) pour être remodifiée par la suite. Le format de sortie final de KODA est cependant du code AutoIT3 définissant l'interface. A la différence du Visual Basic qui stocke ses frames (interface + code) dans des fichiers séparés intégrés à la compilation, AutoIT3 intègre le code de génération des interfaces directement dans le fichier source « au3 ».

Description de l'interface

L'interface est découpée en différents blocs : En haut, la barre de menus, les boutons d'ouverture/sauvegarde, d'exécution et d'import (nous y reviendrons par la suite) et les contrôles à insérer dans le formulaire. Au milieu à gauche, l'Object TreeView qui montrera l'organisation hiérarchique entre les différents objets. Il s'agit d'un « explorateur » de fenêtre. Au centre, la fenêtre vierge sur laquelle nous travaillons. A droite, la « Form List » qui permet de gérer différentes fenêtres. En bas à gauche, l'« Object Inspector » qui permet de régler les différents paramètres de chaque élément de la fenêtre (nom, contenu textuel, taille...)

Utilisation de l'interface

Pour placer un contrôle sur la fenêtre, il suffit de cliquer sur le contrôle désiré, puis sélectionner une zone sur la fenêtre en faisant un glisser-déposer.

Exemple : Voir ci-dessous, nous venons de placer un bouton sur l'interface.

Si on souhaite le déplacer, il suffit de cliquer dessus pour le sélectionner, puis faire un glisser-déposer jusqu'à sa destination.

L'inspecteur d'objet

L'inspecteur d'objet permet de régler finement l'apparence de vos contrôles (taille, couleur, police...). Il permet également de spécifier le contenu textuel de vos zones de texte (champ caption), ainsi que le nom de votre contrôle (champ name). Dans un souci de clarté de code, nous vous recommandons de définir les noms des contrôles que vous allez utiliser dans votre programme (lire une valeur d'un champ, détecter un clic sur un élément...).

Dans l'exemple suivant, le bouton a été nommé « ButValid » et contient le texte « Continuer ».

Export et intégration dans votre programme AutoIT3.

Les deux boutons à droite du bouton d'enregistrement servent respectivement à afficher le code source AutoIT3 et à prévisualiser l'interface. -Le premier affichera le code source dans une petite fenêtre avec un bouton pour copier le code dans le presse-papier.

Voici un exemple de notre fenêtre pour afficher un contrat de licence et demander l'acceptation de celui-ci :

#include <ButtonConstants.au3>
#include <GUIConstantsEx.au3>
#include <StaticConstants.au3>
#include <WindowsConstants.au3>

#Region ### START Koda GUI section ### Form=
$Form1 = GUICreate("Form1", 633, 447, 1561, 164)
$ButValid = GUICtrlCreateButton("Continuer", 424, 400, 121, 25, 0)
$Label1 = GUICtrlCreateLabel("Label1", 8, 8, 620, 377)
GUICtrlSetBkColor(-1, 0xFFFFFF)
$Radio1 = GUICtrlCreateRadio("Oui", 272, 392, 121, 25)
$Radio2 = GUICtrlCreateRadio("Non", 272, 416, 121, 25)
$Label2 = GUICtrlCreateLabel("Acceptez-vous les termes du contrat de licence ?", 24, 400, 237, 17)
GUISetState(@SW_SHOW)
#EndRegion ### END Koda GUI section ###

While 1
	$nMsg = GUIGetMsg()
	Switch $nMsg
		Case $GUI_EVENT_CLOSE
			Exit

	EndSwitch
WEnd

-Le deuxième va directement ouvrir l'éditeur Scite avec le code source présent. L'intérêt est de pouvoir tester en grandeur nature ce à quoi l'interface va ressembler à l'exécution. Appuyez simplement sur la touche <F5> pour lancer le programme.

Interagir avec les contrôles dans le code

Détecter un clic :

Le switch GUIGetMsg() permet de savoir quel contrôle envoie un événement. Pour savoir si notre bouton a été pressé, il suffit de rajouter un Case $NomDuControle. La boucle ressemble alors à cela :

While 1
	$nMsg = GUIGetMsg()
	Switch $nMsg
		Case $GUI_EVENT_CLOSE
			Exit
		Case $ButValid
			MsgBox(0,''Bouton pressé'',''C'est le bouton continuer qui a été pressé'')
	EndSwitch
WEnd

Ce code permettra d'avoir une alerte qui s'affichera lorsque l'utilisateur cliquera sur le bouton « Continuer ».

De manière générale, tout contrôle est cliquable, dans la mesure où l'on peut intercepter l'évènement via cette boucle.

Obtenir les paramètres des contrôles

Nous avons placé deux boutons radio permettant de savoir si l'utilisateur a accepté ou non la licence. Il serait intéressant de savoir quel bouton a été coché pour agir en conséquence. Pour cela, il suffit d'utiliser la fonction GUICtrlRead avec la variable du contrôle en paramètre. Ce qui donne le code suivant :

While 1
	$nMsg = GUIGetMsg()
	Switch $nMsg
		Case $GUI_EVENT_CLOSE
			Exit
		Case $ButValid
			if GUICtrlRead($Radio1) = 1 Then
				msgbox(0,"Merci","Vous avez accepté le contrat de licence !")
				;Insert installation code here
			Else
				msgbox(0,"Erreur","Vous n'avez pas accepté le contrat de licence !")
				Exit
			EndIf
	EndSwitch
Wend

Conclusion

AutoIT3 est déjà en soi un outil puissant pour réaliser nombre de tâches d'administration ou autre. Grâce à KODA, la création d'interfaces graphiques devient encore plus simple et augmente le potentiel du langage pour un investissement en temps minimal. Cet article ne couvre qu'une partie des possibilités de KODA et du système d'interface graphique de manière générale, mais il permet au développeur néophyte de connaître les fonctions de base pour commencer à créer une interface graphique pour ses programmes. Pour plus d'informations, le mieux est de consulter la documentation officielle d'AutoIT3, surtout les fonctions commençant par « GUI ». Chaque fonction est commentée et comporte un exemple.

Annexe

Voici le code source de la fenêtre d'acceptation de licence :

#include <ButtonConstants.au3>
#include <GUIConstantsEx.au3>
#include <StaticConstants.au3>
#include <WindowsConstants.au3>

#Region ### START Koda GUI section ### Form=
$Form1 = GUICreate("Form1", 633, 447, 1561, 164)
$ButValid = GUICtrlCreateButton("Continuer", 424, 400, 121, 25, 0)
$Label1 = GUICtrlCreateLabel("Please Insert License Here", 8, 8, 620, 377)
GUICtrlSetBkColor(-1, 0xFFFFFF)
$Radio1 = GUICtrlCreateRadio("Oui", 272, 392, 121, 25)
$Radio2 = GUICtrlCreateRadio("Non", 272, 416, 121, 25)
$Label2 = GUICtrlCreateLabel("Acceptez-vous les termes du contrat de licence ?", 24, 400, 237, 17)
GUISetState(@SW_SHOW)
#EndRegion ### END Koda GUI section ###



 While 1
 	$nMsg = GUIGetMsg()
 	Switch $nMsg
 		Case $GUI_EVENT_CLOSE
 			Exit
 		Case $ButValid
 			if GUICtrlRead($Radio1) = 1 Then
 				msgbox(0,"Merci","Vous avez accepté le contrat de licence !")
 				;Insert installation code here
 			Else
 				msgbox(0,"Erreur","Vous n'avez pas accepté le contrat de licence !")
				Exit
 			EndIf
 	EndSwitch
 WEnd

Quel est le TCO d'Office 2007 ?

Benoît — Thu, 08 Nov 2007 17:14:00 +0100

A l'heure actuelle, dans une organisation, lorsqu'est menée la réflexion sur l'évolution, voire le changement, de suite bureautique, la question de l'arbitrage du TCO (ou "coût total de possession") se pose rapidement. C'est un calcul savant mais parfois aléatoire qui permet de déterminer l'ensemble des coûts générés par la possession d'un logiciel bien au-delà du simple coût de licence. C'est donc une variable essentielle de prise de décision.

Lorsque l'on décide de comparer la migration de Microsoft Office à OpenOffice, il est naturel d'inclure dans ce calcul des éléments de coûts tels que :

La formation des employés à une interface un peu différente,
La gestion du format de document OpenDocument et les relations avec les correspondants extérieurs à l'organisation,
Les coûts de déploiement et d'administration d'un produit non Microsoft,
La compatibilité éventuelle des macros et des applications métiers.

Si dans l'esprit des décideurs, ces éléments de calcul du TCO pour OpenOffice sont assez naturels et répandus, il est beaucoup plus rare que ce même raisonnement soit appliqué pour Microsoft Office 2007 alors qu'il a encore toute raison d'être.

Formation du personnel

Si l'on considère, à juste titre, que le saut d'Office 2000, XP ou 2003 à OpenOffice nécessite impérativement une formation des équipes, que dire alors pour Office 2007 ? Le ruban de l'interface d'Office 2007 est vendu comme la révolution ultime de l'interface utilisateur. Il l'est peut-être, mais à cause de cela, il rend l'interface utilisateur extrêmement différente de la classique interface bureautique. On peut raisonnablement penser qu'OpenOffice est plus proche d'une interface bureautique classique qu'Office 2007.
Passons à la comparaison :

Office 2003:

OpenOffice 2.3:

Office 2007:

La première et la deuxième copie d'écran sont presque identiques. Ils ont des icônes de mise en page similaires (nouveau, ouvrir, enregistrer, e-mail, etc.), des menus déroulants etc... Office 2007 change tout. Certains icônes sont cachés, d'autres sont au mauvais endroit. Certains menus n'existent pas, les barres d'outils sont par onglets etc...

Les utilisateurs auront à développer de nouvelles habitudes et de réflexes bureautiques.

Formats de fichier et compatibilité

Il est un élément qui est moins présent dans les esprits que pour OpenOffice, c'est qu'Office 2007 arrive également avec un nouveau format de document : le format OpenXML, renvoyant instantanément au placard le bon vieux format de fichier de MS Office 97/XP/2003 qui n'avait que très peu évolué depuis plus de 10 ans. Ce format OpenXML totalement nouveau est incompatible avec les versions précédentes de Microsoft Office.
Voici un petit tableau comparatif des deux formats de document :

	OpenDocument (ODF)	OpenXML (MS Office 2007)
Format ouvert	Oui	En partie
Basé sur le XML	Oui	Oui
Reconnu nativement par Office 2003	Non	Non
Reconnu nativement par OpenOffice 2.3	Oui	Non
Reconnu nativement par Office 2007	Non	Oui
Plug-in de conversion pour Office 2003	Oui	Oui
Plug-in de conversion pour Office 2007	Oui	Oui
Plug-in de conversion pour OpenOffice 2.3	Oui	Oui

Nous voyons donc avec ce tableau que tant OpenOffice que Microsoft Office imposent un changement du format de document et apportent comme corollaire les problématiques de compatibilité de l'existant et de format d'échange avec l'extérieur de l'organisation.
C'est une réflexion supplémentaire qui s'impose ou va s'imposer à toutes les organisations dans la mesure où quelle que soit la suite bureautique adoptée, le format de document ne sera plus le standard « de fait » .doc ou .xls.

La compatibilité des macros

On pourrait penser qu'en optant pour Office 2007, l'organisation s'exonère des questions de compatibilité des macros écrites. Il n'est est rien. Deux éléments imposent en effet une sérieuse remise en question.
La garantie de compatibilité de Microsoft ne couvre que la suite Office 2000. Comme beaucoup d'organisations sont encore restées à Office 97, elles sortent du périmètre de compatibilité.
Des changements considérables ont été apportés à la version 2007 de la suite Microsoft Office, notamment en matière de navigation et d'interface. La disparition de certaines fonctionnalités ou l'apport de modifications dans les procédures à suivre pour effectuer des actions, par exemple, peuvent donc être à l'origine d'un mauvais fonctionnement de certaines macros créées dans des versions antérieures de la suite Office.

Quel est le coût réel d'Office 2007?

Ces différentes modalités mettent en évidence des éléments qui sont souvent oubliés dans une étude d'opportunité qui se pose ou se posera pour chacune des organisations. Avec l'arrivée des nouveaux formats bureautiques, le standard de document bureautique change entraînant avec lui un choix nécessaire et une prise de décision indispensable.

AutoIt 3 - Langage de script pour administration Windows

Pierre — Tue, 30 Oct 2007 18:40:00 +0100

Après avoir vu le titre, certains lecteurs vont penser qu'il s'agit là d'un concurrent direct de KIX avec son célèbre Kixtart (http://www.kixtart.org/). Ce n'est pas tout à fait vrai, même si l'on retrouve des fonctions communes. AutoIT est un langage de programmation orienté administration Windows, sans être pour autant restreint dans cet usage. Actif, doté d'une communauté conséquente et facilement utilisable et extensible, c'est un langage amené à être de plus en plus connu et répandu.

Accès direct : http://www.autoitscript.com/autoit3/

Introduction

Traduction de la description d'AutoIt trouvée sur le site officiel :

AutoIt v3 est un langage de script inspiré du BASIC pour automatiser l'interface de Windows et l'exécution de tâches en général. Il utilise une combinaison de simulation d'appui de touches du clavier, de mouvements de souris de manipulation de fenêtre pour automatiser des tâches qu'il n'est pas possible (ou pas efficace) de réaliser avec d'autres langages (par exemple : VBScript et ses SendKeys). Il permet de générer de petits programmes, auto-contenus et fonctionnera sur toutes les versions standard de Windows, sans avoir à gérer la contrainte des libraires additionnelles.

AutoIt a été conçu au début pour le déploiement de PC pour automatiser et configurer efficacement des milliers de PC. Au fur et à mesure de l'avancement, il est devenu un langage puissant qui supporte les expressions complexes, les fonctions définies par l'utilisateur, les boucles et tout ce que des développeurs confirmés pourraient attendre.

Nous utilisons AutoIT, notamment dans le cadre d'un script de déploiement personnalisé d'OpenOffice. Ce script peut s'insérer dans un Kixtart existant ou fonctionner indépendamment à la demande ou à l'ouverture de session.

AutoIT est livré avec une version modifiée de l'éditeur de texte Scythe qui intègre la coloration syntaxique du langage et des info-bulles pour rappeler les paramètres des fonctions. Des fonctions supplémentaires permettent de compiler et lancer le programme depuis Scythe.

Programme indépendant

Un des avantages d'AutoIt est qu'il peut se déployer sous forme d'un script (.au3) ou sous forme d'un exécutable. Dans ce dernier cas, il n'aura besoin d'aucune librairie externe pour fonctionner (sauf si vous faites appel à des DLL externes, voir plus loin). Cela permet de répandre une application rapidement sans avoir à faire de programme d'installation sur tout un réseau.

Exécuter en tant que...

LA fonction la plus importante d'AutoIt est qu'il propose un jeu de fonctions permettant d'exécuter des commandes avec des droits d'adminitrateur. Quel est l'avantage ? Mettons que sur votre réseau, les utilisateurs n'ont pas le droit d'installer de nouvelles applications. En VBS, il est possible d'utiliser un « Shell.Run » pour lancer l'application d'installation et de coupler avec un « Runas » pour qu'il lance l'installeur avec un compte administrateur et par-dessus tout cela, il faut encore utiliser la commande « SendKeys » pour envoyer des touches du clavier pour composer un mot de passe. La méthode n'est ni simple, ni efficace, car les forums sont remplis de messages de gens n'arrivant pas à utiliser cette méthode. C'est souvent à la suite de ces messages que les gens se voient proposés d'utiliser AutoIt pour remédier au problème.

Comment cela marche t'il dans AutoIt ?

Lancer un programme en tant qu'administrateur se fait simplement à l'aide de deux commandes :

RunAsSet(username, domain, password, [profil])

Run (ou RunWait)(Commande)

La première permet de définir le login/mot de passe/domaine à utiliser pour toutes les commandes Run et RunWait lancées ultérieurement. La deuxième lance la commande en paramètre.

Pour réinitialiser le compte à utiliser (et ainsi revenir sur le compte de l'utilisateur qui se connecte), il suffit de lancer la commande

RunAsSet()

Librairies externes

AutoIT propose une collection de fonctions suffisamment vaste pour couvrir la plupart des besoins en administration Windows. Cependant dans certains cas, il est nécessaire de faire appel à des DLL externes. AutoIT propose de faire appel à des librairies externes à l'aide de 8 fonctions d'ouverture, d'appel et de manipulation des données.

L'exemple suivant montre comment créer une messagebox sans passer par la fonction MsgBox d'AutoIT.

$result = DllCall("user32.dll", "int", "MessageBox", "hwnd", 0, "str", "Test de messagebox", "str", "Some title", "int", 0)

Interaction avec l'environnement graphique

L'utilisation de DLL externes, dont celles de Windows, amène au point suivant : l'interaction avec l'environnement graphique, comme les fenêtres.

L'intérêt immédiat est l'automatisation de tâches répétitives, un peu à la manière de l'Applescript sous Mac OS. Un exemple est le déploiement d'une application qui n'aurait pas de package msi disponible. Le site d'AutoIT présente un exemple en automatisant l'installation de WinZip : http://www.autoitscript.com/autoit3/docs/tutorials/winzip/winzip.htm (en anglais).

Le principe est simple :

WinWaitActive("WinZip® 9.0 SR-1 Setup", "&Setup")
Send("!s")

La première commande fait attendre le programme que la fenêtre nommée "WinZip® 9.0 SR-1 Setup" apparaisse. La deuxième envoie la combinaison de touches <CTRL> + <s> pour simuler une action sur le bouton Setup de la fenêtre.

Bien entendu, ceci n'est qu'un exemple, car WinZip met à disposition un package Msi pour faciliter l'installation. Mais cela montre bien les possibilités d'AutoIT dans le domaine.

Interfaces graphiques

AutoIT permet de créer des interfaces graphiques dans le code, à la manière du langage Java. Cependant, pour faciliter la création de ces interfaces graphiques, LazyCat a créé Koda, un programme qui permet de créer des interfaces graphiques de manière graphique, à la manière d'un IDE (VB ou Java par exemple).

La plupart des contrôles habituels sont présents (boutons, étiquettes, champs de texte, combobox...). Une fois l'interface graphique terminée, Koda générera le code à insérer dans le script AutoIT.

L'interaction avec ces contrôles dans le programme est simple :

$etape = GUICtrlCreateLabel("Initialisation...", 24, 40, 470, 17) ; pour créer une étiquette

GUICtrlSetData($etape, "nouveau texte") ;le texte de l'étiquette est modifié

Fonctions orientées administration

Outre les fonctions énoncées plus haut, AutoIT offre une foule de fonctions et variables définies pour faciliter le développement de scripts d'adminstration Windows, parmi lesquelles :

Accès à la base de registre : cela se fait avec une simple commande RegRead ou RegWrite
Accès aux variables du système : @ComputerName pour le nom de l'ordinateur, @UserName pour le nom de l'utilisateur qui a ouvert la session, @WorkingDir pour le chemin du répertoire courant d'éxecution...
Fonctions de traitement de chaînes de caractères : Plus de 30 fonctions permettent de travailler avec les chaînes de caractère : recherche, découpage, conversion, les outils les plus utilisés sont présents.
Fonctions d'accès au réseau : Les fonctions commençant par TCP permettent de se connecter à des ressources réseau. De nombreuses librairies permettent de gérer ainsi certains protocoles reconnus (HTTP, FTP...)

Conclusion

Les possibilités offertes par AutoIT sont conséquentes. L'administrateur dispose ici d'un outil simple à développer, tout en restant puissant et orienté administration Windows. Le langage évolue rapidement et une communauté importante s'est créé autour, proposant un support et de nombreux scripts.

AutoIT est une solution efficace pour tout problème de déploiement d'application, administration de réseau Microsoft Windows ou autre projet de petite ou moyenne envergure.

Ressources

Site officel : http://www.autoitscript.com/autoit3/

Téléchargement direct : http://www.autoitscript.com/cgi-bin/getfile.pl?autoit3/autoit-v3-setup.exe

Dictionnaire des fonctions : http://www.autoitscript.com/autoit3/docs/functions.htm

Dictionnaire des variables d'environnement : http://www.autoitscript.com/autoit3/docs/macros.htm

Forum : http://www.autoitscript.com/forum/

Koda : http://www.autoitscript.com/forum/index.php?showtopic=32299

Pierre Wirtz - VersusMind

Vous accompagne vers la bureautique libre

http://www.versusmind.eu

Introduction au nouveau module de génération de rapport d'OpenOffice.org

Julien — Thu, 11 Oct 2007 18:37:00 +0200

Comment générer un rapport avec des images.

Présentation

Ce document est destiné aux utilisateurs d'OpenOffice 2.3.0 désirant générer des rapports comprenant des images. C'est une des nouvelles possibilités offertes par le nouveau générateur de rapports d'OpenOffice.org arrivé avec cette dernière version.

Nous allons voir comment stocker des photographies dans Base, puis comment exploiter cette base lors d'un publipostage.
Cette possibilité est disponible grâce à l'extension « sun-report-builder ».

Quelques notions initiales

L’objectif d’une base de données est le stockage structuré de données et la mise à disposition d’outils permettant d’afficher les données de manière pertinente.
Une base est constituée de Tables. Chaque Table est constituée de plusieurs champs.
La base de données est mise à jour à l'aide d'un formulaire pour ajouter, modifier ou supprimer un ou des enregistrements.

Structure de la base

Ce document s'appuie sur un exemple constitué d'une table comportant trois types de champs.

Un champ « ID » : il comportera la clé primaire puisque les bases intégrées imposent la présence d'une clé primaire dans chaque table. Cette clé est un champ qui sera l'identifiant unique de chaque enregistrement. Elle sera générée automatiquement.
Un champ « Nom »
Un champ « Photo »

Création de la base de données

Pour créer un fichier Base, utilisez le menu Fichier -> Nouveau -> Base de Données. Suivre l'assistant en laissant les paramètres par défaut. Après avoir enregistrer votre document, le fichier Base s'ouvre en mode édition.

Structure de la Base de données

Création de la table

Sous l'onglet table, lancer « Créer une table en mode ébauche ». Dans la fenêtre d'ébauche de table, insérer les trois types de champs définis auparavant.

Le champ ID est obligatoire pour identifier de manière unique chaque donnée. Son type est 'Interger' (nombre entier). Allez sur la croix verte en faisant apparaître le menu contextuel (clic droit) et choisir 'Clé primaire'. Dans les propriétés de ce champ, cocher la case « auto-valeur : oui », cela va permettre la gestion automatique de l'identifiant.
Rajoutez les deux champs restants, Nom avec un type 'Texte' et Photo avec un type 'Image'. Laissez, leurs propriétés à la valeur par défaut.
Sauvegardez la table ainsi créée, pour la voir apparaître dans la fenêtre base. Il suffit de double cliquer dessus pour remplir celle-ci.

Création d'un formulaire

Un formulaire est un document texte spécial qui a pour objectif d'afficher, de modifier ou de saisir des données dans une Base.
Dans notre cas, il va permettre l'intégration des photographies dans la table crée précédemment.
Pour ce faire, aller sur l'icône « Formulaire », puis cliquez sur « Utiliser l'assistant de création de formulaire ».

Suivez les étapes proposées par l'« Assistant Formulaire » et transférez les champs disponibles dans la zone « Champs du formulaire ». Vous constaterez que le champ « Image » n'est pas transférable à cette étape, c'est pourquoi vous aurez à l'implémenter ensuite dans le Formulaire.

Après avoir fait la première étape, passez directement à l'étape 5 où vous allez choisir un type de mise en forme de votre document (Ne pas choisir le modèle grille).
Pour finir, passez à l'étape 8 où vous allez définir un nom au formulaire et répondez « Modifier le formulaire » à la question « Comment voulez-vous procéder après la création du formulaire ».

Maintenant que le document est ouvert en mode conception, il va falloir lui placer un contrôle qui puisse accepter les photographies.
Cliquez sur « Autres contrôles » dans la barre « Contrôle de formulaire » et ajoutez au formulaire un « Contrôle picto ».
Pour que ce contrôleur puisse faire la liaison avec la base que vous venez de créer et l'image que vous lui affecterez, cliquez sur le bouton « Contrôle » situé dans la barre « Contrôle de formulaire ». Sous l'onglet « Données », choisir le « Champ de données » qui va contenir les images.

Vous pouvez sortir du mode conception en cliquant, dans la barre de contrôle de formulaire, sur le bouton « (dés)activation le mode conception ».

Utilisation du formulaire

Maintenant que votre formulaire est créé et configuré, vous allez commencer à l'utiliser celui-ci pour insérer des entrées dans la base.
Pour insérer une image dans le « contrôle picto », double cliquez dessus et choisissez l'image souhaitée et affectez lui un nom.

Refaire cette manipulation sur autant d'entrée que vous le souhaitez.
Comme votre base est créée et peuplée, utilisons la pour générer un rapport.

Génération d'un rapport

Tout d'abord, téléchargez l'extension sun-report-builder à l'adresse suivante :
http://extensions.services.openoffice.org/project/reportdesign

Après l'avoir installé, vérifiez que l'extension soit activée.

Dans la base constituée précédemment, placez vous au niveau de l'onglet rapport puis « Créer un rapport en mode ébauche... ». Cette action va démarrer l'extension.

Dans la partie droite de la fenêtre, déplacez-vous sur l'onglet « Données », pour lui affecter :

Type de contenu : Table
Contenu : nom de la table créée précédemment

Maintenant que le rapport est lié à la table contenant les images, il ne reste plus qu'à mettre en forme votre page.
Pour cela il suffit de placer les champs souhaités dans le rapport avec le bouton « Ajouter un champ »

La mise en page effectuée, lancez la génération du rapport avec l'icône « Exécuter le report ».

Crédit

Auteur : Julien CASAVECCHIA - VersusMind

Remerciement : Jean-Michel PIERRE dont le tutoriel « Insérer des images dans Base » a servi de modèle.

Des présentations OpenOffice Impress enfin fluides.

Benoît — Thu, 11 Oct 2007 16:42:00 +0200

Ne nombreux utilisateurs d'OpenOffice.org possesseurs de cartes graphiques de marque ATI l'avaient déjà constaté à leurs dépends : la fluidité des animations Impress laissait parfois à désirer sur les modèles de cette marque : il fallait même parfois supporter quelques écrans bleus ce qui était vite très énervant.
Ce problème est maintenant résolu par une petite extension DirectX développée par SUN, téléchargeable ici.

Les nouveautés de KDE 4.0

Pierre — Tue, 07 Aug 2007 15:11:00 +0200

KDE 4.0 vient de sortir en version beta 1. Cela signifie que l'ajout de nouveautés est terminé et les développeurs se concentrent maintenant sur la résolution de bugs. L'occasion de faire un point sur les nouveautés apportées par la quatrième version de KDE.

Marble est une application comparable avec Google Earth (et en partie compatible). La légèreté est un atout de cette application, car le fonctionnement reste fluide même sans accélération OpenGL. L'un des atouts est que l'application fonctionne aussi bien en stand-alone (programme indépendant dans une fenêtre qu'embarqué dans une autre application), permettant par exemple, de géolocaliser un contact de son carnet d'adresse.

Kwin, le moteur de rendu de KDE s'est vu être le centre de toutes les attentions et a vu son nombre d'effets visuels accrus, ainsi que ses performances améliorées.

Konqueror, qui faisait office, dans les version antérieures, de navigateur web ET d'explorateur de fichiers se concentrera sur la navigation Web, tandis que Dolphin se chargera de la partie exploration. L'interopérabilité entre les deux applications a d'ailleurs été accrue et les deux programmes se verront adjoindre le logiciel GwenView pour visualiser les images.

Konsole, le shell (programme de ligne de commande) de KDE a été lui aussi largement amélioré et verra ses onglets ornés d'un titre et d'une couleur pour bien distinguer les différentes sessions.

oKular, le visualisateur universel de documents, s'est vu doté d'une meilleure accessibilité, d'une meilleure prévisualisation avant impression et d'un support accru du multithreading (multi-tâches concurrentes)

KRDC, l'outil de prise en main à distance, est en cours de réécriture et supportera désormais les onglets en cas de prise en main multiple, ainsi que le stockage des mots de passe dans l'application KWallet.

KDE PIM, le projet de gestion d'informations personnelles, va recevoir dans sa version publique, des éléments de la version professionnelle. KOrganizer va bénéficier d'une vue de type diagramme de Gantt, ainsi que d'une vue de type Outlook. KMail supporte désormais le tagging des mails (mots-clés)

Plasma, l'application qui gère le bureau, a été revue et supportera désormais le javascript, les applets SuperKaramba et pourrait supporter bientôt les widgets de Mac OS X et ceux du navigateur Opera.

Source : http://www.kde.org/announcements/announce-4.0-beta1.php

OOXML : un temps de plus pour la réflexion...

Greg — Fri, 20 Jul 2007 14:37:00 +0200

La volonté de Microsoft de présenter rapidement son format OOXML devant l'ISO en vue d'une normalisation se heurte désormais à un fâcheux contretemps.

En effet, le comité technique V1, membre de l'ISO et chargé au sein de l'INCITS (International Committee for Information Technology Standards) des dossiers relatifs aux systèmes de publication et de bureautique, vient de refuser de 2 voix le passage de ce format à la mention "Approuvé, avec commentaires". Pour franchir cette étape, deux tiers des voix des 26 membres du comité V1 étaient nécessaires. Les sociétés partenaires de Microsoft représentées dans ce comité n'étaient apparemment pas suffisamment nombreuses pour atteindre le seuil fatidique des deux tiers.

Le vote du comité V1 est crucial car il conditionne largement les choix de l'INCITS, organe influençant quant à lui les décisions des Etats-Unis pour l'adoption éventuelle d'un nouveau standard ISO.

La décision des Etats-Unis, déterminante dans le cadre d'une éventuelle normalisation du format OOXML, serait donc pour le moment négative. Si le refus se confirme, le format de Microsoft devrait sans doute connaître de profonds remaniements.

Les parlements français et italien passent au libre.

Greg — Mon, 16 Jul 2007 15:23:00 +0200

Depuis la rentrée parlementaire, chaque député de l'Assemblée nationale française dispose d'un poste de travail libre. Ce projet, à l'étude depuis 2006, est motivé par une volonté d'indépendance logicielle (notamment vis-à-vis de Microsoft), de stimulation de l'économie locale et de maîtrise des coûts (les économies réalisées à long et moyen terme devraient être non négligeables).

Les 577 députés disposeront désormais sur leur poste de travail d'un système Ubuntu Linux, ainsi que de certains logiciels libres incontournables tels que Firefox, Thunderbird et OpenOffice.org 2.0.

L'exemple français fait déjà des émules. En effet, après l'Assemblée nationale française, c'est au tour des députés de la chambre italienne de passer aux logiciels libres et à l'environnement Linux. Cette migration est conséquente puisque ce ne sont pas moins de 3500 postes de travail qui sont concernés. La distribution qui sera retenue n'est en revanche pas encore connue (et pour cause, elle ne serait peut-être même pas encore choisie...).

Les migrations des parlements français et italien sont complètes et constituent deux excellentes nouvelles pour le monde du libre. Bien entendu, les députés devront prendre en main leurs nouveaux outils bureautiques. Un temps de formation sera sans doute nécessaire. Toutefois, les avantages d'une migration sont absolument incontestables :

Sécurité. Les postes de travail utilisant des logiciels libres sont bien moins victimes de tentatives d'espionnage et de consultations illicites de données que ceux fonctionnant avec des logiciels propriétaires.
Indépendance technologique. Les postes de travail des deux parlements ne seront plus dépendants d'un seul éditeur (Microsoft).
Economie. Outre le fait de participer au développement de l'économie locale, cette migration devrait permettre au parlement italien d'économiser environ 900 euros par poste de travail, ce qui représente une économie totale de 3 millions d'euros.

Enfin un vrai convertisseur vers ODF : merci SUN !

Greg — Fri, 06 Jul 2007 15:43:00 +0200

C'est aujourd'hui une bonne nouvelle pour toutes les démarches de migration vers OpenOffice.org. En effet, depuis hier, Sun propose en téléchargement gratuit un convertisseur au format standardisé ODF pour les documents Word, Excel et Powerpoint produits avec les versions de Microsoft Office allant d'Office 2000 à Office 2003 en passant par XP. Pour le moment, ce plugin ne serait toutefois pas compatible avec Office 2007.

Ce convertisseur, disponible uniquement en anglais, devrait être rapidement traduit en d'autres langues dont le français.

Ce plugin semble bien meilleur que son équivalent de Microsoft que la société de Redmond avait fait développé par la société française Cleverage. Dans Word, il permet d'ouvrir et de sauvegarder des documents texte au format ODF. Avec Excel et Powerpoint, il est désormais possible d'importer et d'exporter des feuilles de calculs et des présentations au format ODF.

Pour réaliser ce plugin, Sun a utilisé des filtres ayant été constamment améliorés avec StarOffice et OpenOffice. Ces filtres seraient apparemment bien plus performants que la technologie XSLT utilisée par Microsoft, un outil de conversion reposant sur du XML.

Le convertisseur de Sun vient directement concurrencer le traducteur Open XML / ODF pour Office 2003 et 2007 annoncé en mars dernier par le tandem Microsoft / Novell, servant essentiellement à exploiter le format OOXML de Microsoft dans la suite OpenOffice. Le plugin de Sun va bien plus loin en proposant tout simplement de récupérer les documents créés depuis 2000 avec les diverses suites bureautiques Microsoft.

La page de téléchargement du Sun ODF Plugin 1.0 for Microsoft Office

XPS : encore un standard ou un nouveau monopole ?

Greg — Wed, 04 Jul 2007 18:02:00 +0200

Après avoir fait du format Office Open XML (OOXML), utilisé dans la suite bureautique Office 2007, un standard reconnu, Microsoft souhaite désormais en faire autant avec son format de documents XPS (XML Paper Specification). Le format XPS, concurrent direct du PDF d'Adobe, vient en effet d'être soumis à l'organisme de standardisation de référence Ecma (European Computer Manufacturers Association) International . Ce dernier a crée un comité technique chargé de développer un standard basé sur le XPS dans le but de le soumettre à la validation de l'Organisation Internationale de Normalisation (ISO). La norme ISO est souvent perçue comme un gage de qualité pour les administrations publiques et les grandes entreprises. La réponse de l'ISO concernant une normalisation éventuelle du XPS ne devrait toutefois pas tomber avant 2010.

Le comité technique de l'Ecma travaillant sur la normalisation du format XPS a pour mission de "créer un format standard de document électronique basé sur le langage de description de pages XML qui soit cohérent avec les implémentations existantes du format XPS".

Par ailleurs, le format OOXML de Microsoft devrait lui aussi être soumis cette année encore au jugement de l'ISO dans l'optique d'une normalisation intégrale.

Le cas du XPS stigmatise encore davantage l'opposition entre Microsoft et le reste de l'industrie informatique. Le vice-président d'IBM Bob Sutor, chargé de l'Open Source et des standards et farouche opposant du format OOXML, n'a pas hésité à dénoncer le passage en force de Microsoft au sujet des tentatives de normalisation de XPS et d'OOXML. En effet, Sutor vient d'exprimer publiquement ses craintes en terme d'ouverture, d'indépendance et de degré de collaboration dans les prochaines années : "Devons-nous économiser notre temps et notre argent et laisser Microsoft définir les normes internationales basées sur ses propres produits ?"

Le gouvernement vénézuélien se dote de PCs sous Linux.

Greg — Wed, 27 Jun 2007 11:14:00 +0200

Le Venezuela vient d'équiper son parc informatique de systèmes d'exploitation basés sur Linux. Cette migration traduit un profond désir d'indépendance technologique du Venezuela vis-à-vis des standards étrangers.

A priori, il ne s'agirait pas que d'une simple migration. Dans les faits, le ministère de l'Industrie et du Commerce, au même titre qu'une entreprise chinoise partenaire, est actionnaire de la Venezuela de Industria Tecnologica, l'entreprise qui fabriquera les PCs. Le gouvernement projette donc de s'investir pleinement dans cette migration, en envisageant de produire localement certains des composants entrants dans la fabrication des machines.

La commercialisation des machines, habituellement assurée par des institutions privées, sera cette fois prise en charge par l'Etat. Ces PCs sous Linux seront tout d'abord destinés aux missions gouvernementales, ainsi qu'aux institutions publiques. Ils devraient par la suite être mis à disposition du grand public, participant ainsi à l'essor de Linux au Venezuela ainsi que dans l'ensemble de l'Amérique Latine.

Microsoft Office remplacé par NeoOffice dans les écoles néo-zélandaises.

Greg — Fri, 08 Jun 2007 10:05:00 +0200

En Nouvelle-Zélande, le ministre de l’Éducation a choisi de ne pas reconduire le partenariat avec Microsoft qui consistait pour les écoles du pays à utiliser principalement Microsoft Office.

La suite propriétaire devrait donc être supprimée de plus de 25 000 Mac présents dans les écoles néo-zélandaises. Les applications Word, Excel et PowerPoint seront remplacées par NeoOffice.

Cette décision devrait permettre à la Nouvelle-Zélande d'économiser près de 1,5 million d’euros.

Sortie d'Ubuntu 7.04 « Feisty Fawn ».

Greg — Fri, 20 Apr 2007 18:38:00 +0200

Ubuntu 7.04, encore appelée « Feisty Fawn », est disponible depuis le jeudi 19 avril.

Cette nouvelle version très attendue comprend plusieurs améliorations :

Configuration automatique du réseau grâce à NetworkManager.

Migration depuis Windows proposée par l'installateur (incluant la reconnaissance des favoris d'Internet Explorer et de Firefox, des fonds d'écrans, mais également la possibilité d'importer des contacts AOL et Yahoo au cours de l'installation) .

Meilleur support des applications Windows.

Gestion améliorée des applications multimédia, notamment par l'installation de Flash, de Java de Sun ainsi que de multiples codecs.

Installation facilitée des drivers pour les cartes graphiques.

VersusMind se félicite de la sortie de la version Ubuntu 7.04. Découvrez les offres de services et de formations Ubuntu proposées par VersusMind.

La nouvelle version bêta 7.04 d'Ubuntu est présentée au public.

Greg — Tue, 27 Mar 2007 09:27:00 +0200

Ubuntu Linux vient de se doter de nouveaux atouts permettant à l'utilisateur d'envisager sereinement une migration depuis Windows. En sortant sa version bêta 7.04, la distribution gagne encore en crédibilité. En effet, cette nouveauté d'Ubuntu, qui n'est qu'une version bêta pour le moment, fait déjà preuve d'une grande fiabilité.

Utilisant le noyau 2.6.20, Feisty Fawn englobe, entre autres, GNOME 2.18, OpenOffice.org 2.2.0rc3 et X.org 7.2 pour le poste de travail. Concernant les serveurs, cette version bêta dispose d'Apache 2.2, de PostgreSQL 8.2, de PHP 5.2.1 ou encore de LTSP 5.0.

La virtualisation fait également son apparition, VT chez Intel et AMD-V. Signalons également la possibilité d'importer les signets de Firefox ou d'Internet Explorer depuis une partition Windows, tout comme les contacts de messagerie de type Yahoo, MSN ou AOL.

Lors de l'installation, il est possible de sélectionner les codecs que l'on souhaite, pour visualiser des films ou écouter de la musique par exemple. Enfin, cette version bêta d'Ubuntu propose un partage réseau plug&play du nom d'AVAHI .

Avec une version bêta 7.04 présentant de telles dispositions, nous ne pouvons qu'attendre avec impatience la sortie de la version définitive...

Le Danemark s'engage avec force dans la voie des standards ouverts.

Greg — Thu, 22 Mar 2007 17:01:00 +0100

Depuis 2006, le Danemark ne cesse de manifester son intérêt pour les formats ouverts. Ainsi, le 2 juin 2006, le Parlement a voté l'utilisation obligatoire des standards ouverts dans les Technologies de l'Information et de la Communication du pays, en fixant 2008 comme date butoir. Le 23 févier 2007, Helge Sander, Ministre danois de la Science, de la Technologie et de l'Innovation, a précisé les implications concrètes de cette décision.

Le rapport met l'accent sur deux points qui risquent fort de faire débat dans les mois à venir. Ainsi, « les standards ouverts devront être implémentés graduellement en rendant obligatoire l'utilisation de ces standards ouverts pour le secteur public quand cela est techniquement possible ». Par ailleurs, les standards ouverts ne seront obligatoires que « si une étude économique montre que cela n'entraînera pas de coût supplémentaire pour le secteur public ».

Bien évidemment, les différents protagonistes de cette profonde mutation à venir se querellent déjà au sujet de la dénomination « standard ouvert » qui paraît encore bien équivoque. De même, les organisations danoises vont-elles faire preuve de suffisamment de bonne volonté pour que l'adoption de standards libres soit au final « techniquement faisable » ? Enfin, la question des coûts de migration vers les logiciels libres ainsi que de leur utilisation future constituera sans doute également un frein potentiel à la généralisation de ceux-ci dans les systèmes bureautiques du pays.

Le vote du Parlement danois constitue néanmoins une excellente nouvelle pour les défenseurs des standards ouverts !

Le ministère de la Défense poursuit dans la voie du logiciel libre

Greg — Tue, 20 Mar 2007 15:58:00 +0100

Alors que la DGME (Direction Générale de la Modernisation de l'Etat) éprouve des difficultés au niveau du RGI (Référentiel Général d'Interopérabilité), la Direction Générale des Systèmes d'Information et de Communication du ministère de la Défense manifeste, par le biais d'une première directive, sa volonté d'utiliser toujours davantage de logiciels libres.

Dans cette directive, deux points majeurs sont à souligner, à savoir un recours officiellement affiché aux standards ouverts ainsi qu'une préférence pour les logiciels libres à coût, risques et efficacité comparables.

Par cette directive, le ministère de la Défense semble progressivement suivre dans son ensemble l'exemple donné par l'une de ses composantes majeures : la Gendarmerie Nationale.

La DGME compte désormais un ministère incontournable dans ses rangs, ce qui pourrait permettre d'engager le RGI sur la voie des standards ouverts et des logiciels libres.

L'Etat se penche sur le coût et sur l'efficacité de ses équipements informatiques.

Greg — Fri, 16 Mar 2007 11:57:00 +0100

Une étude datant de 2003 et portant sur les coûts moyens d'un poste de travail avait abouti à la conclusion suivante : la part consacrée au support et aux services d'infrastructures représentait 50 % du coût total alors que celle dédiée à l'acquisition et à la maintenance du matériel en représentait 16 %. L'Etat dispose d'un parc informatique considérable et pourrait réaliser des économies de plusieurs centaines de millions d'euros, à condition d'optimiser ses équipements bureautiques.

Toutefois, le nombre de systèmes d'information différents actuellement installés sur les postes de travail de l'Etat est si important qu'il est quasiment impossible de procéder à une optimisation informatique pertinente en terme de réduction de coûts, mais également de cohérence, de compatibilité et d'efficacité.

L'Etat vient d'engager une phase d'audit de son parc informatique, regroupant sous cette appelation le matériel informatique de bureautique (à l'exception de matériels bureautiques métiers de type industriels liés à des systèmes particuliers), les logiciels des postes de travail, ainsi que l'ensemble des ressources humaines du secteur informatique.

Les objectifs avoués sont une meilleure visibilité du parc bureautique de l'Etat sur les plans organisationnel et technique, l'élaboration d'un tableau de bord destiné à améliorer l'efficacité des équipements tout en réduisant les coûts ainsi que l'implication véritable des différents ministères dans l'optimisation de la bureautique étatique.