Plusieurs files d’attente (une par region) #

Les régions et les noms de région traduits #

Dans le paquet pong.commun.enums, ajouter Region

public enum Region {

        AFRIQUE, ASIE, AMERIQUE, EUROPE;

    }

Pour traduire les régions, ajouter les variables suivantes à fr.properties

AMERIQUE=Amérique
    AFRIQUE=Afrique
    ASIE=Asie
    EUROPE=Europe

Ajouter les variables suivantes à en.properties

AMERIQUE=Americas
    AFRIQUE=Africa
    ASIE=Asia
    EUROPE=Europe

Ajouter une tâche du Dorsal pour initialiser les régions #

Le ModeleFileAttente mémorise maintenant la région et l’utilise pour les id de rendez-vous

public class ModeleFileAttente implements Model, WatchJson, WriteObjectGraph {

        // ...


        // ajouter
        private Region region = null;

        // ...


        // ajouter
        public void initialiserRegion(Region region) {
            this.region = region;
        }

        // ...


        // modifier cette méthode
        private String genererIdRendezVous() {
            String idRendezVous = String.valueOf(prochainIdRendezVous);
            prochainIdRendezVous++;

            // ajouter
            if(region != null) {
                idRendezVous = region.name() + "¤" + idRendezVous;
            }

            return idRendezVous;
        }

Dans pong.commun.messages, ajouter MsgInitialiserFileAttente

public class MsgInitialiserFileAttente extends Message<MsgInitialiserFileAttente> {

        private Region region;

        public MsgInitialiserFileAttente setRegion(Region region) {
            this.region = region;

            return this;
        }

        public MsgInitialiserFileAttente() {
        }

        public void appliquerA(ModeleFileAttente fileAttente) {
            fileAttente.initialiserRegion(region);
        }
    }

Déclarer le message dans Declarations

public class Declarations {

    	public static void declarerMessages(MessageRegistrar registrar) {

    		// ...

    		// ajouter
    		registrar.registerMessage(MsgInitialiserFileAttente.class);
    	}

    	// ...

Dans pong.dorsal.taches.ModifierFileAttente, ajouter

public class ModifierFileAttente {

        public static void creerTaches(BackendTasks tasks) {

            tasks.taskGroup("ModifierFileAttente")

                 .waitsFor(model(ModeleFileAttente.class))

                 .contains(subTasks -> {

                     // ajouter
                     initialiser(subTasks);

                     // ...

                 });
        }

        // ...

        // ajouter
        private static void initialiser(BackendTasks subTasks) {
            subTasks.task("initialiser")

                 .waitsFor(model(ModeleFileAttente.class))

                 .waitsFor(message(MsgInitialiserFileAttente.class))

                 .executes(inputs -> {

                     MsgInitialiserFileAttente msgInitialiserFileAttente = inputs.get(message(MsgInitialiserFileAttente.class));
                     ModeleFileAttente         fileAttente               = inputs.get(model(ModeleFileAttente.class));

                     msgInitialiserFileAttente.appliquerA(fileAttente);
                 });
        }

Dans pong.dorsal.taches, ajouter Initialisation

public class Initialisation {

        public static void creerTaches(BackendTasks tasks) {

            tasks.taskGroup("Initialisation")

                 .contains(subTasks -> {

                     initialiserFilesAttentes(subTasks);

                 });
        }

        private static void initialiserFilesAttentes(BackendTasks subTasks) {

            subTasks.task("initialiserFilesAttentes")

                 .executes(inputs -> {

                     for(Region region : Region.values()) {

                         Ntro.newMessage(MsgInitialiserFileAttente.class)
                             .setModelSelection(ModeleFileAttente.class, region.name())
                             .setRegion(region)
                             .send();
                     }
                 });
        }
    }

S’assurer d’appeler Initialisation.creerTaches dans le Dorsal

public class DorsalPong extends LocalBackendNtro {

        @Override
        public void createTasks(BackendTasks tasks) {

            // ajouter
            Initialisation.creerTaches(tasks);

            // ...

        }
    }

Exécuter et vérifier que la tâche s’exécute

$ sh gradlew pong

# doit afficher
[TASK] initialiserFilesAttentes
[...]
[TASK] initialiser (4)

Vérifier les fichiers .json

_storage
├── models
│   ├── ModeleFileAttente
│   │   ├── AFRIQUE.json
│   │   ├── AMERIQUE.json
│   │   ├── ASIE.json
│   │   └── EUROPE.json

Vérifier le contenu de AFRIQUE.json

{
      "_C": "ModeleFileAttente",
      "prochainIdRendezVous": 0,
      "region": "AFRIQUE",
      "rendezVousDansOrdre": []
    }

Vérifier le graphe du dorsal

Avec la Session, mémoriser et observer la région courante #

Ajouter le code suivant dans SessionPong

public class SessionPong extends Session<SessionPong> {

        // ...

        // ajouter
        private Region                regionCourante      = Region.AMERIQUE;

        // ...

        // ajouter
        public SessionPong() {
            super();
            observerRegionCourante();
        }

        // ...


        // ajouter
        public SessionPong memoriserRegionCourante(Region region) {
            this.regionCourante = region;


            return this;
        }

