Formation Usine Retraite

1. Formation Usine Retraite Radja

2. Sommaire Présentation 1 Jive 2 Jivol 3 Bibliographie et glossaire 4 Questions / Réponses 5 6

3. Sommaire Architecture 1 1.1 Intégration de Jive et Jivol dans l’UR 1.2 Composants sollicités lors d’un appel de service métier 1.3 Jive 2 Jivol 3 Bibliographie et glossaire BST/BREF 4 Questions / Réponses 5

4. 1 – Architecture 1.1 – Intégration de Jive et Jivol dans l’UR • Jive et Jivol utilisent une architecture de services découpée en plusieurs couches, chacune ayant un rôle spécifique

5. Le framework • Techniquement, RADJA est : • un framework d’applications Java client riche • un framework SWING • un framework MVC • un framework intégrant des services COBOL grâce à JIVE • un framework de trace basé sur log4j • etc. • Fonctionnellement, RADJA est : • un framework suivant la charte graphique de l’Usine Retraite • un framework gérant les habilitations métier dans les écrans • un framework intégrant des services métier existants • etc.

6. Sommaire • Urbanisation : RADJA, BST, JIVE… • Architecture d’une application RADJA • Typologie et modalité des fonctions et des écrans • Architecture MVC des écrans RADJA • Méthodologie du développement

7. Urbanisation – Radja, BST, Jive 1.1 – BST • BST est le Bureau Services Transverses • C’est avant tout le lanceur des applications : • Applications / fonctions RADJA de l’Usine Retraite • Applications externes : bloc-notes, calculette, etc. • Il assure aussi des services transverses aux applications : • Corbeilles et contextes • Habilitations • Remarque : BST est réalisé avec RADJA.

8. Urbanisation – Radja, BST, Jive 1.1 – L’Interface d’Accueil (IA)

9. Urbanisation – Radja, BST, Jive 1.1 – Jive • JIVE est un framework pour intégrer des services externes dans une application Java. • RADJA utilise JIVE pour accéder depuis les applications de l’Usine Retraite : • aux référentiels métier (dictionnaires, messages) • aux préférences (groupe/utilisateur) • aux services métier existants (écrits en COBOL)

10. Applicationexterne Bureau(BST) Référentielmétier Applicationmétier Servicemétier Applicationmétier Servicemétier Référentielmétier ? RADJA RADJA RADJA JIVE JIVE COBOL COBOL Urbanisation – Radja, BST, Jive JAVA MAINFRAME

11. Ecrans, fonctions, applications Radja • Un écran Radja est un module autonome, avec son visuel mais aussi son comportement métier propre • Les règles métier sont situés dans les services métier Cobol • Une fonction Radja est un processus métier orchestrant un ou plusieurs écrans • Découpage fonctionnellement cohérent et unitaire d’une application • Enchaînement d’écrans et d’appels de services permettant des consultations ou des mises à jour et laissant le système dans un état cohérent. • Une application Radja est un ensemble de fonctions possédant une configuration commune (dictionnaires, aide, messages d’erreurs, habilitations…)

12. Exemple d’enchaînements Bureau (BST) Application2 Application1 Fonction1 (P) Fonction3 (P) Ecran1 Ecran3 Ecran2 Ecran6 Ecran4 Ecran7 Fonction4 (I) Fonction2 (P) Ecran1 Ecran2 Ecran8 Ecran5

13. Typologie des fenêtres • Les fenêtres des écrans RADJA sont uniformisées : • Respect de la charte ergonomique UR • Pas besoin de « développer les fenêtres » dans une application RADJA • Plusieurs éléments sont cependant personnalisables : • Titre • Bandeau contextuel • Boutons standards (cycle de vie) • Saisie de masse • Barre d’outils • Menu • etc.

14. Exemple

15. Sommaire • Urbanisation : RADJA, BST, JIVE… • Architecture d’une application RADJA • Typologie et modalité des fonctions et des écrans • Architecture MVC des écrans RADJA • Méthodologie du développement

16. Le modèle MVC • Un écran métier RADJA comprend plusieurs éléments : • le Modèle : données représentées par l’écran • la Vue : visuel de l’écran • le Contrôleur de Vue : logique métier de l’écran • Séparer ces éléments permet de plus facilement les maintenir et les réutiliser : c’est le principe des architectures MVC Vue appel méthode événement Contrôleur Modèle

17. Usine Retraite Framework RADJA - Modèle - Décembre 2006

18. Rôle • Le Modèle est passé par la fonction à ses écrans • La fonction instancie et peuple le Modèle • Chaque écran utilise un sous-ensemble des données, peut les modifier ou en ajouter de nouvelles • Pour un écran, le Modèle contient les données : • représentées par la Vue • manipulées par le Contrôleur • RADJA assure automatiquement : • la synchronisation permanente des données entre composants, • le retour aux anciennes valeurs du Modèle en cas d’annulation • Le Modèle est donc la zone d’échange entre : • Le Contrôleur de la fonction • Les Contrôleurs des Vues • Les composants graphiques des Vues • A la fin du dernier écran, la fonction récupère les données du Modèle

