Conception et duplication des données

Bonjour,

Je suis actuellement entrain de faire un site de gestion de rencontres sportives en Angular + Spring.

Mon problème est plus sur la bonne pratique. En effet, j'ai une classe Rencontres avec énormément d'attribut que j'utilise dans plusieurs modules de mon application mais chaque module n'utilise qu'une partie des attributs.

Est ce qu'il vaut mieux faire une requête vers le serveur qui récupère tous les rencontres avec tous les attributs où faire des classes rencontres_Module1, Rencontres_Module2 ... pour faire des choses plus spécifique à chaque module et du coup multiplié aussi les point d'entrée et de terminaison REST ?

Merci pour votre aide.

montrez nous des exemples d'attribut et leurs utilisations.

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38

export interface Game { id: number; type: 'championnat' | 'coupe' | 'amical'; state: 'joué' | 'non joué'; penalty: boolean, forfeit:boolean, glue:boolean, fdme?: URL; code: string; competition: string; numGroup: string; nameGroup: string; day: number; datetime?: Date; nameClubRec: string; numClubRec:number; scoreclubRec?:number, nameClubVis: string; numClubVis:number; scoreClubVis?:number, referee1?: string; realReferee1?: string; referee2?: string; realReferee2?: string; secretary?:string | number; timekeeper?:string | number; halleManager?:string | number; nameHalle?: string; addressHalle?: string; cpHalle?: string; cityHalle?: string; barmen: [ id: number, ], players: [ id:number, ] }

---

Par exemple, pour le module bar, je vais utiliser les barmen, id, datetime; pour le module player, je vais utiliser id, type, glue, competition ...; et ainsi de suite pour d'autre module encore.

soit je ferais plusieurs points d'entrées
soit un point d'entrée avec un filtre ou j'indiquerai un type de donnée voulu (je pencherai sur celle çi)

il faut blinder des 2 cotés (front, back) avec du typage fort pour éviter des erreurs !

Merci pour la forme, mais la question portait plus sur le fond. Du côté angular, j'ai qu'un seul service qui refraichit les données si elles ont plus de 5min. Du coup, avec une seul classe Game en front, j'ai moins de requêtes que si pour chaque module j'utilise plusieurs service et classe Game-module1, game-module2 ect.
Quelle est la meilleure pratique ?

l'utilisation d'une api correspond à une fonctionnalité (côté client et côté serveur) donc le choix des classes que vous allez utiliser dans votre code ne se détermine pas par le nombre de points d'entrée rest et l'inverse non plus.

vous pouvez très bien avoir plein de classes dans le code côté serveur et un seul point d'entrée rest qui répond par exemple à la requete "donne moi les informations qui ont changé depuis 08 h 37".
donc il y aura 1 seul appel qui va répondre un tableau ou une liste de données qui correspondent à une ou plusieurs classes suivant ce qui est utile d'envoyer.

Désolé, mais je m'exprime mal ou je ne comprend pas vos réponses.

Dans l'exemple, c'est moi qui va faire le back end aussi. Bon du coup, comme j'apprend Angular, j'ai fais un mock alors que j'aurai, après réflexion, peut être du commencer par les points de terminaison REST.

Je suis plus dans une réflexion d'architecture.

Actuellement, j'utilise le pattern Subject as a service, avec un BehaviorSubject dans mon service pour gérer l'état. Du coup, pour récupérer par exemple un object avec un id particulier, je le fait coté front end, pareil pour les filtres, je le fais dans le service front end. Cela engendre beaucoup moins de requête http.

Est ce que déjà jusqu'ici je suis dans le bon ?

ensuite, ma question était :

Ma classe "game" est utilisée dans plusieurs module, dans chaque module, j'utilise toutes les données mais pas tous les attributs. Est ce qu'il faut mieux gérer un service avec le pattern Subject as a service par module et multiplié les points de terminaisons ou gérer le service des "Game" à la racine ?

