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);
             });
    }