Acteur automatique

Transcription

Acteur automatique

Note technique
W4 Engine
Acteur
automatique
Cette note technique décrit le fonctionnement et la programmation de l’acteur automatique
sous W4 Engine. La programmation de l’envoi de mail par l’acteur automatique est traitée
en détail.
Sommaire
Elle s'adresse aux développeurs et chefs de projet en charge de réaliser des applications
W4.
1
Description de l'acteur automatique
3
2
Débogage de l’acteur automatique
11
3
Exemples d’utilisation en Java
15
4
Exemples d’utilisation en .NET
20
5
Exemples d’utilisation en COM/ASP
26
6
Scripts en langage W4
32
7
Annexe 1 - Langage W4
35
8
Annexe 2 - Autres commandes de l’acteur automatique
46
Référence : W4TN_AUTO_ACTOR_004_FR
Note technique
W4 Engine
Acteur automatique
© 2005 - 2007 W4. Tous droits réservés.
L'acquisition du présent document confère un droit d'utilisation incessible, non exclusif et
personnel et non un droit de propriété. L'utilisation, la copie, la reproduction et la distribution
du présent document sont permises à condition :
1. que la mention de droits d'auteur ci-dessus figure sur toutes les copies et que cette
mention de droits d'auteur et la présente mention d'autorisation apparaissent conjointement ;
2. que le présent document ne soit utilisé qu'à des fins d'information et non commerciales ;
3. que le présent document ne soit modifié de quelque manière que ce soit.
Tous les produits et marques cités sont la propriété de leurs titulaires respectifs.
Les informations contenues dans ce document pourront faire l’objet de
modifications sans préavis.
Description de l'acteur
automatique
1
1.1
Fonctionnement général
Principe de l’acteur automatique
L’acteur automatique W4 est un programme client autonome de W4 Engine.
Il est installé avec chaque instance de W4 Engine et s’exécute sur la même machine que
« son » instance de W4 Engine.
L'acteur automatique est lancé automatiquement avec W4 Engine, dans l’installation
standard par défaut.
Veuillez vous reporter au document suivant :
3 Manuel d'exploitation de W4 Engine (section Fichiers de configuration)
Le nom de son binaire est wfautomatic(.exe). Il utilise les API C/C++ de W4 Engine.
La raison d’être de l’acteur automatique est d’effectuer des traitements informatiques qui
lui sont notifiés par l’intermédiaire de tâches, tout comme pour un acteur humain.
Il apparaît donc, dans la modélisation, comme un rôle spécial – automatic - auquel sont
assignées les activités représentant des traitements informatiques.
Les étapes associées à ces activités ont une icône particulière les distinguant des étapes
attribuées à des acteurs humains.
Scripts de l’acteur automatique
La plupart des concepts applicables aux acteurs humains sont applicables dans le
contexte de l’acteur automatique W4 : il dispose d’un compte propre avec identifiant
– automatic - et mot de passe ; il possède des rôles, une corbeille, etc., à un détail
près : si un acteur humain sait interpréter et remplir un formulaire, le programme
incarnant l’acteur automatique « préfèrera » exécuter un script dans lequel seront décrits
les traitements à effectuer. Par exemple : envoi d’un mail d’information, mise à jour
d’une base métier, etc.
Le modèle (template) associé à une activité destinée à un acteur automatique doit donc
être un modèle de script et non un modèle d’écran HTML.
Pour distinguer ces scripts des formulaires « humains », l’acteur automatique se voit
affecter la langue conventionnelle auto, les formulaires de cette langue étant en fait des
scripts.
Le nom d’un fichier script acteur automatique a le format suivant :
<nom de l’activité>.auto.html
Notez la présence de l’attribut .html bien que le modèle ne soit pas du HTML.
Le langage de script de l’acteur automatique est décrit plus bas.
3
NOTE TECHNIQUE
Attention !
Les modèles de script de l’acteur automatique doivent être sur le serveur supportant
l’instance de W4 Engine et non sur le serveur de présentation supportant l’application W4
(dans le cas où ils sont distincts).
Par défaut, les acteurs automatiques de toutes les instances recherchent les modèles
selon
le
même
principe
que
le
moteur,
soit
par
défaut
sous
<W4Engine_Home>/Activities, où <W4Engine_Home> représente le répertoire
d’installation de W4 Engine, sauf si, pour l’instance considérée, le répertoire est redéfini
par une ligne <instance>.alias.Activities dans le fichier w4server.cfg.
3 Manuel d'exploitation de W4 Engine (section Fichiers de configuration)
Erreur d’exécution de script de l’acteur automatique
En cas d’erreur à l’exécution du script par l’acteur automatique (wfautomatic.exe), la
tâche correspondante n’est pas terminée mais réassignée par l’acteur automatique au
responsable du dossier (rôle ou acteur).
Dans ce cas, le formulaire de la tâche présentée à l’acteur est :
<nom de l’activité>.<lg>.<attribut>, où <lg> est la langue de l’acteur et
<attribut> vaut selon le contexte applicatif asp, jsp, aspx ou html.
Si ce modèle n’existe pas, le modèle <nom de l’activité>.<attribut> est
présenté.
Attention !
L’absence de modèle pour un acteur humain est une cause d’erreur très fréquente. Les
modèles de bibliothèques standard livrés avec W4 Studio traitent ce cas.
Sérialisation des traitements
L’acteur automatique traite ses tâches consécutivement. Il n’y a pas de parallélisme. En
conséquence, si le traitement moyen d’une tâche est de 1 s, l’utilisation du workflow ne
devra pas générer plus de 3600 tâches par heure sous peine de voir la corbeille de
l’acteur automatique croître indéfiniment.
Dans ce cas de figure, il est préférable de réaliser des connecteurs multi-threadés, à
l’aide du serveur de connecteurs.
Compte acteur automatique
wfautomatic se connecte avec l’identifiant conventionnel du compte de l’acteur
automatique, automatic (id = 2), mot de passe auto.
Le compte du participant d’identifiant automatic est décrit et géré, comme tout autre
acteur, à travers l’interface d’administration. Ce compte ne peut être supprimé.
On définira donc pour l’activité automatique Acti le script Acti.auto.html (notez la
présence de l’attribut .html bien que le modèle ne soit pas du HTML).
Il s'agit d'un utilisateur nommé qui utilise donc une licence de ce type qui lui est réservée
(à l'instar du compte d’administration d’identifiant w4adm). Il peut donc toujours se
connecter. Ces 2 licences sont toujours incluses et gratuites.
W4 BPM Suite
NOTE TECHNIQUE
Acteur automatique
4
Attention !
Il est fortement déconseillé de modifier les attributs de l’acteur automatique, notamment
sa langue et son mot de passe.
Lancement de l’acteur automatique
L’acteur automatique est lancé avec les autres tâches du serveur W4 Engine par
l’intermédiaire du fichier sys/Config.<instance>, soit par sys/Config.w4adm pour
l’instance par défaut.
3 Manuel d'exploitation de W4 Engine (section Fichier de configuration
Config.<instance>)
Dès son lancement, wfautomatic.exe se connecte au serveur de workflow, sous son
identifiant d’acteur, automatic, avec le mot de passe, auto. Il reste connecté tant qu’il
n’est pas arrêté.
Rôles
L’acteur automatique possède deux rôles système : automatic et reassign.
automatic est le rôle prédéfini pour l’acteur automatique. Il n’a aucune propriété
système particulière.
En revanche, le rôle système reassign donne le droit à un acteur le possédant de
réassigner une tâche qui lui est attribuée.
Comme expliqué ci-dessus, cette possibilité est utilisée par l’acteur automatique quand il
détecte une erreur dans le script de la tâche. Il réassigne alors la tâche au responsable
(au responsable désigné ou, à défaut, au rôle responsable en mode libre service), c’està-dire, en principe, à un acteur interactif.
D’autres rôles peuvent être assignés si nécessaire.
Attention !
L’acteur consulte uniquement sa corbeille « personnelle » : il recherche les tâches
assignées nominativement au compte automatic. Il ne recherche pas les tâches en
libre-service pour son ou ses rôles.
De plus, il est fortement déconseillé d’affecter le rôle automatic à un autre acteur que
l’acteur automatic.
En effet, les étapes destinées à l’acteur automatic sont assignées selon le mode
Acteur avec la charge de travail la plus faible pour le rôle automatic. Si plusieurs
acteurs ont le rôle automatic, les tâches associées pourraient potentiellement être
affectées à un autre acteur que celui visé : automatic.
Algorithme de l’acteur automatique
Après son démarrage, l’acteur consulte sa corbeille (API SearchTask) et exécute
chacune des tâches.
Pour chaque tâche, le programme :
appelle l’API ProcessTask ;
5
NOTE TECHNIQUE