        // ajouter
        public SessionPong observerRegionCourante() {
            this.setModelSelection(ModeleFileAttente.class, regionCourante.name());

            return this;
        }

Ajouter un `EvtChangerRegion` #

Dans pong.frontal.evenements, ajouter

public class EvtChangerRegion extends Event {

        private Region region;

        public EvtChangerRegion setRegion(Region region) {
            this.region = region;

            return this;
        }

        public void appliquerA(SessionPong session) {

            session.memoriserRegionCourante(region)
                   .observerRegionCourante();
        }
    }

Déclarer l’événement dans le Frontal:

public class FrontalPong implements FrontendFx {

        // ...

        @Override
        public void registerEvents(EventRegistrar registrar) {
            // ...

            // ajouter
            registrar.registerEvent(EvtChangerRegion.class);
        }

Ajouter une tâche pour changer de région #

Dans AfficherFileAttente, ajouter la tâche suivante

public class AfficherFileAttente {

        public static void creerTaches(FrontendTasks tasks) {

            tasks.taskGroup("AfficherFileAttente")

                 .waitsFor("afficherVueFileAttente")

                 .contains(subTasks -> {

                     // ...

                     // ajouter
                     changerRegion(subTasks);

                 });
        }

        // ...

        // ajouter
        private static void changerRegion(FrontendTasks subTasks) {

            subTasks.task("changerRegion")

                    .waitsFor(event(EvtChangerRegion.class))

                    .executes(inputs -> {

                        SessionPong      session          = Ntro.session();
                        EvtChangerRegion evtChangerRegion = inputs.get(event(EvtChangerRegion.class));

                        evtChangerRegion.appliquerA(session);

                  });
        }

Afficher les régions dans un ComboBox #

Dans file_attente.fxml, ajouter un ComboBox pour afficher les régions

    <!-- ajouter un HBox autour du boutonSInscrire -->
        <HBox styleClass="conteneur">

            <!-- boutonSInscrire ici -->

            <!-- petit espace -->
            <Pane styleClass="petit-espace-horizontal"/>

            <!-- ajouter -->
            <ComboBox fx:id="comboRegion" >
            </ComboBox>

        </HBox>

Dans VueFileAttente, récupérer et initialiser le ComboBox

public class VueFileAttente extends ViewFx {

        // ...

        @FXML
        private ComboBox<String> comboRegion; // ajouter

        // ajouter
        private Map<Region,String> nomRegionParRegion = new HashMap<>();
        private Map<String,Region> regionParNomRegion = new HashMap<>();

        // ...

        @Override
        public void initialize() {

            // ...

            // ajouter
            Ntro.assertNotNull(comboRegion);

            // ajouter
            initialiserRegions();

            // ajouter
            initialiserComboRegion();
        }

        // ...

        // ajouter
        private void initialiserRegions() {
            for(Region region : Region.values()) {
                String nomRegion = resources().getString(region.name());
                nomRegionParRegion.put(region, nomRegion);
                regionParNomRegion.put(nomRegion, region);
            }
        }

        // ajouter
        private void initialiserComboRegion() {
            comboRegion.setFocusTraversable(false);

            for(Region region : Region.values()) {
                comboRegion.getItems().add(nomRegionParRegion.get(region));
            }

            comboRegion.setOnAction(evtFx -> actionComboRegion());

        }

        // ajouter
        private void actionComboRegion() {

            String nomRegion = comboRegion.getSelectionModel().getSelectedItem();

            Region region = regionParNomRegion.get(nomRegion);

            if(region != null) {

                Ntro.newEvent(EvtChangerRegion.class)
                    .setRegion(region)
                    .trigger();
            }
        }

En français
En anglais

S’assurer d’afficher la région courante (même au premier affichage) #

Créer les méthodes pour afficher la région courante

public class SessionPong extends Session<SessionPong> {

        // ...

        // ajouter
        public SessionPong afficherRegionCourante(VueFileAttente vueFileAttente) {

            vueFileAttente.afficherRegionCourante(regionCourante.name());

            return this;
        }

public class VueFileAttente extends ViewFx {

        // ...



        // ajouter
        public void afficherRegionCourante(String idRegion) {
            Region region = null;

            if(idRegion != null) {
                region = Region.valueOf(idRegion);
            }

            if(region == null) {

                comboRegion.getSelectionModel().clearSelection();

            }else {

                comboRegion.getSelectionModel().select(nomRegionParRegion.get(region));

            }
        }

Ajouter le code suivant dans la tâche pour afficher la file d’attente

    // modifier cette méthode
        private static void afficherFileAttente(FrontendTasks tasks) {

            tasks.task("afficherFileAttente")

                 .waitsFor(modified(ModeleFileAttente.class))

                 .waitsFor(created(VueFileAttente.class))

                 .executes(inputs -> {

                     // ajouter
                     SessionPong                 session        = Ntro.session();

                     VueFileAttente              vueFileAttente = inputs.get(created(VueFileAttente.class));
                     Modified<ModeleFileAttente> fileAttente    = inputs.get(modified(ModeleFileAttente.class));

                     fileAttente.currentValue().afficherSur(vueFileAttente);

                     // ajouter
                     session.afficherRegionCourante(vueFileAttente);
                 });
        }