19. Sommaire • Introduction • Lire / écrire dans le Modèle depuis un Contrôleur • Référentiels métier • Lier un composant graphique au Modèle • Concevoir le Modèle d’un écran • Clonage et contraintes techniques

20. Adressage d’une propriété • Les données du Modèle sont hiérarchisées et accédées en utilisant une adresse (comme un système de fichiers) • L’adresse d’un objet situé à la racine du Modèle est préfixée par un « # » • Exemple : #personne • Une propriété d’un objet est accédée en utilisant le séparateur « / » • Exemple : #personne/adresse • L’objet doit posséder des accesseurs standards pour pouvoir accéder à ses propriétés • Exemple : getAdresse et setAdresse pour la propriété adresse • On peut utiliser plusieurs fois le séparateur pour accéder aux propriétés de propriétés • Exemple : #personne/adresse/codePostal • Les méthodes getValue et setValue sont utilisées pour lire et écrire le Modèle

21. Adressage d’une propriété • Exemples : • getValue ("#personne/entreprise/salaries");  personne.getEntreprise ().getSalaries (); • setValue ("#personne/nom", "DURAND");  personne.setNom ("DURAND"); • setValue ("#personne/entreprise/nom", "XYZ");  personne.getEntreprise ().setNom ("XYZ");

22. Référentiels métier • Depuis une application RADJA, on peut faire référence à des référentiels métier particuliers : • Dictionnaires (code / libellé court / libellé long) • Messages d’erreur (code / message / criticité) • Il existe des dictionnaires et un référentiel de messages communs à toutes les applications • Chaque application peut en outre définir ses propres dictionnaires et messages • Quand un code adressé depuis un composant ou un contrôleur n’existe pas dans le référentiel de l’application, il est recherché dans le référentiel commun

23. Accès aux référentiels métier • On accède aux référentiels métier comme s’ils faisaient partie du Modèle, avec deux racines spéciales : • #dic pour les dictionnaires de l’application • #msg pour le référentiel de messages de l’application • Pour chaque item du dictionnaire, on peut sélectionner : • /code : le code • /shortLabel : le libellé court • /fullLabel : le libellé long • Les référentiels métier sont en lecture seule • Exemple: Lecture des libellés longs d’un dictionnaire • getValue ("#dic/civilite/fullLabel");

24. Composants graphiques

25. Sommaire • Généralités • Fonctionnalités communes • Composants à valeur statique • Champs • Composants activables • Composants sélectionnables • Conteneurs • Autres composants…

26. Généralités • Composants de base issus de SWING, avec valeur ajoutée : • Techniquement plus simples à utiliser : formateurs, aide et menu contextuels, synchronisation automatique avec les données, etc. • Intégrés au métier : habilitations, charte ergonomique, etc. • Composants moins standards : • Déversoirs (listes, arbres, tableaux), écran de recherche, etc. • Un composant graphique s’utilise au sein d’une Vue • Création • Configuration • Ajout à la Vue • Certains composants graphique peuvent être liés au Modèle en leur associant l’adresse de l’objet représenté • Exemple : champTexte.setValuePath ("#personne/nom"); • Exemple : liste.setReferencePath ("#dic/civilite");

27. Fonctionnalités communes • setFrameworkName ("monComposant") • Nom métier du composant • Permettra d’adresser le composant depuis le Contrôleur • setGroups (unEnsembleDeGroupes) • Associe le composant à des groupes • Permettra d’agir sur plusieurs composants simultanément depuis le Contrôleur • setFrameworkEnabled (boolean) • setFrameworkVisible (boolean) • setPreferredSize (new Dimension (50, 50)) • addActionOnEvent (EVENT_TYPE, "EventName") • EVENT_FOCUS_GAINED : prise du focus • EVENT_FOCUS_LOST : perte du focus • EVENT_VALUE_CHANGED : changement de valeur dans le composant • EVENT_ACTION_PERFORMED : activation (clic, boutons Espace, Entrée…)

28. RjLabel / libellé • Un libellé statique : • Méthodes : • setText("Telephone :") • setItalic(true)

29. champ texte label RjTextField / texte simple • Un champ texte simple : • Méthodes : • setValuePath("#nom") • setReferencePath("#listeNoms") • setTabIndex(3) • setMandatory(true) • setHelpText("Entrez un nom") • setMinLength(0) • setMaxLength(20) • setBold(true) • setEditPattern("#.##.##.#A.###.###")L’argument suit la syntaxe de MaskFormater en Java : • # caractère numérique, • A caractère alpha-numérique, • etc. • setValidationPattern("0\\d|1[12]")L’argument est une expression régulière.

30. RjButton / bouton • Un bouton : • Méthodes : • addActionOnEvent(EVENT_ACTION_PERFORMED, "MettreAJour") c’est l’action métier associée au bouton qui définit son libellé, son icône, sa description, etc.