exécute une à une les lignes du script ;
si une erreur survient sur une ligne du script : interrompt l’interprétation du script et
appelle l’API ReassignTask. Les erreurs d’exécution du script peuvent être :
▫ ligne non reconnue,
▫ code retour d’une commande appelée non nul ;
si l’exécution du script s’est bien terminée : appelle l’API EndTask, sauf si la tâche à
changé d’état (par exemple, terminée ou « remise » dans la corbeille par un
OnHoldTask). Dans ce cas, il considère que le script a pris en charge l’état de la
tâche automatique et ne s’en mêle donc pas.
Une fois toutes les tâches traitées (c’est-à-dire terminées, réassignées ou « remises »
dans la corbeille), l’acteur automatique attend T secondes (60 par défaut) puis interroge
W4 Engine pour savoir si de nouvelles tâches ont été créées depuis sa dernière
interaction grâce à l’API CheckNewTask.
Notez que cette API est très rapide car elle ne fait pas appel à la base de données, ni
même à l’ordonnanceur (scheduler) mais à la surveillance de session, qui note au
passage si de nouvelles tâches sont créées entre deux appels pour le compte de la
session.
Si de nouvelles tâches ont été créées il les recherche (API SearchTask) et reprend le
traitement décrit ci-dessus, attend à nouveau T secondes et recommence. Il répète cette
opération N fois (10 par défaut). Après cela il consulte à nouveau toute sa corbeille. Il
retrouve dans sa corbeille les tâches qu’il a suspendues pendant les traitements
précédents ainsi que les nouvelles tâches arrivées pendant les dernières T secondes.
1.2
Exploitation de l’acteur automatique
Syntaxe du lancement en ligne de commande :
wfautomatic[.exe] <T> <N>
Exemples
CheckNewTask
SearchTask
wfautomatic 15 60
Toutes les 15 s (*)
Toutes les 60 x 15s, soit 15 mn (*)
wfautomatic 60 60
Toutes les 60 s (*)
Toutes les 60 x 60s, soit 1 h (*)
wfautomatic
Toutes les 30 s (*)
Toutes les 30 x 10s, soit 5 mn (*)
(*) en excluant les temps de traitement des tâches.
3 Manuel d'exploitation de W4 Engine (section Fichier de configuration
Config.<instance>)
W4 BPM Suite
NOTE TECHNIQUE
Acteur automatique
6
1.3
Langage de commande
Fonctionnement
Introduction
Les trois principales commandes sont :
@include_url, exécution d’un script « distant » par appel d’un URL ;
href=, permet d’exécuter une suite d’API W4 exprimées au format URL CGI ;
system=, soumission d’une commande à l’interpréteur de la plateforme.
Exemple
system=ftp -n -i –s c:\temp\w4stdin.tmp aberlour
Chaque ligne représente une commande que l’acteur automatique exécute en séquence.
Une ligne vide ou blanche est ignorée.
Une ligne non reconnue provoque une erreur fatale. Elle génère un message d’erreur
dans le fichier journal de l’acteur automatique wfautomatic<pid>.log.
Un fichier script vide ne génère pas d’erreur.
Quand l’interprétation est terminée, l’acteur automatique termine la tâche sauf si l’état
de la tâche automatique a été modifié, par exemple en la suspendant ou en la
terminant : l’acteur automatique en conclut que les commandes qu’il a exécutées sont la
cause de ce changement d’état. Il n’interfère pas.
Dans le cas où l’acteur automatique termine la tâche, il le fait sans positionner les
variables entrée/sortie et sortie de la tâche.
Si des valeurs résultats sont nécessaires, il faut que l’une des commandes les positionne
en terminant la tâche.
En cas d’erreur sur une ligne, la séquence d’erreur standard est :
une journalisation d’erreur est faite dans le fichier wfautomatic<pid>.log (selon le
mécanisme standard de journalisation du serveur) où <pid> est le process id de
l’acteur automatique ;
le traitement est arrêté à cette ligne ;
l’acteur automatique réassigne sa tâche à l’acteur responsable du dossier ou en libreservice au rôle responsable de la procédure si le responsable du dossier n’est pas
nommé.
Pré-processing
Le paramétrage des scripts avec les données contextuelles se fait à l’aide du langage
propriétaire W4 expliqué ci-dessous (les objets du langage W4 sont repérés par le
caractère @ en tête de leurs identifiants).
Avant d’interpréter son script, l’acteur automatique soumet la totalité du fichier
correspondant au « parser » du langage W4 qui substitue aux paramètres leurs valeurs.
7
NOTE TECHNIQUE
Toutes les possibilités du langage W4 peuvent être utilisées. La seule condition est qu’en
sortie du traitement de substitution, la forme résultat soit valide.
Un fichier vide ou des lignes vides ou avec espaces est une forme légale.
Exécution déportée par @include_url
Les possibilités du langage propriétaire de W4 étant très limitées en dehors de l’accès à
W4, la commande du langage W4 @include_url est très utilisée.
Cette commande, reconnue par l’analyseur du langage, permet « d’appeler un URL » puis
d’interpréter le fichier source retourné par l’exécution de l’URL (noter que ce source est à
nouveau « parsé » avant d’être rendu à l’acteur automatique).
Cet URL sera en général un appel paramétré à un script ASP, JSP ou .NET. Le texte
retourné par l’exécution de l’URL est usuellement vide.
Les paramètres passés incluent généralement le contexte de session de l’acteur
automatique, session qui peut alors être utilisée dans le script pour accéder au moteur de
workflow.
Le script de l’acteur automatique se réduit alors à cette ligne. Tout le traitement est fait
dans le code de l’URL.
Le traitement est donc fait dans l’analyseur du langage W4. Ensuite, puisque son script
est vide, l’acteur automatique « se contente » de terminer la tâche si elle est toujours
dans l’état en-cours.
L’usage de cette commande est décrit plus en détail dans les chapitres suivants :
3 Exemples d’utilisation en Java
3 Exemples d’utilisation en.NET
3 Exemples d’utilisation en COM/ASP
Exemple
Avant substitution :
@include_url(http://thehost/MyApp/Activities/MyAutoActi.aspx?@ctx&ta
[email protected]&[email protected])@/include
Après substitution :
L’URL a été appelé pendant la substitution, et la réponse à la requête (en l’occurrence la
chaîne vide) se substitue à la chaîne @include_url(…)/@include
Attention !
Une source d’erreur commune est que le script de l’URL rende « un peu de HTML » de
façon plus ou moins volontaire, notamment en cas d’erreur (stack Java, message « page
not found », message d’erreur ODBC, etc.). Ce résultat n’a plus une forme valide.
L’acteur automatique passe en erreur.
Référence
Commandes usuelles de l’acteur automatique :
W4 BPM Suite
NOTE TECHNIQUE
Acteur automatique
8

