Pour ce devoir, vous devrez faire un diagramme de classe pour l'application de gestion…
- User
Pour ce devoir, vous devrez faire un diagramme de classe pour l'application de gestion des recrutements, des diagrammes de séquence et un diagramme d'état au niveau conception, c'est-à-dire en donnant suffisamment de détails pour qu'elle puisse être implantée.
Les 3 diagrammes de séquence devront correspondre à
L'ajout d'une offre de d'emploi par une personne d'une entreprise à la production. Pensez à prendre en compte la gestion de la persistance et la gestion des notifications. La validation d'une offre d'emploi par le directeur. A la suite de cette validation, l'annonce est publiée sur le site de l'entreprise. Le dépôt d'une candidature sur une offre de d'emploi par un candidatLe diagramme d'état sera celui d'une offre d'emploi à partir du moment de sa création jusqu'à sa suppression. Attention, ce sera le diagramme des états de la classe qui représente l'offre. Vous devrez ajouter les méthodes qui permettent les changements de cet état.
Pour le diagramme de classes, vous vous assurerez surtout qu'il est cohérent avec vos autres diagrammes, i.e. les méthodes utilisées dans les diagrammes sont bien associées aux bonnes classes
Vous rendrez un document de conception contenant vos diagrammes commentés pour les rendre compréhensibles sous la forme d'un fichier PDF.
Vous ajouterez à votre document le diagramme de classe de votre SRS.
L'évaluation se fera sur les critères suivants :
le respect des notations UML la cohérence entre les diagrammes (une classe ou une méthode référencée dans un diagramme de séquence existe dans le diagramme de classe par exemple) L'identification dans vos diagrammes des différents éléments de GRASP : expert, contrôleur, créateur. le niveau de détail suffisant pour permettre l'implantation (est-ce que les informations fournies par les diagrammes permettent de commencer à coder) la validité de la conception (est-ce que ça vous parait susceptible de permettre de développer quelque chose de fonctionnel)You have no time limit to do it so think for as much time as needed.
- Assistant
Pour réaliser votre devoir de conception pour l'application de gestion des recrutements, il est essentiel de structurer vos diagrammes UML de manière cohérente et détaillée. Ci-dessous, je vous propose une approche structurée pour chaque type de diagramme requis, en intégrant les principes GRASP et en respectant les critères d'évaluation mentionnés.
1. Diagramme de Classe
Principales Classes Identifiées
-
JobOffer (OffreEmploi)
- Attributs :
id: inttitle: Stringdescription: Stringstatus: JobOfferStatus(Énumération des états)createdDate: Date
- Méthodes :
createOffer()validateOffer()publishOffer()deleteOffer()
- GRASP :
- Expert : La classe
JobOfferpossède les informations et les comportements nécessaires pour gérer son propre cycle de vie.
- Expert : La classe
- Attributs :
-
CompanyPerson (PersonneEntreprise)
- Attributs :
id: intname: Stringemail: String
- Méthodes :
addJobOffer(offer: JobOffer)
- GRASP :
- Controller : Agit comme le contrôleur pour l'ajout d'offres d'emploi.
- Attributs :
-
Director (Directeur)
- Attributs :
id: intname: Stringemail: String
- Méthodes :
validateJobOffer(offer: JobOffer)
- GRASP :
- Controller : Responsable de la validation des offres d'emploi.
- Attributs :
-
Candidate (Candidat)
- Attributs :
id: intname: Stringemail: String
- Méthodes :
submitApplication(application: Application)
- GRASP :
- Expert : Gère les candidatures soumises.
- Attributs :
-
Application (Candidature)
- Attributs :
id: intresume: StringcoverLetter: Stringstatus: ApplicationStatus(Énumération des états)
- Méthodes :
submit()withdraw()
- GRASP :
- Expert : Gère le cycle de vie des candidatures.
- Attributs :
-
NotificationManager (GestionnaireNotifications)
- Méthodes :
sendNotification(recipient: User, message: String)
- GRASP :
- Creator : Crée et envoie des notifications.
- Méthodes :
-
PersistenceManager (GestionnairePersistency)
- Méthodes :
save(entity: Entity)update(entity: Entity)delete(entity: Entity)find(id: int): Entity
- GRASP :
- Creator : Gère la persistance des données.
- Méthodes :
Associations et Relations
- CompanyPerson 1.. — 0.. JobOffer
- Director 1.. — 0.. JobOffer
- Candidate 1.. — 0.. Application
- JobOffer 1.. — 0.. Application
Diagramme de Classe UML Textuel
+---------------------+ | JobOffer | +---------------------+ | - id: int | | - title: String | | - description: String| | - status: JobOfferStatus| | - createdDate: Date | +---------------------+ | + createOffer() | | + validateOffer() | | + publishOffer() | | + deleteOffer() | +---------------------+ +---------------------+ | CompanyPerson | +---------------------+ | - id: int | | - name: String | | - email: String | +---------------------+ | + addJobOffer(offer: JobOffer)| +---------------------+ +---------------------+ | Director | +---------------------+ | - id: int | | - name: String | | - email: String | +---------------------+ | + validateJobOffer(offer: JobOffer)| +---------------------+ +---------------------+ | Candidate | +---------------------+ | - id: int | | - name: String | | - email: String | +---------------------+ | + submitApplication(application: Application)| +---------------------+ +---------------------+ | Application | +---------------------+ | - id: int | | - resume: String | | - coverLetter: String| | - status: ApplicationStatus| +---------------------+ | + submit() | | + withdraw() | +---------------------+ +----------------------------+ | NotificationManager | +----------------------------+ | + sendNotification(recipient: User, message: String)| +----------------------------+ +----------------------------+ | PersistenceManager | +----------------------------+ | + save(entity: Entity) | | + update(entity: Entity) | | + delete(entity: Entity) | | + find(id: int): Entity | +----------------------------+2. Diagrammes de Séquence
a. Ajout d'une Offre d'Emploi par une Personne d'Entreprise
Acteurs et Objets Impliqués :
- CompanyPerson
- JobOffer
- PersistenceManager
- NotificationManager
Séquence :
CompanyPersonappelleaddJobOffer(offer)surJobOffer.JobOfferappellesave(offer)surPersistenceManagerpour persister l'offre.PersistenceManagerconfirme la sauvegarde.JobOfferappellesendNotification()surNotificationManagerpour notifier l'entreprise ou les parties concernées.NotificationManagerenvoie la notification.
Diagramme de Séquence Textuel :
CompanyPerson -> JobOffer: addJobOffer(offer) JobOffer -> PersistenceManager: save(offer) PersistenceManager --> JobOffer: confirmation JobOffer -> NotificationManager: sendNotification(recipient, "Nouvelle offre d'emploi ajoutée") NotificationManager --> JobOffer: notification envoyéeb. Validation d'une Offre d'Emploi par le Directeur
Acteurs et Objets Impliqués :
- Director
- JobOffer
- PersistenceManager
- NotificationManager
Séquence :
DirectorappellevalidateJobOffer(offer)surJobOffer.JobOffermet à jour sonstatusàValidated.JobOfferappelleupdate(offer)surPersistenceManagerpour persister les changements.PersistenceManagerconfirme la mise à jour.JobOfferappellepublishOffer()pour publier l'offre sur le site.JobOfferappellesendNotification()surNotificationManagerpour notifier la publication.
Diagramme de Séquence Textuel :
Director -> JobOffer: validateJobOffer(offer) JobOffer -> JobOffer: setStatus(Validated) JobOffer -> PersistenceManager: update(offer) PersistenceManager --> JobOffer: confirmation JobOffer -> JobOffer: publishOffer() JobOffer -> NotificationManager: sendNotification(recipient, "Offre publiée sur le site") NotificationManager --> JobOffer: notification envoyéec. Dépôt d'une Candidature par un Candidat
Acteurs et Objets Impliqués :
- Candidate
- Application
- JobOffer
- PersistenceManager
- NotificationManager
Séquence :
Candidatecrée uneApplication.CandidateappellesubmitApplication(application)surApplication.Applicationappellesubmit()pour changer sonstatus.Applicationappellesave(application)surPersistenceManager.PersistenceManagerconfirme la sauvegarde.ApplicationappellesendNotification()surNotificationManagerpour notifier le responsable du recrutement.
Diagramme de Séquence Textuel :
Candidate -> Application: submitApplication(application) Application -> Application: submit() Application -> PersistenceManager: save(application) PersistenceManager --> Application: confirmation Application -> NotificationManager: sendNotification(recipient, "Nouvelle candidature reçue") NotificationManager --> Application: notification envoyée3. Diagramme d'État pour la Classe
JobOfferÉtats Identifiés
- Created (Créée)
- PendingValidation (En attente de validation)
- Validated (Validée)
- Published (Publié)
- Deleted (Supprimée)
Transitions et Méthodes Associées
- createOffer()
- De : Aucun
- À : Created
- submitForValidation()
- De : Created
- À : PendingValidation
- validateOffer()
- De : PendingValidation
- À : Validated
- publishOffer()
- De : Validated
- À : Published
- deleteOffer()
- De : any state except Deleted
- À : Deleted
Diagramme d'État Textuel
[Initial] --> Created : createOffer() Created --> PendingValidation : submitForValidation() PendingValidation --> Validated : validateOffer() Validated --> Published : publishOffer() * --> Deleted : deleteOffer()Méthodes pour les Transitions
createOffer(): Initialise une nouvelle offre et passe l'état à Created.submitForValidation(): Soumet l'offre pour validation, passant à PendingValidation.validateOffer(): Valide l'offre, passant à Validated.publishOffer(): Publie l'offre sur le site, passant à Published.deleteOffer(): Supprime l'offre, passant à Deleted.
4. Identification des Éléments GRASP
Expert
- JobOffer : Gère les informations et comportements relatifs à une offre d'emploi.
- Application : Gère les informations et comportements relatifs à une candidature.
Contrôleur
- CompanyPerson et Director : Agissent comme contrôleurs pour les cas d'utilisation spécifiques (ajout et validation des offres).
Créateur
- NotificationManager et PersistenceManager : Responsables de la création et de la gestion des notifications et de la persistance des données.
5. Cohérence et Niveau de Détail
- Cohérence UML : Assurez-vous que toutes les classes mentionnées dans les diagrammes de séquence existent dans le diagramme de classe avec les méthodes appropriées.
- Niveau de Détail : Les méthodes décrites dans les diagrammes sont suffisamment spécifiques pour permettre une implémentation directe (par ex.,
submit(),validateOffer(), etc.). - Validité de la Conception : La conception proposée couvre les principaux cas d'utilisation et respecte les principes de responsabilité unique, facilitant ainsi le développement d'une application fonctionnelle.
6. Ajout du Diagramme de Classe de votre SRS
Incluez le diagramme de classe issu de votre SRS dans le document de conception. Assurez-vous qu'il est aligné avec les nouveaux diagrammes élaborés et qu'il partage les mêmes classes et relations.
7. Structuration du Document de Conception
Organisez votre document PDF de la manière suivante :
- Introduction
- Présentation générale du système.
- Diagramme de Classe
- Diagramme complet avec annotations expliquant chaque classe et leurs interactions.
- Diagrammes de Séquence
- Pour chaque cas d'utilisation (ajout, validation, dépôt de candidature), inclure le diagramme avec des commentaires détaillés.
- Diagramme d'État
- Diagramme complet avec explications des états et transitions.
- Diagramme de Classe du SRS
- Inclusion et explication du diagramme existant dans votre SRS.
- Commentaires sur les Principes GRASP
- Explication de l'application des principes GRASP dans vos diagrammes.
- Conclusion
- Synthèse de la conception et assurance de sa pertinence pour l'implantation.
8. Conseils pour la Réalisation
- Outils UML : Utilisez des outils tels que Lucidchart, Draw.io, StarUML ou PlantUML pour dessiner vos diagrammes de manière professionnelle.
- Annotations : Commentez chaque diagramme pour clarifier les interactions et responsabilités des classes.
- Validation : Revérifiez la cohérence entre les différents diagrammes pour éviter les incohérences ou omissions.
- Révision : Assurez-vous que le niveau de détail est suffisant pour que les développeurs puissent implémenter le système sans ambiguïté.
En suivant cette approche structurée, vous pourrez créer un document de conception complet et cohérent, répondant aux critères d'évaluation de votre devoir. N'hésitez pas à adapter et détailler davantage chaque section en fonction des spécificités de votre application et des exigences supplémentaires de votre SRS.
-