31. RjComboBox / boîte de sélection • Une boîte de sélection : • Méthodes : • setDisplayFormat("Item {.}") setDisplayFormat("Echéance au {fin,date,yyyy-MM-dd}") setDisplayFormat("{code} ## {fullLabel}")

32. RjFilterList / liste filtrable • Une liste avec filtre :

33. RjOverflowLists / déversoir à listes • Un déversoir de liste à liste : • Méthodes : • setOverflowMode(MODE_COPY_ELEMENTS) : le mode de fonctionnement du déversoir, en copie ou en déplacement

34. RjTextFieldDate / date • Une date (avec ou sans sélecteur) : • Méthodes : • setDatePickerVisible(true) • Entrée-sortie : • Objet Calendar • Objet Date • Chaîne (String) formatée AAAAMMJJ

35. RjTable / tableau • Un tableau : • Méthodes : addColumn(new RjColumn("id", "Index", false, Integer.class);addColumn(new RjColumn("marie", "Marié", true, Boolean.class);addColumn(new RjColumn("nom", "Nom", false, String.class);

36. Sommaire • Généralités • Fonctionnalités communes • Composants à valeur statique • Champs • Composants activables • Composants sélectionnables • Conteneurs • Autres composants…

37. RjPanel / panel • Un panel classique. • Méthodes : • setLayout(new GridLayout()) : disposition des composants • add(unComposant) : ajout d’un composant • add(unComposant, uneContrainte) : ajout d’un composant avec un paramètre • Exemples : • setLayout(new BorderLayout());add(unComposant, BorderLayout.CENTER);add(unComposant, BorderLayout.SOUTH); • setLayout(new GridLayout(3,2));

38. RjPanelLogicalGroup / cadre avec titre • Un panel encadré avec un titre : • Méthodes : • setTitle("Champs texte") : initialisation du titre

39. RjSplitPane / panel divisé • Un panel divisé par une barre déplaçable : • Méthodes : • setLeftComponent(unComposant) : initialisation du composant gauche • setRightComponent(unComposant) : initialisation du composant droit • setDividerLocation(120) : réglage de la position du séparateur (en pixels depuis le bord gauche)

40. Usine Retraite Framework RADJA - Vues et composition visuelle - Décembre 2006

41. La Vue • La Vue est la partie visuelle d’un écran métier. C’est : • une organisation cohérente de composants graphiques • choix des composants, disposition, etc. • la configuration de ces composants : • données représentées, déclenchement d’actions métier, etc. • Une fois développée, on peut réutiliser une Vue comme un composant, au sein d’une autre Vue : on parle alors de vue incluse. vue

42. Sommaire • Créer une vue • Décrire les actions d’une vue • Utiliser le plugin de composition visuelle

43. Notion de Vue • La Vue est la partie visuelle d’un écran métier. C’est l’assemblage et la configuration de composants graphiques RADJA. • Une fois développée, on peut réutiliser une Vue dans n’importe quelle application RADJA. • On peut aussi réutiliser une Vue comme un composant standard au sein d’une autre Vue : on parle alors de vue incluse. Vue racine Vue incluse Vue incluse Vue incluse

44. Exemple

45. Créer et composer une vue • Une vue RADJA se développe sous la forme d’une classe,qui hérite de RjAbstractViewImpl : • Les composants sont créés et configurés dans le constructeur de la vue. Si on le fait manuellement, cela donne par exemple : • import ur.radja.display.impl.component.generic.RjAbstractViewImpl; • public class NouvelleVue extends RjAbstractViewImpl { • } • public NouvelleVue(){ • RjLabel unComposant = new RjLabel(); unComposant.setText("helloworld"); add(unComposant); • }

46. Exemple de vue import ur.radja.display.impl.component.generic.RjAbstractViewImpl; public class NouvelleVue extends RjAbstractViewImpl { public NouvelleVue(){ // Création et configuration d’un label RjLabel leLabel = new RjLabel(); leLabel.setText("Nom :"); // Création et configuration d’un champ texte RjTextField leChamp = new RjTextField(); leChamp.setValuePath("#personne/nom"); // Ajout des composants dans la vue et configuration setLayout(new GridLayout()); add(leLabel); add(leChamp); setPermissionName("habilitationXYZ"); } }

47. Sommaire • Créer une vue • Décrire les actions d’une vue • Utiliser le plugin de composition visuelle

48. Usine Retraite Framework RADJA - Contrôleurs de vues - Décembre 2006

49. Vue Modèle Contrôleur Le Contrôleur de Vue • Le Contrôleur de Vue est le comportement métier de l’écran : • Initialisation • Actions métier en réaction à des événements (modification d’une valeur dans un champ de la Vue, boutons, etc.) • Validation métier • Une fois développé, un Contrôleur peuts’utiliser avec une autre Vue. • On peut aussi prévoir plusieurs Contrôleurspour une même Vue (qu’on utilisera selonle contexte).

50. Sommaire • Généralités • Méthodes définissables / redéfinissables • Méthodes à disposition