href="W4 URL" : décrit au chapitre 3
@include_url("URL")@/include : décrit aux chapitres 4, 5 et 6
system=localShellCommandLine : voir ci-dessous
outValue=taskOutvalue : voir ci-dessous
logError=errorNumber : voir ci-dessous
// comment text : voir ci-dessous
L Remarque
Quelques commandes obsolètes, non conseillées, sont décrites en annexe.
Commande system=
system=localShellCommandLine
Soumission à l’interpréteur de commande du serveur (typiquement sh sous Unix,
cmd.exe sous Windows) de la commande localShellCommandLine.
L’acteur automatique attend la fin de la commande avant de passer à la ligne suivante
(la commande est un appel à la fonction system() de la bibliothèque standard C).
Attention !
Tout code retour non nul de la commande system= est considéré comme une erreur,
que la cause en soit une erreur de lancement de la commande (commande non trouvée,
shell absent, etc.) ou un exit code non nul retourné par la commande s’étant
correctement exécutée ou pas.
Le traitement standard d’erreur est appliqué. Si la commande appelée retourne en
fonctionnement normal un exit code non nul, elle doit être « enveloppée » par un script
retournant un exit code nul.
Exemple
Exécution d’une commande ftp (ftp mode ligne standard sous Windows).
system=ftp -n -i –sc:\temp\w4stdin.tmp myhost.myname.com
1>c:\temp\w4stdout.tmp
2>c:\temp\w4stderr.tmp
Commande outValue=
outValue=textString
Positionnement de la valeur de retour de la tâche (ou code retour). Si plusieurs lignes de
ce type existent, la dernière prévaut. Si la tâche est déjà terminée (comme conséquence
de l’exécution d’une ligne précédente du script) la ligne n’a pas d’effet.
Commande logError=
logerror=ErrorNumber
Arrêt en erreur du traitement. Code d’erreur à enregistrer dans le fichier journal
wfautomatic<pid>.log.
Les lignes suivantes du script sont ignorées. La tâche est réassignée comme sur toute
erreur.
9
NOTE TECHNIQUE
Ligne commentaire
// texte commentaire
Chaque ligne de commentaire doit être précédée de //.
W4 BPM Suite
NOTE TECHNIQUE
Acteur automatique
10
Débogage de l’acteur
automatique
2
2.1
Journalisation des erreurs
Les erreurs détectées par l’acteur automatique sont enregistrées dans le fichier journal
wfautomatic<pid>.log où PID est le process identifier (visible dans le gestionnaire de
tâches).
Un certain nombre de lignes sont générées pour chaque erreur. On donne ci-dessous, en
titre, la partie significative.
3 Manuel d'exploitation de W4 Engine (section Fichiers journaux)
Line=début de séquence html…
L’acteur automatique a trouvé un modèle HTML au lieu d’un modèle interprétable.
Causes possibles :
1. Le modèle n’existe pas, l’acteur a reçu alors le modèle standard d’erreur (qui est en
HTML).
2. Le modèle a un nom incorrect, typiquement <acti>.html au lieu de <acti>.auto.html.
3. La langue de l’acteur n’est pas en accord avec celle du modèle.
error 1
Une commande system= a échoué.
Causes possibles :
1. La commande est incorrecte (la vérifier en l’entrant à la console).
2. La commande n’est pas dans le chemin d’exécution (variable d’environnement $PATH).
error 22
Conditions d’apparition :
Serveur Unix avec des installations cloisonnées.
Utilisation de l'acteur automatique avec la syntaxe :
@INCLUDE_URL(http://<servername>:<serverPort>/<appliWeb>/servlet/fr.
w4.http.W4Servlet?@ctx&template=Activities/FTX_delayClosed.auto.jsp&
[email protected])@/INCLUDE
11
NOTE TECHNIQUE
Lors de ce type d'utilisation, l'erreur 22 peut survenir (voir ci-dessous) car l'acteur
automatique redirige sur le serveur Web Java et doit ABSOLUMENT disposer de la
variable d'environnement W4_ADM_DIR.
Le log est :
<w4_log> @(#) W4Engine 4.1.12.0 (2004.42) - Sun Solaris (A)
2004-12-09 15:23:25 (1) WFGetAdmDir: the software is not properly
installed
2004-12-09 15:23:25 (1) error 22 (WFGetAdmDir admtools.c 5001
[4979])
2004-12-09 15:23:25 (0) error 22 (WFReadGlobalContext admtools.c
3813 [3785])
2004-12-09 15:23:25
[436])
2004-12-09 15:23:25
[505])
2004-12-09 15:23:25
[212])
2004-12-09 15:23:25
2004-12-09 15:23:25
2004-12-09 15:23:25
2004-12-09 15:23:25
< <inputFileName>
2004-12-09 15:23:25
(2) error 11 (WFCloseStorage wfstorage.c 445
(0) error 11 (WFCleanStorage wfstorage.c 505
(0) error 22 (WFInitCgiClient wfcgimain.c 254
(1)
(1)
(1)
(1)
WFInitCgiClient: argc=1
WFInitCgiClient: argv[0]=cgi.exe
WFInitCgiClient: Server side usage:
WFInitCgiClient:
cgi.exe -e <envFileName>
(0) error 22 (main wfcgimain.c 376 [368])
error 33
Ligne de commande incorrecte.
La ligne en cause est affichée dans le journal dans le message :
WFProcessAutomaticTask: line=ligne incorrecte
Exemple 1 :
1999-08-13 18:29:32 (2) WFProcessAutomaticTask: incorrect line
1999-08-13 18:29:32 (2) WFProcessAutomaticTask: line=<!DOCTYPE HTML
PUBLIC "-//IETF//DTD HTML//EN">
1999-08-13 18:29:32 (2) error 33 (WFProcessAutomaticTask
H:\w4\src\notifier\wfautomatic.c 623 [539])
1999-08-13 18:29:32 (0) error 33 (main
1999-08-13 18:29:32 (2) main: task #18236 cannot be processed
Cause : le modèle (langue « auto ») de l’activité automatique n’existe pas
(Acti.auto.html). Le mécanisme de modèle par défaut a joué, fournissant à l’acteur
automatique un modèle HTML… Soit Acti.html, soit Standard.html.
W4 BPM Suite
NOTE TECHNIQUE
Acteur automatique
12
Exemple 2
1999-06-25 10:01:56 (2) WFProcessAutomaticTask: incorrect line
1999-06-25 10:01:56 (2) WFProcessAutomaticTask: line=dir *
1999-06-25 10:01:56 (2) error 33 (WFProcessAutomaticTask
1999-06-25 10:01:56 (0) error 33 (main
1999-06-25 10:01:56 (2) main: task #105751 cannot be processed
Cause : l’utilisateur a mis dans son fichier de script :
dir *
au lieu de :
system=dir *
error 3040
Une erreur a été détectée. La réassignation de la tâche au (rôle) responsable du dossier
a échoué.
Causes possibles : l’acteur automatique n’a pas le rôle reassign.
Veuillez vous reporter au chapitre suivant :
3 Annexe 1
L’acteur automatique s’arrête en erreur.
Causes possibles : très probablement une ligne href= sans guillemets.
Contournement : corriger. Arrêter / redémarrer le serveur W4.
2.2
13
Pièges de l’acteur automatique
1
Le mot de passe utilisé par le programme wfautomatic.exe est auto. S’il est
changé, par l’interface d’administration web, dans la description de l’acteur
automatic, le programme wfautomatic.exe ne pourra pas se connecter.
2
Ne pas changer la langue de l’acteur automatique (valeur auto) par cette même
interface d’administration.
3
Bien qu’il s’agisse d’un script, le nom du fichier de script doit comporter l’attribut
.html, soit pour l’activité MyActivity : MyActivity.auto.html.
4
La syntaxe d’une ligne est mot-clé=valeur sauf pour le mot-clé href où la syntaxe est
href="valeur". L’absence de « quote » entourant la valeur provoque une erreur
fatale de l’acteur automatique.
NOTE TECHNIQUE
5
Dans le cas d’installation multi-instances, la commande href doit stipuler l’instance
concernée. Sinon les commandes portent sur l’instance par défaut.
Exemple : href="/cgi.exe ?@ctx&cmd=..." est correct car @ctx est expansé en
lg=@lg&id=@id&lid=@lid&wfs=@wfs où wfs identifie l’instance à laquelle est
connecté l’acteur automatique.
6
Tâches d’alarmes ou de dépassement non exécutées.
Si, en dépit du paramétrage de l’acteur automatique, une tâche ne semble pas être
exécutée par ce dernier, il faut s’assurer que celle-ci n’est pas une tâche d’alarme ou
de dépassement. Dans ce cas, la tâche n’est peut-être pas encore créée, car le
service de gestion des alarmes (wfbigbrother) « tourne » par défaut sur la base
d’une vérification toutes les minutes.
7
Vérification de la corbeille de l’acteur automatique.
On peut aussi vérifier la corbeille de l’acteur automatique en se connectant sous son
identité. Le fait de choisir une de ses tâches affichera le script. Rien de cela
n’empêchera l’acteur automatique de fonctionner.
8
Une tâche peut ne pas être exécutée par l’acteur automatique quand :
▫ elle
assignée en libre-service pour le rôle automatic (ou un autre rôle qui
aurait été attribué au compte automatic). L’acteur ne recherche que les tâches
assignées nominativement ;
▫ l’état de la tâche est « en attente ».
W4 BPM Suite
NOTE TECHNIQUE
Acteur automatique
14
3
3.1
Environnement
Le modèle standard d’application JSP livré avec W4 Studio donne le squelette du code
d’une activité automatique « écrite » en Java.
Modèle activité (activityAuto.auto.html)
Le modèle livré est vide :
// include the script here
Au commentaire peut être substitué un include_url appelant un script sur le modèle
de celui-ci :
@include_url(http://<serverName>:<serverPort>/<appliWeb>/servlet/fr.
w4.http.W4Servlet?@ctx&template=Activities/FTX_delayClosed.auto.jsp&
[email protected])@/include
Modèle code Java (activityAuto.auto.jsp)
Ce code comprend la récupération du contexte de session (id, lid, workflow instance) de
l’acteur automatique pour utilisation par le code, l’ouverture et la fermeture d’une
connexion entre le script et W4 Engine utilisant ce contexte de session de l’acteur
automatique.
<%@ include file="/Includes/w4Context.jsp" %>
<%@ include file="/Includes/w4OpenConnexion.jsp" %>
<%@ include file="/Includes/w4CloseConnexion.jsp" %>
3.2
Envoi d’un courrier électronique
Attention !
Le code est donné à titre indicatif. Il peut ne pas fonctionner dans votre environnement.
Ce code nécessite les fichiers suivants : activation.jar, mail.jar, mailapi.jar et
smtp.jar.
15
NOTE TECHNIQUE
<%@ page
import="java.util.*,fr.w4.TWFexception,fr.w4.basic.*,fr.w4.session.*
,fr.w4.search.*,fr.w4.buildtime.basic.*,fr.w4.buildtime.dynamic.*,fr
.w4.runtime.dynamic.*,fr.w4.http.*,fr.w4.utils.*,fr.w4.marshal.*,fr.
w4.runtime.ref.*,fr.w4.buildtime.ref.*,fr.w4.utils.*" %>
<%@ page
import="java.io.*,java.net.*,javax.mail.*,javax.mail.internet.*" %>
<%@ include file="../Includes/w4Context.jsp" %>
<%@ include file="../Tools/w4Methods/w4Methods.jsp" %>
<%
int taskid = 0;
int loginid= 0;
int actorid =0;
String lg= "";
// ** Déclaration des variables dont on aura besoin
// Les variables multivaluées sont déclarées en String car on
utilise la méthode
// qui peuple une string
String tStringVarEmails="";
//String tStringVarEmails="";
String tStringVarExpediteur="";
// String StrVartext=";
String tStringVarDemandeur="";
String tStringVarDateDde="";
String tStringVarMotif="";
String tStringVarMontant="";
try
{
taskid= Integer.parseInt(request.getParameter("taskid"));
loginid= Integer.parseInt(request.getParameter("lid"));
actorid= Integer.parseInt(request.getParameter("id"));
lg = request.getParameter("lg").toString();
// ** Pour tester la récupération de ces valeurs
System.out.println("Ma tâche: "+ taskid);
System.out.println("loginid: "+ loginid);
System.out.println("actorid: "+ actorid);
}
catch(NumberFormatException nfe)
{
System.out.println("\n----------Exception NumberFormat dans
mailInfo.jsp");
nfe.printStackTrace();
}
TWFfullTaskRef fullcurrentTaskref = null;
TWFfullTask fullcurrentTask = null;
TWFnativeSession w4Session = null;
Enumeration actorEnum = null;
TWFTrawVariable tVariables = null;
TWFTrawVariable cVariables = null;
W4 BPM Suite
NOTE TECHNIQUE
Acteur automatique
16
try
{
w4Session = new TWFnativeSession();
w4Session.setPriority(101);
// ** Renseigner le nom du serveur W4 ("ServerName)et de
l'instance ("w4adm"
// ou autre)
w4Session.setActorId(actorid);
w4Session.setServerName("ServerName");
w4Session.setInstanceName("w4adm");
w4Session.setLanguage(lg);
w4Session.setLoginId(loginid);
w4Session.openConnection();
TWFTfullTaskFieldName fields = new TWFTfullTaskFieldName();
fields.add(TWFfullTaskFieldName.CASEVARIABLES);
fullcurrentTask =(new
TWFfullTaskRef(taskid)).wfGetFullTask(fields,(null),(null));
// Récupère les variables de tâche
tVariables = fullcurrentTask.wfGetTaskVariables(true);
// Récupère les variables de dossier
cVariables= fullcurrentTask.getCaseVariables();
// ** Récupère les adresses mail des destinataires
// de la variable multivaluée "mailDestinataire" - utilisation
d'une méthode
// définie dans w4Methods.jsp ou depuis la variable Email
monovaluée
// tStringVarEmail = cVariables.getValue("Email").toString();
tStringVarEmails=w4mVariableValue(tVariables,
"mailDestinataire", ",");
// ** Récupère les variables de tâches nécessaires au texte et
enveloppe
// de mail
tStringVarExpediteur =
tVariables.getValue("mailExpediteur").toString();
//StrVartext = cVariables.getValue("Body").toString();
tStringVarDemandeur =
tVariables.getValue("demandeur").toString();
tStringVarDateDde =
tVariables.getValue("dateDemande").toDate().getDay()
+"/"+tVariables.getValue("dateDemande").toDate().getMonth()
+"/"+tVariables.getValue("dateDemande").toDate().getYear();
tStringVarMotif = tVariables.getValue("motif").toString();
tStringVarMontant = tVariables.getValue("montant").toString();
17
NOTE TECHNIQUE
// ** Pour tester la récupération des valeurs
System.out.println("destinataires " + tStringVarEmails);
System.out.println("demandeur " + tStringVarDemandeur);
System.out.println("Date demande " + tStringVarDateDde);
System.out.println("montant " + tStringVarMontant);
System.out.println("motif " + tStringVarMotif);
System.out.println("expediteur " + tStringVarExpediteur);
/************************* Données propres à l'envoi du message
*/
String from = tStringVarExpediteur;
String host = "tea";
String subject = "Demande d'engagement de dépenses acceptée";
String message = " L'engagement de dépense demandée le
"+tStringVarDateDde+" par "+tStringVarDemandeur+" a été acceptée.
Montant de la dépense prévue (en KEuros) : "+tStringVarMontant+".
Motif de la demande : "+tStringVarMotif+".";
Properties props = new Properties();
props.put("mail.smtp.host", host);
Session maSession = Session.getDefaultInstance(props, null);
/************************* Pour l'envoi du message */
try
{
MimeMessage msg = new MimeMessage(maSession);
msg.setFrom(new InternetAddress(from));
msg.setRecipients(Message.RecipientType.TO, tStringVarEmails);
// msg.setRecipients(Message.RecipientType.CC,
"[email protected], [email protected]");
msg.setSubject(subject);
// Créer et renseigner la première partie du message
MimeBodyPart mbp1 = new MimeBodyPart();
mbp1.setText(message);
mbp1.setHeader("Content-Type","text/html; charset=iso-885915");
Multipart mp = new MimeMultipart();
mp.addBodyPart(mbp1);
msg.setContent(mp);
// Positionner la date: en-tête
msg.setSentDate(new Date());
// Envoyer le message
Transport.send(msg);
}
catch(Exception e1)
W4 BPM Suite
NOTE TECHNIQUE
Acteur automatique
18
{
System.out.println("\nException lors de l'envoi du
message\n");
e1.printStackTrace();
}
/************************* Fin des données propres à l'envoi du
message */
}
// Fermer la session W4 ouverte
catch(TWFexception e)
{
System.out.println("erreur setting des variables");
e.printStackTrace();
}
finally
{
if(w4Session != null && w4Session.getSessionHandle() > 0)
{
try
{
w4Session.closeConnection();
}
catch(TWFexception e)
{
e.printStackTrace();
}
}
}
%>
19
NOTE TECHNIQUE
4
4.1
Environnement
Le modèle standard d’application .NET (C#) livré avec W4 Studio donne le squelette du
code d’une activité automatique « écrite » en C#.
Ce code comprend la récupération du contexte de session (id, lid) de l’acteur
automatique pour utilisation par le code, l’ouverture et la fermeture d’une connexion
entre le script et W4 Engine utilisant le contexte de session de l’acteur automatique.
Modèle activité (auto_page_default.auto.html)
@include_url(http://localhost/${sub_directory}/Activities/${activity
_name}_auto.aspx?@ctx&[email protected]&[email protected])
@/include
Les formes ${identifiant} correspondent au langage W4 Studio.
3 Manuel de génération de W4 Studio
Soit, après une substitution arbitraire du langage W4 Studio :
@include_url(http://thehost/MyApp/Activities/MyAutoActi_auto.aspx?@c
tx&[email protected]&[email protected])@/include
Attention !
Le service w4 doit pouvoir accéder à la page automatique. Il existe cependant plusieurs
façons de faire :
1 Le service w4 doit être démarré sous un compte utilisateur et non pas en tant
que « système local » ; ensuite, ce compte doit avoir les droits d’exécution (droits sur
le système de fichiers) sur les fichiers .aspx et .aspx.cs.
2 Si le service w4 est démarré par le « système local », alors il est nécessaire, via IIS,
d’autoriser les connexions anonymes soit sur le fichier .aspx (d’activité automatique),
soit sur le répertoire contenant l’activité automatique, soit sur l’application.
3 Pour les applications générées à partir de la version 5.5 de W4 Studio, il est
nécessaire de configurer le web.config pour qu’il autorise l’accès direct à la page
d’activité automatique sans passer par la page de connexion à l’application (cf.
exemple ci-dessous).
W4 BPM Suite
NOTE TECHNIQUE
Acteur automatique
20
<location path="Activities/${activity_name}_auto.aspx">
<system.web>
<authorization>
<allow users="?"/>
</authorization>
</system.web>
</location>
Modèle code C#
Un total de 5 fichiers est donc nécessaire pour faire fonctionner l’activité automatique
correctement :
le fichier .auto.html à déployer sur le serveur ;

4.2
les fichiers de la page <Activite_auto> (.aspx et .cs) qui correspondent aux
fichiers d’exécution du traitement automatique ;
les fichiers de la page <Activite> (.aspx et .cs) qui permettent d’afficher la tâche
assignée au responsable de l’application lorsque l’activité automatique ne s’est pas
déroulée correctement (par exemple un message d’avertissement).
Le modèle de code C# inclut le code d’envoi d’un courrier électronique listé ci-dessous
ainsi que la mise à jour de variables du dossier qui sont en sortie de l’activité.
Attention !
Dans L’exemple qui suit, les éléments du langage W4 Studio identifiés par ${…} ne sont
pas substitués.
Le code est donné à titre indicatif. Il peut ne pas fonctionner dans votre environnement.
Fichier .aspx
Ce fichier doit contenir uniquement la référence à son « code behind ». Aucun code html
ne doit être écrit.
Son contenu sera donc le suivant :
<%@ Page language="c#" Codebehind="${activity_name}_auto.aspx.cs"
AutoEventWireup="false"
Inherits="${sub_directory}.Activities.${activity_name}_auto" %>
21
NOTE TECHNIQUE
Fichier .aspx.cs
Toutes les parties « <texte> » doivent être remplacée car elles dépendent de votre
environnement et/ou de votre modélisation (il y en a 6 dans l’exemple qui suit).
using
using
using
using
System;
System.Data;
System.Web;
System.Web.Mail;
using W4.Session;
using W4.Basic;
using W4.Runtime;
using ${sub_directory}.Utils;
using ${sub_directory}.Utils.W4;
namespace ${sub_directory}.Activities
{
/// <summary>
/// Envoi d'un mail contenant l'ensemble des variables en entrée
de tâche
/// Mise à jour de trois variables en sortie de tâche
/// </summary>
public class ${activity_name}_auto : System.Web.UI.Page
{
private TWFnativeSession _oTWFnativeSession;
private const string w4ServerName = "<W4ServerName>";
private const string w4InstanceName = "<W4InstanceName>";
private const string smtpServerName = "<smtpServerName>";
private void Page_Load(object sender, System.EventArgs e)
{
//Récupération des informations de la request
string CaseId = Request.Params["caseId"];
int TaskId = Convert.ToInt32(Request.Params["taskId"]);
TWFtaskRef oTWFtaskRef = new TWFtaskRef(TaskId);
try
{
_oTWFnativeSession = getW4Session(Request);
_oTWFnativeSession.WFOpenConnection();
// Création du mail
createMail(oTWFtaskRef, CaseId);
//Terminaison de la tâche avec mise à jour de la variable
TWFvariableList oTWFvarList = new TWFvariableList();
oTWFvarList.SetValue("<varNameStr>", "valeur");
oTWFvarList.SetValue("<varNameInt>", 12);
oTWFvarList.SetValue("<varNameDate>", new TWFdate(1980, 1,
1, 12, 30, 00));
oTWFtaskRef.WFEndTask(new TWFname("CodeRetour"),
oTWFvarList);
}
catch(Exception l_Exception)
{
Helper.ManagedError(l_Exception, this, this.Context);
W4 BPM Suite
NOTE TECHNIQUE
Acteur automatique
22
}
finally
{
//Fermeture de la connexion
_oTWFnativeSession.WFCloseConnection();
_oTWFnativeSession = null;
}
}
public void createMail(TWFtaskRef oTWFtaskRef, string caseId)
{
// Récupération des variables de tâche
W4.Runtime.TWFvariableList oTWFvarList =
oTWFtaskRef.WFGetVariables(true);
string piecesJointes = "";
string taskVar = "<table border='0'>";
taskVar += "<tr><td colspan='2'>Variables de
tâches</td></tr>";
for (int i = 0; i < oTWFvarList.Length; i++)
{
taskVar += "<tr>";
taskVar += "<td align='top'>" + oTWFvarList.Item(i).Name +
"</td>";
taskVar += "<td>";
switch (oTWFvarList.Item(i).GetValueType().ToString())
{
case "System.String":
foreach (string val in oTWFvarList.Item(i).StringValues)
taskVar += val + " ";
break;
case "System.Int32":
foreach (int val in oTWFvarList.Item(i).IntValues)
taskVar += val.ToString() + " ";
break;
case "W4.Basic.TWFdate":
foreach (W4.Basic.TWFdate val in
oTWFvarList.Item(i).DateValues)
{
if (val.Year != 0)
taskVar += new DateTime(val.Year, val.Month,
val.Day).ToString("u") + " ";
}
break;
case "W4.Runtime.TWFdocumentRef":
foreach (W4.Runtime.TWFdocumentRef val in
oTWFvarList.Item(i).DocumentValues)
{
if (val != null)
{
W4.Runtime.TWFdocument doc = val.WFGetDocument();
taskVar += "Cf pièce jointe : " + doc.Str + " ";
string virtualPath = doc.AccessPath;
if (!piecesJointes.Equals(""))
piecesJointes += ",";
23
NOTE TECHNIQUE
piecesJointes += virtualPath;
}
}
break;
}
taskVar += "</td></tr>";
}
taskVar += "</table>";
// Création du corps du message
string body = "<html>";
body += "<body>";
body += taskVar;
body += " Signé : Acteur AUTOMATIQUE";
body += "</body>";
body += "</html>";
string destinataire = "[email protected]";
string auteur = "[email protected]";
string sujet = "W4 - envoi de mail automatique - dossier " +
caseId;
// Exécution de l'envoi du mail
SendMail(destinataire, auteur, sujet, body, piecesJointes);
}
public void SendMail(string mailTo, string mailFrom, string
mailSubject, string mailBody, string pathOfAttachments)
{
SmtpMail.SmtpServer = smtpServerName;
// Instanciation de l'objet "Message"
MailMessage objMessage = new MailMessage();
// Paramètres du mail
objMessage.To = mailTo;
objMessage.From = mailFrom;
// --> Format du message
objMessage.BodyFormat = MailFormat.Html;
// --> Sujet
objMessage.Subject = mailSubject;
// --> Corps
objMessage.Body = mailBody;
// --> Priorité
objMessage.Priority = MailPriority.Normal;
// --> Pièces Jointes
// Construction de la liste de pièces jointes
if (pathOfAttachments != "")
{
char[] delim = new char[] {','};
foreach (string sSubstr in pathOfAttachments.Split(delim))
{
string adr = Server.MapPath(Request.ApplicationPath) +
sSubstr.Replace("/",
System.IO.Path.DirectorySeparatorChar.ToString());
MailAttachment myAttachment = new MailAttachment(adr);
objMessage.Attachments.Add(myAttachment);
W4 BPM Suite
NOTE TECHNIQUE
Acteur automatique
24
}
}
// Envoi du mail
SmtpMail.Send(objMessage);
}
#region Méthode permettant de construire le context et la
session
private TWFnativeSession getW4Session(HttpRequest
objHTTPRequest)
{
TWFsessionContext _oTWFsessionContext = new
W4.Session.TWFsessionContext();
//lecture des informations dans la querystring
_oTWFsessionContext.ActorId =
Convert.ToInt32(objHTTPRequest.QueryString["id"]);
_oTWFsessionContext.Language =
objHTTPRequest.QueryString["lg"];
_oTWFsessionContext.LoginId =
Convert.ToInt32(objHTTPRequest.QueryString["lid"]);
_oTWFsessionContext.InstanceName = w4InstanceName;
if (! w4ServerName.Equals(""))
_oTWFsessionContext.ServerName = w4ServerName;
TWFnativeSession oTWFnativeSession = new
W4.Session.TWFnativeSession(_oTWFsessionContext);
return oTWFnativeSession;
}
#endregion
#region Code généré par le Concepteur Web Form
override protected void OnInit(EventArgs e)
{
InitializeComponent();
base.OnInit(e);
}
private void InitializeComponent()
{
this.Load += new System.EventHandler(this.Page_Load);
}
#endregion
}
}
25
NOTE TECHNIQUE
5
5.1
Exemples d’utilisation en
COM/ASP
Environnement
Le modèle standard d’application ASP livré avec W4 Studio 5.0 donne le squelette du
code d’une activité automatique « écrite » en ASP.
Ce code comprend la récupération du contexte de session (id, lid) de l’acteur
automatique pour utilisation par le code, l’ouverture et la fermeture d’une connexion
entre le script et W4 Engine utilisant le contexte de session de l’acteur automatique.
Modèle activité (auto_page_default.auto.html)
En langage W4 Studio :
@include_url(http://${param label='Nom du serveur et port : '
default_value='localhost'}/${sub_directory}/Activities/${param
label='ASP Page with launching processing (without .asp) : '
default_value='activityAutoName'}.asp?@ctx&[email protected])@/in
clude
Soit, en langage W4, après une substitution arbitraire du langage W4 Studio :
@include_url(http://localhost/MyApp/Activities/MyAutoActi.asp?@ctx&t
[email protected])@/include
Attention !
Le service w4 doit être démarré par un compte utilisateur et non pas le « système
local », sinon IIS peut ne pas donner accès à la page .asp.
W4 BPM Suite
NOTE TECHNIQUE
Acteur automatique
26
Modèle code ASP (auto_page_default.asp)
<%
'******
'*
'* Attention, le fichier .auto.html appelant celui-ci doit être
dans le répertoire W4_HOME/Activities/...
'* BE CAREFUL , the file .auto.html used to call this file, must
exist in the folder W4_HOME/Activities/...
'*
'*****
'***
'* Reconstitution de la session
'* id représente l'acteur automatique
'* Aucun retour n'est autorisé (pas de response.write)
'* En cas de débogage utilisation de WFsetTrace de l'objet
TWFsession
'***
set objTWFsession = Server.CreateObject("w4com.TWFsession")
objTWFsession.Context.Modify request("id"),request("lid"),50,
request("lg"),"ASPClient",request("srv"),request("wfs")
' Prévision en cas de débogage: activation du mode trace
'objTWFsession.Context.WFsetTrace "+t +mcom"
'objTWFsession.WFOpenConnection
'**********************************************************
' Code asp de l'acteur automatique avec utilisation de la session
' Utilisation de objTWFsession.WFaddTraceLine " my line " pour
' afficher une ligne de trace dans le ficier \temp\w4dll.tra
'**********************************************************
' Prévision en cas de débogage: désactivation du mode trace
'objTWFsession.Context.WFsetTrace "-t +mcom"
'objTWFsession.WFCloseConnection
5.2
Attention !
Le code ci-dessous est donné à titre indicatif. Il peut ne pas fonctionner dans votre
environnement. Il utilise l’objet NewMail de la DLL cdonts.dll.
27
NOTE TECHNIQUE
Le détail des conditions d’utilisation de cet objet est donné à la suite du code.
<%@ Language=VBScript %>

<%
set mysession = Server.CreateObject("w4com.TWFsession")
set myAutoTaskName = server.CreateObject("w4com.TWFname")
set myContext = server.CreateObject("w4com.TWFsessionContext")
myAutoTaskName.Id = Request("taskid")
mySession.Context.Modify request("id"),request("lid"),50,
%>

<%
' Récupère les variables de tâche
set myTrawVariables =
mysession.WFGetVariables(myAutoTaskName,true)
sendNotification =
myTrawVariables.item("sendNotification").Value(1).Value
customerEmail =
myTrawVariables.item("CUSTOMEREMAIL").Value(1).Value
Sub subSendMail(strToName, strSubject)
Dim strMyBody
Dim objMyCDONTSMail
Set objMyCDONTSMail = CreateObject("CDO.Message")
objMyCDONTSMail.From= "[email protected]"
objMyCDONTSMail.To = strToName
objMyCDONTSMail.Subject = strSubject
strMyBody = strMyBody & "Bonjour, " & vbCrLf &vbCrLf
strMyBody = strMyBody & "Nous n'avons pas pu répondre
favorablement à votre demande de clé de licence. " & vbCrLf &vbCrLf
strMyBody = strMyBody & "Cordialement. " & vbCrLf
strMyBody = strMyBody & "W4 Support Team. "
objMyCDONTSMail.TextBody= strMyBody
objMyCDONTSMail.send
set objMyCDONTSMail=nothing
End Sub
call subSendMail(customerEmail,"Notification refus")
%>

Installation de la DLL CDONTS
Cette DLL n’est plus livrée avec Windows pour les versions supérieures à 2000 Server.
W4 BPM Suite
NOTE TECHNIQUE
Acteur automatique
28
Microsoft a décidé de supprimer CDONTS avec IIS 5.1, donc sous Windows XP vous
n'aurez pas accès à ce composant. Il vous faudra trouver le fichier cdonts.dll puis
l'enregistrer dans la base de registre.
Visitez cette page pour de plus amples informations :
http://support.microsoft.com/directory/article.asp?ID=KB;EN-US;Q171440&
Le fichier cdonts.dll est à placer dans le répertoire « Windows » (WINNT dans la plupart
des cas) puis dans le sous-répertoire System32. Ensuite, faites Démarrer/Exécuter puis
saisissez "regsvr32 cdonts.dll" pour enregistrer la DLL dans la base de registre.
Ce fichier est aussi disponible sur le CD Rom de Windows 2000 Pro et Server sous la
forme cdonts.dl_. En commande DOS, faites un "expand.exe cdonts.dl_ cdonts.dll" puis
faites la manipulation comme indiquée plus haut.
Sous Windows 2003, la DLL a été renommée ; elle s'appelle CDOSYS.dll (elle est dans
\system32 et ne fonctionnera pas sous NT4). Son utilisation ne semble pas trop différer.
Éléments d’utilisation de l’objet NewMail de CDONTS
Envoyer un mail
<% Dim Mailer
Set Mailer = Server.CreateObject("CDONTS.NewMail")
' on crée l'objet CDONTS
Mailer.To = "[email protected]"
' email du destinataire
Mailer.From = "[email protected]"
' email de l'expediteur
Mailer.Subject = "Titre du message"
' titre du message
Mailer.Body = "Le texte qui sera envoyé"
' corps du message
Mailer.Send
' on envoie le tout
%>
On peut également mettre le tout sur une seule ligne qui devrait alors ressembler à :
<% ' on crée toujours l'objet avant
Mailer.Send "[email protected]","[email protected]","Titre d
u message","Le texte à envoyer"
' et on le ferme toujours après
%>
29
NOTE TECHNIQUE
Une fois le mail envoyé, on n'oublie pas de fermer l'objet Mailer, sinon on ne peut plus en
envoyer ultérieurement, avec la commande :
<% Set Mailer = Nothing %>
Fonctions supplémentaires
<%
' importance : 0 = normal, 1 = urgent, 2 = très urgent
Mailer.Importance = 0
' le chemin du fichier qui sera attaché
Mailer.AttachFile "\\repertoire\fichier.jpg","fichier.jpg"
' liste des destinataires en CarbonCopy, séparés par une virgule
Mailer.Cc = "[email protected], [email protected]"
' liste des destinataires en BlindCarbonCopy (Copie cachée invisible
), séparés par une virgule
Mailer.BCc = "[email protected], [email protected]"
' Pour envoyer un
Mailer.BodyFormat
Mailer.MailFormat
' Pour laisser le
lignes
%>
W4 BPM Suite
mail au format HTML, ajouter ces 2 lignes :
= 0
= 0
mail en format PlainText, mettez des 1 pour ces 2
NOTE TECHNIQUE
Acteur automatique
30
Soit au total l’exemple simple suivant :
<%
'******
'* Attention, le fichier .auto.html appelant celui-ci doit être
dans le répertoire W4_HOME/Activities/...
'* BE CAREFUL , the file .auto.html used to call this file, must
exist in the folder W4_HOME/Activities/...
'*
'*****
'***
'* Reconstitution de la session
'* id représente l'acteur automatique
'* Aucun retour n'est autorisé (pas de response.write)
'* En cas de débogage utilisation de WFsetTrace de l'objet
TWFsession
'***
set objTWFsession = Server.CreateObject("w4com.TWFsession")
objTWFsession.Context.Modify request("id"),request("lid"),50,
'**********************************************************
'Code asp de l'acteur automatique avec utilisation de la session
'utilisation de objTWFsession.WFaddTraceLine " my line " pour
'afficher une ligne de trace dans le ficier \temp\w4dll.tra
'**********************************************************
Sub subSendMail(strToName, strSubject)
Dim strMyBody
Dim objMyCDONTSMail
Set objMyCDONTSMail = CreateObject("CDONTS.NewMail")
objMyCDONTSMail.From= "[email protected]"
objMyCDONTSMail.To = strToName
objMyCDONTSMail.Subject = strSubject
strMyBody = "Corps du message" & vbCrLf
strMyBody = strMyBody & "Deuxième ligne du corps du message" &
vbCrLf
strMyBody = strMyBody & "Troisième ligne du corps du message"
objMyCDONTSMail.Body= strMyBody
objMyCDONTSMail.Send
set objMyCDONTSMail=nothing
End Sub
call subSendMail("[email protected]","sujet du mail")
%>
31
NOTE TECHNIQUE
6
6.1
Présentation
Ces scripts, introduits par la commande href=, sont utiles pour les traitements simples.
Par ailleurs, ils sont plus rapides que l’appel d’un script (JSP, ASP, .NET) « derrière » un
URL local ou distant via la commande @include_url.
En contrepartie, ils ne portent que sur les API W4 et peuvent être difficiles à écrire et à
mettre au point.
href= introduit des URL W4 basés sur les API C/C++ dites API « CGI ».
Pour une information détaillée, veuillez vous reporter au document suivant :
3 Documentation de référence en ligne des API CGI
Les données contextuelles apparaissant dans ces URL sont décrites à l’aide du langage
W4 présenté de façon assez détaillée dans ce chapitre.
Pour une information complémentaire sur le langage W4, veuillez vous reporter au
document suivant :
3 Note technique - Langage W4
6.2
Exemples
Terminaison de tâche avec positionnement de variables
Objet : positionnement des variables de tâche avant terminaison de la tâche. Si la
terminaison de tâche est laissée à l’acteur automatique, il ne positionne aucune variable.
href="/W4/cgi.exe?@ctx&cmd=ExitTask&command=EndTask&taskName.id=@tas
k.name.id&[email protected]"
Attention !
Notez la présence impérative des guillemets entourant la valeur (URL) suivant href=.
Commentaires
Cmd=ExitTask
Nom fonction API C ExitTask (sortie de tâche)
command=EndTask
Type de sortie : terminaison
W4 BPM Suite
NOTE TECHNIQUE
Acteur automatique
32
[email protected] Identification de la tâche (id)
[email protected] Variable de tâche StatusResponse prend la valeur de
la variable « Fin »
Création de tâches en fonction d’une variable
multivaluée
Objet : création de tâches selon une valeur multivaluée. A utiliser quand il s’agit de
distribuer des tâches non selon un rôle mais selon une valeur, par exemple créer autant
de tâches de suivi qu’il y a de lots à traiter.
[W4MAP NbReponses]
[W4ENTRY NULL
default]href="/W4/cgi.exe?@ctx&cmd=ExitTask&command=EndTask&StatutFi
[email protected]&o(utvalue=fin&[email protected]"[/W4ENTRY]
[W4ENTRY default default]@LOOP(BASESSII_ToutesReponsesDetaillees)
(href="/W4/cgi.exe?@ctx&cmd=Init&command=CreateTask&[email protected]&c
aseName.id=@ite(m.name.id&node=Fin&bypass=1"
@/LOOP
[/W4ENTRY]
[/W4MAP]
{@BASESSII_ToutesReponsesDetaillees.nbItems:NbReponses}
Commentaires
Si NbReponses est vide l’entrée NULL de la map est utilisée. Le résultat après
substitution sera :
href="/W4/cgi.exe?@ctx&cmd=ExitTask&command=EndTask&[email protected]
alue&outvalue=f(in&[email protected]"
(avec les valeurs des identifiants @ substituées)
Si NbReponses vaut 2, l’entrée default de la map sera prise, soit :
@LOOP(BASESSII_ToutesReponsesDetaillees)
(href="/W4/cgi.exe?@ctx&cmd=Init&command=CreateTask&[email protected]&c
aseName.id=@ite(m.name.id&node=Fin&bypass=1"
@/LOOP
33
NOTE TECHNIQUE
Qui bouclera 2 fois, donnant :
href="/W4/cgi.exe?@ctx&cmd=Init&command=CreateTask&[email protected]&ca
seName.id=@item(.name.id&node=Fin&bypass=1"
href=/W4/cgi.exe?@ctx&cmd=Init&command=CreateTask&[email protected]&cas
eName.id=@item(.name.id&node=Fin&bypass=1
Avec les valeurs des identifiants @ substituées.
Positionnement d’attributs de tâches
Objet : mise à jour des attributs date d’alarme et de dépassement des tâches actives
d’un dossier.
Le script WorkcaseAllActiveTasks renvoie toutes les tâches actives du dossier. Pour
chacune, les 2 attributs sont mis à jour avec les variables dateFinSouhaitee et
datePublication, cela à partir de 2 variables de dossier repositionnées dans une tâche
antérieure.
@LOOP(WorkcaseAllActiveTasks)
href="/W4/cgi.exe?@CTX&cmd=SetVariable&[email protected].
id&VariableName(.str=dateFinSouhaitee&value.type=WF_UNION_DATA_DATE&
value.date.day=@dateFinSouhait(ee.value.day&value.date.month=@dateFi
nSouhaitee.value.month&value.date.year=@dateF(inSouhaitee.value.year
"
href="/W4/cgi.exe?@CTX&cmd=SetVariable&[email protected].
id&VariableName(.str=datePublication&value.type=WF_UNION_DATA_DATE&v
alue.date.day=@datePublication(.value.day&value.date.month=@datePubl
ication.value.month&value.date.year=@datePubl(ication.value.year"
@/LOOP
W4 BPM Suite
NOTE TECHNIQUE
Acteur automatique
34
7
7.1
Présentation
Cette annexe a pour but de présenter le langage W4 pour les utilisateurs qui souhaitent
programmer l’acteur automatique dans ce langage, sans avoir auparavant appris à
programmer des applications web à l’aide de ce langage.
Le langage de script W4 permet de définir des modèles de pages de texte dans lesquelles
sont référencés des objets workflow. Le langage est quelquefois appelé WSP, W4 Server
Pages, ou @SP pour @ Server Pages, le caractère @ ayant une signification particulière.
Ce langage est utilisable pour définir tout modèle de fichiers texte. Il est utilisé dans
divers contextes que sont :
les pages HTML de l’interface d’administration standard web de W4 Engine dites
« CGI » ;
les pages HTML et les documents des applications web W4 dites « CGI » ;
les URL W4 apparaissant dans ces pages ;
les scripts de définition du mail interprétés par le moteur W4 Engine ;
les scripts du langage de commande de l’acteur automatique (ce document).
Noter que le langage W4 n’est plus mis en avant pour la définition des pages HTML : les
modèles d’applications livrés à partir de la version 5 de W4 BPM Suite sont Java/JSP,
.NET et ASP/COM. De même, une interface d’administration est aussi disponible en Java
au lieu de celle définie en langage W4.
Pour plus d’informations sur la définition de pages HTML à l’aide du langage
W4, consultez les documents suivants dont ce texte reprend en partie le contenu :
3 Note technique – Langage W4
La présentation qui suit est découpée en deux parties :
un survol des possibilités du langage avec des exemples simples ;
une description détaillée.
Les exemples sont majoritairement donnés dans le contexte de l’acteur automatique.
Il est donc souhaitable d’avoir compris globalement le mécanisme de fonctionnement de
l’acteur automatique avant de lire ce qui suit.
L Remarque
Le langage W4 n’est pas le langage de l’acteur automatique. Il est uniquement utilisé par
ce dernier comme un pré-processeur selon la séquence suivante :
soumission du fichier script (modèle de l’activité), dans son ensemble, au
« parseur » du langage W4 ;
récupération du fichier résultat, dans son ensemble ;
interprétation du fichier résultat en terme de commandes pour l’acteur automatique,
ligne par ligne.
35
NOTE TECHNIQUE
7.2
Détail du langage
Mécanisme de substitution
Le module « parseur » du langage reçoit en entrée :
le fichier texte à substituer ;
un contexte de substitution workflow.
Dans un contexte de substitution sont définis notamment : l’acteur, et donc sa langue, la
session de l’acteur (id de connexion à W4 Engine), le dossier courant, la tâche
courante, etc.
Le parseur effectue ses traitements sur le texte passé en paramètre, sous forme de
fichier, et retourne à l’appelant, en une fois, l’ensemble du texte résultat.
Le parseur fonctionne ainsi :
balayage jusqu’à repérage d’un élément du langage ;
interprétation de l’élément ;
si nécessaire, substitution à l’élément du texte résultat de l’interprétation ;
continuation du balayage (en incluant le texte résultat de la substitution).
Le texte résultat est ensuite interprété par l’appelant comme bon lui semble.
Exemple
Soit le texte suivant,
administrateur :
soumis
au
« parseur »
dans
le
contexte
d’une
session
ABC @actor.name DEF
IJK @id LMN
Le parseur reconnaît certains éléments parce qu’ils sont introduits par @.
Ici sont demandés le nom de l’acteur et son Id.
Dans le contexte d’une session w4adm (dont l’id est 1), il retourne le texte suivant :
ABC w4adm DEF
IJK 1 LMN
Objets workflow
Tous les objets du contexte de substitution W4 Engine sont identifiables. Ils sont
introduits par le caractère @.
Quelques exemples :
@actor : acteur courant

W4 BPM Suite
@task : tâche courante
@case : dossier courant
NOTE TECHNIQUE
Acteur automatique
36

@activity : activité correspondant à la tâche courante
@procedure : procédure correspondant au dossier courant
etc.
Pour chaque objet, chaque attribut ou chaque variable peut être référencé :
@actor.name ou @actor.name.str : identifiant texte de l’acteur courant

@actor.name.id identifiant numérique de l’acteur courant
@actor.firstname : prénom de l’acteur courant
@task.actor : acteur de la tâche
@task.myvariable.value : valeur de la variable de tâche myvariable
etc.
Des macros existent pour quelques objets courants :
@lg pour @actor.language

@id pour l’id de l’acteur (@actor.name.id)
@lid pour l’identifiant de la session courante (lid pour logical id)
@wfs pour l’identifiant de l’instance de workflow courante (wfs pour workflow service)
@ctx pour la chaîne « lg=@lg&id=@id&lid=@lid&wfs=@wfs », utilisée dans les
URL «CGI » pour propager un contexte de session.
Exemple
Source modèle :
Current actor (login @actor.name) is called: @actor.firstName
@actor.lastName
His language code is '@lg'.
Après substitution dans un contexte de session de l’acteur John Smith, login jsmith :
Current actor (login jsmith) is called: John Smith
His language code is 'en'
Dictionnaires (map)
Les dictionnaires ont été introduits originellement pour traduire des libellés selon le
contexte de langue. Une utilisation dérivée est la génération conditionnelle du code. Les
dictionnaires sont nommés map en anglais. Le terme map s’est imposé, au féminin, en
français. Il sera utilisé dans la suite du texte.
Un dictionnaire est une table de traduction, où à chaque entrée, qui est une chaîne de
caractères quelconque, est associée une traduction en une ou plusieurs autres chaînes de
caractères, éventuellement distinguées par leur langue.
Exemple
Map traduisant des codes couleurs (chaînes "1" et "2") en clair, en anglais et en français.
37
NOTE TECHNIQUE
[W4MAP colourmap]
[W4ENTRY 1 en]red[/W4ENTRY]
[W4ENTRY 1 fr]rouge[/W4ENTRY]
[W4ENTRY 2 en]blue[/W4ENTRY]
[W4ENTRY 2 fr]bleu[/W4ENTRY]
[/W4MAP]
La syntaxe de référence à une traduction de la map est {entry_string:map_name}.
Si la langue de l’acteur est l’anglais (en) :
{1:colourmap} est traduit red
Si c’est le français (fr) :
{1:colourmap} est traduit rouge
Une entrée peut être la valeur d’un objet : {@task.prioritycolour.value:colourmap}.
L’ordre des entrées est indifférent et on pourra préférer une organisation par langue. Soit
pour la même map :
[W4MAP colourmap]
[/W4MAP]
Exemple
Source modèle :
...
[W4MAP countryname]
[W4ENTRY fr en]France[/W4ENTRY]
[W4ENTRY uk en]United Kingdom[/W4ENTRY]
[W4ENTRY fr fr]France[/W4ENTRY]
[W4ENTRY uk fr]Royaume-Uni[/W4ENTRY]
[/W4MAP]
...
His country code '@actor.country' means
'{@actor.country:countryname}'.
...
W4 BPM Suite
NOTE TECHNIQUE
Acteur automatique
38
L Remarque
Les « ... » représentent le « reste » du source non significatif pour l’exemple, avant et
après substitution.
Source substitué dans le contexte John Smith, anglais s’il en est :
...
His country code 'uk' means 'United Kingdom'.
...
Noter que les maps « disparaissent » une fois interprétées. Tous les caractères entre
[W4MAP ….] et [/W4MAP], retour à la ligne et ces mot-clés inclus, sont supprimés. Tous
ceux en dehors sont conservés.
[W4MAP colour]
[WMAPENTRY NULL en]colour not set[/W4ENTRY]
[W4MAPENTRY 0 en]white[/W4ENTRY]
[W4MAPENTRY 1 en]red[/W4ENTRY]
[W4MAPENTRY 2 en ]blue[/W4ENTRY]
[W4MAPENTRY DEFAULT en]unknown colour code[/W4ENTRY]
[/W4MAP]
{@var:colour}
Après substitution, en supposant le contexte de langue ‘en’ et que @var contient la
chaîne « 1 » :
Red
Qui contient une ligne blanche en-tête correspondant au retour à la ligne suivant
[/W4MAP], caractère se trouvant être en dehors des « frontières » de la map.
Pour ne pas avoir de ligne blanche après substitution, il faut écrire sur la même ligne que
[/W4MAP], soit :
[W4MAP colour]
[W4MAPENTRY NULL]colour not set[/W4ENTRY]
[W4MAPENTRY 0]white[/W4ENTRY]
[W4MAPENTRY 1]red[/W4ENTRY]
[W4MAPENTRY 2]blue[/W4ENTRY]
[W4MAPENTRY DEFAULT]unknown colour code[/W4ENTRY]
[/W4MAP]{@var:colour}
Après substitution, en supposant que @var contient toujours la chaîne ou le nombre 1 :
Red
39
NOTE TECHNIQUE
Les éléments syntaxiques suivants sont aussi disponibles :
reconnaître une entrée vide (objet à valeur vide) ;
traduction par défaut d’une chaîne non reconnue ;
traduction par défaut si la langue de l’entrée n’est pas reconnue.
A titre d’exemple, on enrichit au fur et à mesure la map exemple définie auparavant, on
introduit une traduction pour l’entrée NULL en anglais et en français soit :
Reconnaissance de l’entrée vide : mot-clé NULL. Soit :
[W4MAP colourmap]
[W4ENTRY NULL en]no colour[/W4ENTRY]
[W4ENTRY NULL fr]pas de couleur[/W4ENTRY]
[/W4MAP]
Puis l’on introduit maintenant l’entrée par défaut qui donne la traduction, ici en anglais et
en français, des entrées non reconnues (en l’occurrence, ni vide, ni 1, ni 2). L’entrée par
défaut est introduite par le mot-clé « default ».
Soit toujours :
[W4MAP colourmap]
[W4ENTRY default en]unknown colour code[/W4ENTRY]
[W4ENTRY default fr]code couleur inconnu[/W4ENTRY]
[/W4MAP]
Enfin, si le contexte de langue n’est pas reconnu, il faut introduire une traduction par
défaut, identifiée à nouveau par le mot-clé default, en seconde position cette fois. Soit,
pour les 4 entrées NULL, 1, 2 et default, les langues en, fr et default (qui donne de
l’anglais) :
W4 BPM Suite
NOTE TECHNIQUE
Acteur automatique
40
[W4MAP colourmap]
[W4ENTRY NULL default]no colour[/W4ENTRY]
[W4ENTRY 1 default]red[/W4ENTRY]
[W4ENTRY 2 default]blue[/W4ENTRY]
[W4ENTRY default en]unknown colour code[/W4ENTRY]
[W4ENTRY default fr]code couleur inconnu[/W4ENTRY]
[W4ENTRY default default]unknown colour code[/W4ENTRY]
[/W4MAP]
Notez la dernière entrée « default default » : entrée par défaut dans la langue par
défaut.
Le mot-clé @mapentry permet d’afficher la valeur de l’entrée. La fin de la map
précédente peut être enrichie ainsi :
...
[W4ENTRY 2 default]blue[/W4ENTRY]
[W4ENTRY default en]unknown colour code (value: @mapentry)[/W4ENTRY]
[W4ENTRY default fr]code couleur inconnu (value:
@mapentry)[/W4ENTRY]
[W4ENTRY default default]unknown colour code (value:
@mapentry)[/W4ENTRY]
[/W4MAP]
Finalement une entrée de map peut référencer une map définie auparavant ou ellemême selon la syntaxe suivante :
...
[W4ENTRY value language]{value:mapname}[/W4ENTRY]
...
Utilisation pour la génération conditionnelle
En programmation de l’acteur automatique les maps sont surtout utilisées en génération
conditionnelle pour réaliser un « if then else » ou plus généralement un « switch ».
Dans ce cas la langue importe peu, seule la langue default est stipulée :
41
NOTE TECHNIQUE
...
[W4MAP ifelsemap]
[W4ENTRY condition default]text generated if condition
verified[/W4ENTRY]
[W4ENTRY default default]text generated if condition not
met[/W4ENTRY]
[/W4MAP]
...
{@something:ifelsemap}
...
Si @something est valué "condition" alors la traduction du source ci-dessus est :
...
text generated if condition verified
...
Pour toute autre valeur de chaîne la traduction est :
...
text generated if condition not met
...
Le « if » simple se traduit ainsi :
[W4MAP ifmap]
[W4ENTRY condition default]text generated if condition
verified[/W4ENTRY]
[W4ENTRY default default][/W4ENTRY]
[/W4MAP]
Le « switch » ainsi :
[W4MAP switch]
[W4ENTRY condition1 default]text generated if condition1
verified[/W4ENTRY]
[W4ENTRY condition2 default]text generated if condition2
verified[/W4ENTRY]
[W4ENTRY default default][/W4ENTRY]
[/W4MAP]
Génération itérative
La génération itérative se fait à partir d’un objet multivalué.
W4 BPM Suite
NOTE TECHNIQUE
Acteur automatique
42
@LOOP(@task.Reference @task.UnitPrice)
Reference: @item.1.value Unit price: @item.2.value
@/LOOP
Si la variable de tâche « Reference » contient la valeur multiple « Part1 », « Part2 » et la
variable UnitPrice contient la les valeurs « 12 », « 23 », on obtient comme affichage :
Reference: Part1 Unit price: 12
Reference: Part2 Unit price: 23
Recherche (script)
Outre les objets du contexte de substitution, il est nécessaire de pouvoir référencer les
autres objets, résultats d’une requête de recherche d’objets serveur. Les exemples les
plus évidents sont la corbeille de l’acteur ou la liste des dossiers en cours de l’acteur.
Pour cela il faut pouvoir spécifier une recherche et après cela itérer sur les résultats de la
recherche. Le résultat est un tableau d’objets.
La spécification de l’API ou de la suite d’API est :
[W4SCRIPT scriptname]
...script definition...
[/W4SCRIPT]
Le script devient un objet référençable du type résultat de la recherche, sur lequel on
peut notamment itérer avec le mot-clé @LOOP :
@LOOP (@scriptname)
...
@/LOOP
La définition est fondée sur les « API URL C » qui permettent de décrire sous forme d’un
URL toutes les API de W4 Engine.
C’est la même que celle utilisée dans les URL des applications web W4, dites « CGI » et
dans la commande href= "" de l’acteur automatique.
Ces APIs URL C et leur usage sont définies en détail dans :
3 Note technique - Langage W4
Cependant la définition donne une certaine souplesse car le script peut être défini en
plusieurs lignes :
43
NOTE TECHNIQUE
[W4SCRIPT mysearch]
cmd=search&
object=task&
...
[/W4SCRIPT]
@include_url
Cette fonction permet de substituer le retour d’un URL. La syntaxe en est :
@include_url(URL)@/include
Où URL est un URL HTTTP complet, y compris la chaîne « http: » (notez la dissymétrie
« include_url » d’un côté, « include » tout court de l’autre).
L’URL est soumis. Son exécution a lieu ; durant ce temps le « parseur » attend. Le texte
réponse de l’URL est récupéré par le « parseur ». Il est substitué à la chaîne
@include_url(URL)@/include.
Dans le contexte de l’acteur automatique, les usages de « include_url» sont multiples :
mise à jour de base métier ;
envoi d’un courrier électronique d’information ;
scripting d’actions trop complexes ou impossibles à exprimer en langage W4.
En contrepartie, les performances d’exécution des URL sont à surveiller.
Exemple commenté
Envoi de mail d’information par l’acteur automatique.
// send mail via my Java/JSP script
@include_url(http://scriptserver/scripts/mySendMail.jsp?dest=@dest&.
..)@/include
Après substitution, en supposant que l’URL ne rende rien on obtient :
Code valide (vide !) interprété par l’acteur automatique.
Si l’URL « rend » quelque chose du type :
W4 BPM Suite
NOTE TECHNIQUE
Acteur automatique
44
<html> ...
Mail sent
...
</html>
L’acteur automatique « ne reconnaît pas ses petits » et passe en traitement d’erreur de
script non reconnu.
Les scripts sont développés ou remaniés spécifiquement pour répondre à cette
contrainte.
Bien entendu un script peut rendre une séquence valide pour l’acteur automatique.
@include_url(http://scriptserver/scripts/mySendMailRC.jsp?dest=@dest
)@/include
MySendMailRC.jsp rend un code retour sous la forme exacte "outvalue=value". Soit par
exemple pour une exécution sans encombre :
Outvalue=0
Outvalue= est une syntaxe correcte qui sera reconnue par l’acteur automatique.
45
NOTE TECHNIQUE
8
Annexe 2 - Autres commandes de
l’acteur automatique
Attention !
Les commandes ci-dessous sont conservées pour compatibilité ascendante du produit. Leur
usage est déconseillé.
Commande href - exec et clearexec
Exécution d’un URL W4 (uniquement) tel qu’il apparaît dans un document HTML.
Dans href=, la macro « exec » peut être utilisée à la place de « cgi.exe ».
Soit : href="/W4/exec?..."
La macro « clearexec » est utilisée pour indiquer que l’URL ne doit pas être crypté.
href="/W4/clearexec?..."
Si la commande nexttemplate (voir ci-dessous) est utilisée, évite le double cryptage.
Commande href - fileOut
Pour pouvoir récupérer le résultat de la commande, un paramètre complémentaire est
introduit : fileOut qui indique un fichier résultat récupérable par l’acteur automatique.
Si le nom de fichier est relatif, le fichier est créé dans le répertoire de wfautomatic.exe,
soit …/w4/bin. Il est donc souhaitable d’utiliser des chemins absolus (voir exemple cidessous).
Le fichier n’est pas détruit sauf s’il est utilisé dans nextTemplate.
L Remarque
L’environnement disponible dans ce contexte est l’environnement de wfautomatic.exe et non
l’environnement CGI. Le répertoire temporaire est accessible par @env.TEMP.
Exemple
href="/W4/exec?@ctx&cmd=...&template=Acti1&fileOut=@(env.TEMP)/out&..."
nextTemplate=@(env.TEMP)/out
Commande nextTemplate
nextTemplate=nextTemplate
Définition du prochain script interprété par l’acteur automatique. Si plusieurs lignes de ce type
existent, la dernière prévaut. Ce mécanisme permet de chaîner le traitement de plusieurs
scripts pour une même tâche.
Typiquement le contenu variable de ce fichier peut être généré dynamiquement par une ou
plusieurs commandes du script courant.
Plusieurs fichiers de ce type peuvent être chaînés.
W4 BPM Suite
NOTE TECHNIQUE
Acteur automatique
46
Si le nom de fichier est relatif, le fichier est créé dans le répertoire de wfautomatic.exe, soit
<répertoire d’installation>/w4/bin. Il est donc souhaitable d’utiliser des chemins absolus, par
exemple en utilisant le répertoire temporaire (voir exemple ci-dessous).
Ces fichiers sont détruits une fois traités. Ces fichiers suite ne sont pas « parsés ». Ce qui
entraîne, hélas, la subtilité suivante. Si le fichier désigné par nextTemplate= contient la ligne
:
href="/W4/exec?id=123&lid=123332&lg=fr&wfs=w4adm&cmd=…"
il y a erreur.
En effet, la pattern « /W4/exec? » est de fait une forme reconnue par le parseur W4. Elle est
remplacée par « /W4/cgi.exe? », comme chacun peut le voir dans le source des modèles tels
que reçus par les navigateurs. La ligne correcte est donc :
href="/W4/cgi.exe?id=123&lid=123332&lg=fr&wfs=w4adm&cmd=…"
47
NOTE TECHNIQUE
Annexe 2 - Autres commandes de l’acteur automatique
Note technique
W4 Engine
Acteur automatique
Pour toute remarque ou suggestion concernant ce document, vous pouvez contacter le
support technique W4, en précisant la référence W4TN_AUTO_ACTOR_004_FR :
par le service de traitement des dossiers Supportflow sur MyW4.com, à l’adresse
suivante : http://support.myw4.com
par courrier électronique : [email protected]
par téléphone : 33 (0) 820 320 762