Je pense on est un peu sur une question de l'utilité de NgRx, mais on m'a dit c'était vraiment compliqué pour une première approche avec angular et surtout pour des petits projets.

pour te répondre je vais prendre un exemple avec un service de location de chambre d'hotel
une chambre peut etre defini avec le modèle suivant :
- id
- numero de chambre
- nb piece
- date
...

le back doit fournir un CRUD, donc les 4 points d'entrées suivants :
- GET /chambre (ajouter des filtres, c'est facultatif mais c'est une bonne pratique)
- POST /chambre
- PUT /chambre
- DELETE /chambre

* imagine que tu as 300 chambres
sur ton projet angular tu veux récupérer toutes les chambres donc tu fais : GET /chambre
il te retourne les 300 chambres d'un coup, le problème est que ça va être un peu long niveau réseau de plus afficher 300 chambres sur la vue comme ça, ce n'est pas ergonomique

en général, on met un système de pagination sur le front
- GET /chambre --> avec un filtre de pagination (je veux 10 chambres à partir de la 3eme page) donc de 30 à 40

* autre point :
le client s'intéresse uniquement aux chambre avec 2 pièces
c'est une mauvaise pratique que ton frontend récupére les 300 chambres (temps réseau) et filtrer après.

donc ton front end, doit faire :
- GET /chambre --> avec un filtre sur le nombre de piece = 2

voilà l'utilité des filtres !

** mais si vraiment il y a peu d'enregistrements en base de données, alors tu peux te permettre de tout récupérer et gérer par le front-end

Citation:

---

Ma classe "game" est utilisée dans plusieurs module, dans chaque module, j'utilise toutes les données mais pas tous les attributs. Est ce qu'il faut mieux gérer un service avec le pattern Subject as a service par module et multiplié les points de terminaisons ou gérer le service des "Game" à la racine ?

---

je n'ai pas trop compris.

disons que dans le module1 tu utilises :

Code:

---

1 2 3 4 5 6

export interface Game { id: number; type: 'championnat' | 'coupe' | 'amical'; state: 'joué' | 'non joué'; penalty: boolean, forfeit:boolean,

---

et dans le module2, tu utilises :

Code:

---

1 2 3 4 5 6 7 8 9 10 11

export interface Game { id: number; code: string; competition: string; numGroup: string; nameGroup: string; day: number; datetime?: Date; nameClubRec: string; numClubRec:number;

---

c'est bien ça la question ?


disons que ton service fournis un observable : game$ = new BehaviorSubject...
tu l'initialises avec tous les games provenant de l'api

les composants dans les modules : module1, module2, module3, s'abonnent à : game$

- un ou des composants du module1 s'abonne à game$ et effectue un filtrage avec map....
- un ou des composants du module2 s'abonne à game$ et effectue un filtrage avec map....
- etc...

mais au lieu d'effectuer le filtrage dans le .ts du composant, fait le dans le service :

game-service.ts

Code:

---

1 2 3 4 5 6 7 8 9

game$ = new BehaviorSubject...   getGameType1() { return $game.pipe(map(.............)); }   getGameType2() { return $game.pipe(map(.............)); }

---

et tous les composants du module 1 feront : game$ = game-service.getGameType1();
etc...


la bonne pratique est de toujours factoriser et écrire du code dans les services


exemple architecture :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22

/core   /shared (en commun avec plusieurs features) --- /services -------- /game-service.ts ---/models ...   /feature1 --> (utilise /shared/services/game-service.ts) ---/services ---/components ---/models ... /feature2 --> (utilise /shared/services/game-service.ts) ---/services ---/components ---/models ... /feature3 --> (utilise /shared/services/game-service.ts) ---/services ---/components ---/models

---

Merci pour la deuxième partie, c'était bien ma question, et cela correspond à ce que j'ai déjà fait.

Pour la première partie, dans le cas d'un service de location de chambre d'hotel, quel intérêt serai alors d'utiliser le pattern Subject as a service pour gérer les chambres ?