Red Hat JBoss jBPM
Tutoriel Red Hat JBoss jBPM (version community) (9) : démarrage et test final de l'exécution complète du processus de recrutement
L'objectif de cet article est de voir le déroulement complet du processus avec le démarrage du processus avec son formulaire associé, puis la connexions des différents participants avec la récupération des tâches dans leur corbeille, la saisie du formulaire associé et la progression automatique du workflow.
En étant connecté avec le user « admin », démarrez une instance du processus :
- Menu Process Management - Process Definitions - sélectionnez recrutement - cliquez sur start
Le formulaire de démarrage du processus s'affiche.
Pour simplifier, dans notre exemple, c'est admin qui spécifie que le candidat sera "rhona" pour le poste "urbaniste SI" et le test de compétence (ah si tous les tests d'embauche étaient comme celui-ci ...) "2 + 2 = " auquel devra répondre le candidat pour ensuite être évalué par "sylvie" des ressources humaines, "thierry" du groupe Chef de Projet et la décision finale sera prise par "jacques" du groupe Direction Générale au vu de 2 recommandation RH et CP.
Dans le menu Process Management - Process Instances - Onglet de droite « Instance Detail » montre la "human task" "Test de competence" active et dans l'état "Reserved" pour "rhona".
L'onglet "Process Variables" affiche les valeurs de toutes les variables de processus.
Le flow est passé à la 1ère tâche « Test de compétences ».
Déconnectez-vous et connectez-vous avec le user « rhona », supposons que ce soit une candidate au poste.
Récupérez la tâche en attente, remplissez et validez le formulaire comme indiqué dans l'écran suivant.
Recommencez les mêmes étapes avec « sylvie » du groupe RH,
Une fois la dernière tâche exécutée (la décision du DG est prise), le processus se termine.
Ce didacticiel complet a permis de voir :
- l’installation jBPM,
- une présentaton de l’IDE KIE Workbench,
- la création d’un projet dans un repository dans une unité organisationnelle,
- la conception d’un processus métier à la norme BPMN 2 avec l’outil web
- la conception des formulaires associés aux tâches humaines
- le déploiement du processus dans le moteur de jBPM
- le démarrage et l’exécution d’une instance de processus
- la récupération et l’accomplissement des tâches par les différents acteurs en fonction de leurs affectations.
Un bon nombre de thématiques n’ont pas été traitées comme
- l’administration,
- l’exploitation,
- la persistance,
- les transactions,
- les performances,
- le processus de mise en production,
- le BAM (Business Activity Monitoring),
- la simulation (BPMSim),
- la gouvernance, l
- e cycle de vie,
- l’aspect méthodologique de conception des processus métier,
- le lien avec l’urbanisme et la stratégie des SI ,
- le retour sur investissement d'un outil de BPM,
- les outils réservés aux développeurs,
- l’intégration d’un moteur de règles métiers, j’en passe et des meilleurs, …
Mais il faut bien en garder un peu pour d’autres aventures « tutorielesques » qui verront le jour très prochainement.
"L'homme naît sans dents, sans cheveux et sans illusions, et il meurt de même, sans cheveux, sans dents et sans illusions."
Alexandre Dumas
Voir aussi :
http://urbanisation-si.wix.com/blog
http://urbanisme-si.wix.com/blog
http://urbanisation-si.wix.com/urbanisation-si
http://urbanisation-si.over-blog.com/
http://rhonamaxwel.over-blog.com/
http://urbanisation-des-si.blogspot.fr/
Tutoriel Red Hat JBoss jBPM (version community) (8) : construction et déploiement du processus de notre étude de cas
Une fois les formulaires personnalisés, on déploie le projet :
- Cliquez sur le bouton Open Project Editor - Menu Build - Build & Deploy -
- Cliquez sur le bouton undeploy correspondant au projet.
Vous devez avoir le message comme quoi c'est bien déployé.
Dans le cas contraire vérifiez si par exemple le projet n'est pas déjà déployé : Menu Deploy- Process Deployments -
Etant donné que tout a été généré et validé par l’outil, il ne devrait pas y avoir d’erreur lors du déploiement.
Dans le prochain article nous verrons le déroulement complet du processus avec le démarrage du processus avec son formulaire associé, puis la connexions des différents participants avec la récupération des tâches dans leur corbeille, la saisie du formulaire associé et donc la progression du workflow.
"L'incrédulité est quelquefois le vice d'un sot, et la crédulité le défaut d'un homme d'esprit."
Denis Diderot
Voir aussi :
http://urbanisation-si.wix.com/blog
http://urbanisme-si.wix.com/blog
http://urbanisation-si.wix.com/urbanisation-si
http://urbanisation-si.over-blog.com/
http://rhonamaxwel.over-blog.com/
http://urbanisation-des-si.blogspot.fr/
Tutoriel Red Hat JBoss jBPM (version community) (7) : génération de formulaires et mapping des variables
L'objectif de cet article est de voir comment on génère automatiquement des formulaires et comment on mappe les champs avec les variables locales aux tâches.
Voyons tout d’abord les variables globales d’un processus.
Au démarrage de l’instance du processus, ces variables seront créées et éventuellement initialisées.
Pour définir les propriétés du processus, cliquez quelque part dans la zone de travail. La zone de gauche affiche alors les propriétés du processus.
Cliquez sur "Définitions de variables" puis saisir les variables du processus qui seront utilisées en entrée ou en sortie des tâches.
Vérifiez et modifier les autres champs (id, nom, package, processus exécutable, ...) avec les valeurs de l'écran ci-dessus.
La transmission en entrée et en sortie des valeurs des différents champs de formulaires se fait par recopie des variables globales de processus dans des variables locales de chaque tâche, puis sur le formulaire on va mapper chaque champ en entrée ou en sortie avec ces variables locales.
Pour générer automatiquement tous les formulaires de toutes les tâches en plus du formulaire attaché au démarrage du processus, dans le bandeau en haut, sélectionner l’icône de génération de formulaires, dans le menu déroulant, sélectionnez « Générer tous les formulaires »
Dans le répertoire src, les formulaires apparaissent avec leur convention de nommage : <nom de la tâche>-takform.form
Pour notre tutoriel dont l’objectif est de voir les étapes de conception d’un processus métier simple, nous garderons en l’état le look des formulaires générés, sachant que l’on peut les personnaliser. De même l’aspect manipulation sera réduit à sa plus simple expression en manipulant en entrée/sortie les variables globales du processus.
Sélectionnez dans l’ordre les formulaires et modifiez-les en fonction des écrans ci-dessous.
Le formulaire correspondant au processus se nomme tutojbpm.recrutement-taskform.form. Il contient par défaut tous les champs correspondants aux variables de processus.
Ne laissez que les champs : "candidat, poste et testCompetence" et supprimez les autres.
Nous nous contenterons de spécifier les valeurs en entrée/sortie des variables locales liées aux zones de saisies.
Sélectionnez le champ candidat, cliquez sur le crayon pour avoir accès aux propriétés du champ, sélectionnez "Output binding expression", saisissez candidat et cliquez sur « Required ». La valeur saisie dans le champ candidat sera recopiée dans la variable globale de processus "candidat" et pourra être récupérée par les autres formulaires des autres tâches pour être affiché.
Répétez les mêmes étapes pour les champs "poste" et "testCompetence".
Répétez les étapes précédentes pour les formulaires :
testCompetence-takform.form
poste :
Input binding expression : poste
*testCompetence :
Output binding expression : testCompetence (Required)
entretienRH-takform.form
poste :
Input binding expression : poste
*recommandationRH :
Output binding expression : recommandationRH (Required)
testCompetence :
Input binding expression : testCompetence
poste :
Input binding expression : poste
*recommandationCP :
Output binding expression : recommandationCP (Required)
testCompetence :
Input binding expression : testCompetence
candidat :
Input binding expression : candidat
*decisionFinale :
Output binding expression : decisionFinale (Required)
poste :
Input binding expression : poste
recommandationCP :
Input binding expression : recommandationCP
recommandationRH :
Input binding expression : recommandationRH
testCompetence :
Input binding expression : testCompetence
Dans le prochain article on verra comment déployer le processus puis exécuter une instance de processus avec l'affichage des formulaire permettant la saisie des utilisateurs.
"Une société d'athées inventerait aussitôt une religion."
Honoré Balzac
Voir aussi :
http://urbanisation-si.wix.com/blog
http://urbanisme-si.wix.com/blog
http://urbanisation-si.wix.com/urbanisation-si
http://urbanisation-si.over-blog.com/
http://rhonamaxwel.over-blog.com/
http://urbanisation-des-si.blogspot.fr/
Tutoriel Red Hat JBoss jBPM (version community) (6) : vérifiez la conformité à la norme BPMN 2
A ce stade, vous pouvez activer la validation qui va vérifier la conformité de votre processus avec la norme des processus exécutables BPMN 2 (exemple : un processus exécutable doit avoir un nœud de fin, si vous supprimez celui de votre processus, la validation va vous avertir qu’il en faut un).
"On n'est curieux qu'à proportion qu'on est instruit."
Jean-Jacques Rousseau
Voir aussi :
http://urbanisation-si.wix.com/blog
http://urbanisme-si.wix.com/blog
http://urbanisation-si.wix.com/urbanisation-si
http://urbanisation-si.over-blog.com/
http://rhonamaxwel.over-blog.com/
http://urbanisation-des-si.blogspot.fr/
Tutoriel Red Hat JBoss jBPM (version community) (5) : conception du processus en BPMN 2
Après cet intermède administratif mais ô combien nécessaire, passons à la conception du processus qui va être réalisé par un expert métier dûment formé à BPMN 2 et à l'outil KIE Workbench (pour simplifier nous resterons connecter avec admin).
Pour modéliser le processus en BPMN :
- Menu : Authoring - Project Authoring - Explore - Assurez-vous d'avoir bien sélectionné l'unité com.urbanisation-si, le repository blogrepo et le projet tutojbpm - New Item - Business Process - Saisir le nom du processus "recrutement" - laissez le nom du package proposé : com.urbanisation_si.tutojbpm
A priori jBPM va utiliser ce nom à la compilation, c'est pour cette raison que le - de urbanisation-si se transforme en _ (un nom Java ne peut pas contenir le caractère - qui est réservé).
Cliquez sur les doubles chevrons de gauche (<<) pour afficher la bibliothèque BPMN 2 et sur les doubles chevrons de droite (>>) pour afficher les propriétés d'un élément sélectionné.
Tout est contextuel, le modeleur BPMN 2 web inclus tout ce qui se fait de mieux en terme de client web riche.
En sélectionnant un élément dans la zone de travail, des symboles apparaissent tout autour vous permettant très rapidement de développer votre processus sans avoir à retourner dans la toolbox ou dans la zone de propriété.
- Sélectionnez dans "Evènements de commencement", l'évènement de début simple (rond vide), faites un "drag and drop" dans la zone de travail.
- Cliquez dessus, des icônes apparaissent tout autour du symbole.
- Cliquez sur le rectangle, une nouvelle tâche avec un « séquence flow » est automatiquement créé. Sélectionnez la tâche, cliquez sur le symbole de gateway exclusive XOR (X), la gateway est créée avec le « séquence flow »,
- Sélectionnez la gateway, cliquez sur le rectangle, puis une 2ème fois pour avoir 2 tâches en parallèles à partir de gateway.
- Sélectionnez la 1ère tâche, cliquez sur le symbole de gateway,
- Sélectionnez la 2ème tâche, cliquez sur le symbole de flèche « séquence flow » et amener la souris sur la 2ème gateway.
- Sélectionnez la 2ème gateway, cliquez sur le rectangle,
- Sélectionnez la dernière tâche et cliquez sur le symbole du rond entouré (évènement de fin).
- Sauvegardez régulièrement en cliquant sur le bouton en haut à droite.
- Sélectionnez à tour de rôle chaque tâche, cliquez sur le symbole de clé et sélectionnez « Tâche Utilisateur ».
- Double cliquez sur chacune d’entre elle, une zone de saisie apparaît pour nommer vos tâches.
- Sélectionnez à tour de rôle chaque gateway, cliquez sur le symbole de la clé et sélectionnez «Parallel »
- Il reste pour chaque tâche à configurer la partie "subject" c'est à dire le libellé qui apparaîtra sur les formulaires
- Configuez le mapping des données en entrées et en sorties. Pour chacune des tâches, cliquez sur "Tâches à compléter" et suivez les écrans suivants.
Voir ci-dessous.
Remarque : cette tâche est réservée à l'utilisateur dont le user de connexion est renseignée dans la variable de processus "candidat" initialisée au démarrage du processus par "admin".
Pour que cette tâche se retrouve dans la corbeille correspondant à la variable "candidat", il faut mettre dans la propriété "Acteur" la chaîne : #{candidat}
Ce mapping signifie qu'en entrée, les valeurs des variables de processus (globlaes) "poste" et "testCompetence" sont recopiées dans les variables locales de la tâche portant le même nom (on aurait pu donner des noms différents car les zones de mémoires correspondantes sont bien différentes).
De même en sortie, la valeur de la variable locale testCompetence" est recopiée dans la variable globale du même nom.
Remarque : cette tâche est réservée au groupe "RH".
Pour que cette tâche se retrouve dans la corbeille du groupe "RH", il faut mettre dans la propriété "Acteur" la valeur RH
Ce mapping signifie qu'en entrée, les valeurs des variables de processus (globlaes) "poste", "testCompetence" et "candidat" sont recopiées dans les variables locales de la tâche portant le même nom (on aurait pu donner des noms différents car les zones de mémoires correspondantes sont bien différentes).
De même en sortie, la valeur de la variable locale "recommandationRH" est recopiée dans la variable globale du même nom.
Remarque : cette tâche est réservée au groupe "CP".
Pour que cette tâche se retrouve dans la corbeille du groupe "CP", il faut mettre dans la propriété "Acteur" la valeur CP
Ce mapping signifie qu'en entrée, les valeurs des variables de processus (globlaes) "poste", "testCompetence", "recommandationCP" et "candidat" sont recopiées dans les variables locales de la tâche portant le même nom (on aurait pu donner des noms différents car les zones de mémoires correspondantes sont bien différentes).
De même en sortie, la valeur de la variable locale "recommandationCP" est recopiée dans la variable globale du même nom.
Remarque : cette tâche est réservée au groupe "DG".
Pour que cette tâche se retrouve dans la corbeille du groupe "DG", il faut mettre dans la propriété "Acteur" la valeur DG
Ce mapping signifie qu'en entrée, les valeurs des variables de processus (globlaes) "candidat", "poste", "testCompetence", "recommandationRH" et "recommandationCP" sont recopiées dans les variables locales de la tâche portant le même nom (on aurait pu donner des noms différents car les zones de mémoires correspondantes sont bien différentes).
De même en sortie, la valeur de la variable locale "decisionFinale" est recopiée dans la variable globale du même nom.
Quand le flow d’exécution arrivera sur une tâche, le moteur la placera dans la corbeille de l'utilisateur ou du groupe correspondant au user de connexion à l'application en fonction de la valeur de la propriété "Acteur" de la tâche.
A la connexion, l'utilisateur pourra alors consulter la liste des tâches en attente qui lui sont réservées.
Il pourra sélectionner une tâche.
Si un formulaire a été associé à la tâche, il s'affichera avec le bouton "Réclamer" (Claim).
Les champs de formulaires afficheront les valeurs des variables locales associées en entrée et initialisés en fonction du mapping avec les variables globales (processus).
Si l'utilisateur clique sur ce bouton, il pourra saisir dans les champs de sortie associés aux variables locales dont les valeurs seront recopiés ensuite dans les variables globales de processus en fonction du mapping.
Une fois le formulaire rempli, l'utilisateur clique le bouton "Terminer" (Complete), ce qui a pour effet de faire avancer à la ou les tâche(s) suivante(s) dans le processus.
Nous verrons dans le prochain article la conception des formulaires.
"L'amour, c'est l'espace et le temps rendus sensibles au coeur."
Proust Marcel
Voir aussi :
http://urbanisation-si.wix.com/blog
http://urbanisme-si.wix.com/blog
http://urbanisation-si.wix.com/urbanisation-si
http://urbanisation-si.over-blog.com/
http://rhonamaxwel.over-blog.com/
http://urbanisation-des-si.blogspot.fr/
Tutoriel Red Hat JBoss jBPM (version community) (4) : connexion à l'IDE KIE Workbench et création des unités organisationnelles
Le KIE Worbench se lance à partir d'un navigateur :
Si par le plus grand des hasards, l'application ne se chargeait pas, vérifier dans le répertoire
de ne pas avoir le fichier jbpm-console.war.undeployed
Si c'est le cas, supprimer le (ATTENTION pas le fichier jbpm-console.war mais l'autre avec l'extension .undeployed).
En le supprimant vous devriez voir apparaître un nouveau fichier avec l'extension isdepoying puis au bout de quelques instants qui se transforme en .deployed !
On va créer d'abord créer une nouvelle unité organisationnelle qui peut par exemple correspondre à une zone métier ou une zone ressouce pour un grand compte (domaine banque, domaine assurance, RH, DSI, ...).
Dans l'exemple nous créerons l'organisation "com.urbanisation-si".
Une unité organisationnelle peut avoir plusieurs repository de stockage des ses processus, règles et objets métiers. Nous créerons ici pour les besoins du tutoriel le repository "blogrepo".
Et enfin, un repository peut contenir plusieurs projet pouvant correspondre à une application. Nous créerons le projet "tutojbpm".
Dans l'écran du KIE Workbench, connectez vous en administrateur avec admin et le mot de passe admin.
Vous pouvez franciser l'application en cliquant sur la roue dentée en haut à droite et prendre French.
Pour ce tutoriel nous resterons dans la langue de William Shakespeare et en mode Basic.
Créer une nouvelle unité organisationnelle :
Menu : Authoring - Administration - Organizational Units - Manage Organizational Units - Add - Saisir le nom "com.urbanisation-si"
Créer un nouveau repository :
Menu : Repositories - New Repository - Saisir "blogrepo" - sélectionner l'unité "com.urbanisation-si" et cliquez sur Managed Repository pour avoir la gestion des versions.
Créer un nouveau projet :
Menu : Authoring - Project Authoring - New Item - Project - Saisir "tutojbpm"
"Tu dois devenir l'homme que tu es. Fais ce que toi seul peux faire. Deviens sans cesse celui que tu es, sois le maître et le sculpteur de toi-même."
Friedrich Nietzsche
Voir aussi :
http://urbanisation-si.wix.com/blog
http://urbanisme-si.wix.com/blog
http://urbanisation-si.wix.com/urbanisation-si
http://urbanisation-si.over-blog.com/
http://rhonamaxwel.over-blog.com/
http://urbanisation-des-si.blogspot.fr/
Tutoriel Red Hat JBoss jBPM (version community) (3) : démarrer l'ensemble des composants
Mettons en ordre de marche l'ensemble :
ou
ant start.demo.noeclipse
pour ne pas démarrer Eclipse
Cette tâche ant démarre :
- le SGBD H2
- le serveur wildfly
- KIE Workbench (IDE) et le dashboard (BAM)
- Eclipse
A noter qu'il existe toute une flopée de tâches Ant pour démarrer uniquement tel ou tel composant non obligatoire comme Eclipse par exemple.
A ce stade vous devriez avoir Eclipse Luna d'ouvert.
La partie réservée aux développeurs comme les APIs jBPM permettant les tests unitaires, le débogage, l'audit et la simulation de processus sera abordée dans un tutoriel ultérieur.
Eclipse peut être refermé sans impact.
"Trois sortes d'amis sont utiles, trois sortes d'amis sont néfastes. Les utiles : un ami droit, un ami fidèle, un ami cultivé. Les néfastes : un ami faux, un ami mou, un ami bavard."
Confucius
Voir aussi :
http://urbanisation-si.wix.com/blog
http://urbanisme-si.wix.com/blog
http://urbanisation-si.wix.com/urbanisation-si
http://urbanisation-si.over-blog.com/
http://rhonamaxwel.over-blog.com/
http://urbanisation-des-si.blogspot.fr/
Tutoriel Red Hat JBoss jBPM (version community) (2) : l'installation
Mais assez parlé et passons aux choses sérieuses. Comme à l'habitude dans mes tutoriaux, je vais partir de 0.
jBPM étant conçu en Java, il vous faut l'installer (si ce n'est pas déjà fait). La dernière version Java 8 fait parfaitement l'affaire :
http://www.oracle.com/technetwork/java/javase/downloads/jdk8-downloads-2133151.html
Pensez bien à configurer les variables d'environnement JAVA_HOME avec le répertoire d'installation du jdk et la variable PATH avec le répertoire bin.
J'aurais aimé télécharger et cliquer sur un exécutable, qui masque toute la cuisine interne et arriver directement sur l'IDE.
Mais jBPM a choisi de fournir un script Ant, permettant, il est vrai, aux architectes et aux développeurs d'avoir un script prêt à l'emploi qui pourra avantageusement servir à l'exploitation et être personnalisée à loisir en fonction par exemple du SGBD utilisé.
L'installation complète propose un script Ant pour démarrer, arrêter, nettoyer les différents composants de la suite jBPM.
Téléchargez Ant
http://ant.apache.org/bindownload.cgi
Dézippez et configurez la variable d'environnement ANT_HOME avec le répertoire d'installation.
Téléchargez jBPM :
http://sourceforge.net/projects/jbpm/files/jBPM%206/jbpm-6.3.0.Final/
Cliquez: Download jbpm-6.3.0.Final-installer-full.zip (390.2 MB)
Dézippez pour obtenir le répertoire jbpm-installer.
Avant de commencer à exécuter l'intégration des briques, je vous conseille d'ajouter tout de suite les users et les rôles nécessaires au bon déroulement de notre processus.
Sinon, après l'installation, vous seriez obligé de faire « ant clean.demo », modifiez les fichiers et à nouveau ant install.demo et vous perdriez votre repository avec vos processus.
Ajoutez les noms des utilisateurs et leur mot de passe dans le fichier users.properties du répertoire auth de jbpm-installer :
sylvie=sylvie
thierry=thierry
helena=helena
jacques=jacques
et leurs rôles (groupes) dans le fichier roles.properties :
sylvie=analyst,HR,RH
thierry=analyst,PM,CP
helena=analyst,DG,RH
jacques=analyst,DG
Les nouveaux utilisateurs et leurs rôles seront directement intégrés dans le serveur d'application JBoss Wildfly.
L'installation se lance en ligne de commande dans le répertoire jbpm-installer :
Le script télécharge les briques nécessaires comme le serveur d'application JBoss Wildfly, la base H2, le driver adéquat, Hibernate, Eclipse Luna et les plugins jbpm, etc, etc, ...
Le nouvel IDE, KIE Workbench (jbpm-console.war) est installé en vue d'être déployé quand on démarrera le serveur, les plugins sont installés dans Eclipse.
Le reporting est une application web (dashboard-builder.war) à part qu'il faut installer :
Suspens, la suite au prochain épisode.
"La règle d'or de la conduite est la tolérance mutuelle, car nous ne penserons jamais tous de la même façon, nous ne verrons qu'une partie de la vérité et sous des angles différents."
Gandhi
Voir aussi :
http://urbanisation-si.wix.com/blog
http://urbanisme-si.wix.com/blog
http://urbanisation-si.wix.com/urbanisation-si
http://urbanisation-si.over-blog.com/
http://rhonamaxwel.over-blog.com/
http://urbanisation-des-si.blogspot.fr/
Tutoriel Red Hat JBoss jBPM (version community) (1) : description de l’étude de cas
Les nouvelles tendances d'ingénierie logicielle proposent d'impliquer de plus en plus les acteurs fonctionnels dans la conception des applicatifs.
La norme BPMN 2 (Business Process Modeling Notation) a été spécialement conçue pour la MOA afin qu'elle puisse participer à la modélisation de ses processus métier.
Le BPM (Business Process Management) a pour but d'automatiser l'exécution de ces processus.
La dernière version de jBPM ( http://www.jbpm.org/ ), la version community (open source) de la suite Red Hat JBoss BPM, propose les outils de modélisation BPMN, le moteur d'exécution, des modules de reporting (BAM Business Activity Monitoring), d'administration pour le cycle de vie des processus, de générateurs de formulaires, fonctions de validation et simulation, des plugins Eclipse pour les développeurs, et enfin directement intégré dans le package, Drools le standard des moteurs de règles.
Ce tutoriel s'adresse aux débutants en BPM et a pour but de :
- montrer un cas concret complet d'un processus métier exécutable au sens de la norme BPMN2 ( http://www.omg.org/spec/BPMN/2.0/ ).
- expliquer le fonctionnement des tâches humaines dans un processus automatisé
- décrire les étapes pour installer la version open source (community) jBPM
- créer une unité organisationnelle, un repository et un projet dans l'IDE web KIE Workbench,
- réaliser un processus exécutable avec l'outil de modélisation web BPMN 2
- déployer et exécuter le processus
- montrer les interactions avec les différents acteurs métiers impliqués dans le processus avec la récupération de leurs tâches dans leur corbeille
Aussi tout ce qui concerne le langage BPMN 2, l’architecture jBPM, la conception détaillée des formulaires, le modèle de données, le BAM, le cycle de vie des processus et des tâches, la persistance des processus, la sécurité, la validation, la simulation, l’optimisation, les performances des processus et l'intégration avec Drools feront l’objet d’autres tutoriels plus spécialisés.
Description du processus métier :
Le processus est déclenché par le service des ressources humaines dans le but de suivre et de réaliser un compte rendu des différents entretiens d'un candidat à un poste.
Un membre de la RH démarre le processus. Un écran lui demande de saisir le nom du candidat, le poste et des questions pour un test de compétences (ici réduit à 1 question).
Le jour du passage du test, le candidat se connecte avec un nom et un mot de passe fourni par la RH. Il répond aux questions du test et se déconnecte.
La RH, se connecte à l’IDE KIE, récupère et exécute la tâche qui se trouve dans sa corbeille, visualise les réponses aux tests, fait passer l'entretien au candidat, puis termine la tâche en mettant son appréciation.
Le chef de projet (CP) procède exactement de la même manière pour saisir son appréciation.
Les 2 tâches peuvent être réalisées dans n'importe quel ordre et sont indépendantes.
Une fois les 2 tâches concernant les appréciations RH et CP entièrement réalisées, un membre de la Direction Générale (DG) pourra se connecter à KIE, récupérer et exécuter la tâche qui se trouve dans sa corbeille et qui consiste àvisualiser les appréciation de la RH et CP et à saisir sa décision finale.
Ce processus métier, volontairement simpliste coté BPMN, permet de montrer la prise en compte de tâches humaines dans un processus exécutable.
"Toute la vie est une affaire de choix. Cela commence par : "la tétine ou le téton ?" Et cela s'achève par : "Le chêne ou le sapin ?""
Pierre Desproges
Voir aussi :
http://urbanisation-si.wix.com/blog
http://urbanisme-si.wix.com/blog
http://urbanisation-si.wix.com/urbanisation-si
http://urbanisation-si.over-blog.com/
http://rhonamaxwel.over-blog.com/
http://urbanisation-des-si.blogspot.fr/
Tutoriel jBPM : mais que devient l'open source jBPM, fait il aussi bien que son grand frère Drools ?
Les nouveaux développements d'applications proposent que la conception puisse se faire par les utilisateurs finaux et des développeurs qui ne seraient pas des gourous des dernières tendances technologiques.
Ce tutoriel a pour but de montrer un cas concret simple d'un processus métier exécutable au sens de la norme BPMN2 ( http://www.omg.org/spec/BPMN/2.0/ ).
Pour bien comprendre les différents concepts comme l'exécution des "Human Task", j'utiliserais la suite open source jBPM ( http://www.jbpm.org/ ).
Au cours de mes différentes missions en conseil en urbanisation, j'ai eu l'occasion de mettre en oeuvre le moteur de règles métiers open source Drools ( http://www.drools.org/ ) permettant de concevoir, d'exécuter et de gérer de manière efficiente des règles métiers en dehors du code et des applications.
Cette brique éprouvée est devenue le standard des moteurs de règles open source.
Derrière cette suite logicielle se trouve jBoss (le serveur d'application JEE le plus utilisé en production) et Red Hat, l'éditeur de la distribution Linux la plus répandue en entreprise, à qui appartient jBoss.
Drools et jBPM appartiennent donc à la famille JBoss/Red Hat, mais jBPM fait il aussi que son frère Drools ?
Red Hat commercialise les 2 offres sous les appellations : Red Hat® JBoss® BRMS (Business Rules Management System) ( https://www.redhat.com/fr/technologies/jboss-middleware/business-rules ) et Red Hat® JBoss® BPM Suite ( http://www.redhat.com/en/technologies/jboss-middleware/bpm )
Pour Red Hat la société commerciale, il est clair que Drools et jBPM servent de laboratoire d'expérimentation. Les solutions opensource n'étant bien évidemment pas garanties contre le bogues, Red Hat s'engage par contre dans les solutions payantes a corrigé tous les défauts et à apporter son aide et son expertise aux futurs clients.
Si le moteur Drools est fiable, robuste et n'a plus de preuve à faire, qu'en est-il de jBPM ?
L'histoire de jBPM est un peu mouvementée.
Pour relancer la machine, on envoit les experts de l'équipe Drools à la rescousse. La version 5 reprend tout de A à Z avec l'objectif de supporter la nouvelle norme BPMN 2 exécutable et son XML associé..
JBoss tente de se différencier en promouvant l’intérêt de l’intégration de sa solution avec son moteur de règles (Drools), arguant qu’une solution BPM sans cette fonctionnalité n’est pas concevable.
Si jBPM est remis sur les rails, il lui reste beaucoup de chemin à parcourir car pendant ce temps les solutions open source concurrente ont beaucoup progressées. Si le moteur fonctionne, ce n'est pas le cas des outils pour Eclipse et encore moins pour ceux dédiés aux concepteurs de processus métiers. Dans la documentation, il est fait mention que pour le BAM (Business Activity Monitoring), les développeurs ont toutes les briques pour développés eux-mêmes leurs dashboard. L'exemple fourni est une caricature de ce qu'on exige d'une vraie solution de BAM.
Avec la nouvelle version 6, la norme BPMN 2 pour les processus exécutable est maintenant bien supportée.
La stratégie de Red Hat est de concurrencer les solutions commerciales et de pénétrer le marché des grandes organisations.
- Clustering et haute disponibilité
- Nouveau BAM entièrement revu à partir de la solution Polymita rachetée par Red Hat
- Utilisation du framework UberFire permettant de développer rapidement des écrans de reporting
- des outils de simulation
- le support du cloud
- des connecteurs BPM
- le support de la totalité de la norme BPMN2
- des outil web de modélisation des données
- des générateur de formulaires
- le « No code tooling », la possibilité aux experts métiers de créer, déployer, exécuter et surveiller leurs processus sans avoir à écrire du code.
- les "processus dynamique", c'est à dire la possibilité de changer dynamiquement une instance de processus en cours d’exécution comme ajouter une tâche à la volée.
- les support des applications mobiles
- les outil de migration d’un processus en cours d’exécution vers un nouveau, incluant un outil graphique gérant les différences
- l'analyse de processus pour détecter les problèmes et les optimiser
- le "Goal driven BPM" qui a pour ambition, au lieu de modéliser les processus comme une séquence d’étapes, de se focaliser plus sur les buts et les pré-conditions qui serviront à générer le processus résultant peut être à partir des concepts métiers et de la modélisation orientée but (GORE Goal Oriented Requirements Engineering).
"Deux choses sont infinies : l'Univers et la bêtise humaine. Mais en ce qui concerne l'Univers, je n'en ai pas encore acquis la certitude absolue."
Albert Einstein
Voir aussi :
http://urbanisation-si.wix.com/blog
http://urbanisme-si.wix.com/blog
http://urbanisation-si.wix.com/urbanisation-si
http://urbanisation-si.over-blog.com/
http://rhonamaxwel.over-blog.com/
http://urbanisation-des-si.blogspot.fr/