Discussion :

[supras31]

Salut tous le monde je suis en train d élaborer le diagramme de classe relatif à une application permettant de :
gérer les projets informatiques d une boite de développement et ceci comporte
gestion des affectations au projet selon les grilles de compétences
gestion des missions à l étranger , si un projet nécessite une mission à l étranger
gestion des formation ; un projet informatique c'est à dire un logiciel peut nécessiter une formation
gestion des clients
, ce que j'ai parvenu à déduire est :
que un projet est composé de taches , une équipe responsable du projet constituée des employés affectes au projet selon les grilles de competences ainsi on trouve bien par exemple des projets qui nécessitent des compétences en développement java ou bien dotnet ou bien web(html+css) etc.....
mon problème est que j'arrive pas à modéliser la relation entre projet , compétence , et employé
et de même j'arrive pas à réaliser la relation que dans un projet on ne trouve qu un chef de projet
ce que je peut deduire au niveau des cardinalités
1 projet nécessite entre 1 et * competences , et 1 competence peut etre dans 0/* pojet
1 employé peut avoir entre 1 et n competences , 1 comp ==0/* employés
voici le diagramme qu j'ai realisé ci dessous

[fsmrel]

Bonsoir supras31,


Je me sens bien plus à l’aise avec le modèle relationnel de données (aka théorie relationnelle) qu’avec les diagrammes de classes, mais bon, je vais essayer de vous aider quand même, en attendant que les cracks viennent à votre aide.

Supposons donc qu’un projet requière certaines compétences et que des employés aient acquis des compétences (avec un certain niveau de compétence, notez la classe-association) :




A signaler que l’employé est doté de son matricule (id_employé est un identifiant, donc en principe caché). Pour établir une association entre les compétences requises et les compétences acquises, on pourrait par exemple procéder ainsi :





Mais il y a un problème : le libellé de la tâche dépendra non seulement de la tâche, mais aussi de l’employé et de la compétence, d’où une redondance néfaste, correspondant à un viol de troisième forme normale.


En échange, on peut s’orienter vers ceci :





On peut faire figurer la fonction exercée par un employé dans le cadre d’une tâche, et assigner un chef de projet à un projet (il n’est pas rare que quelqu’un soit chef simultanément de plus d’un projet, et tout cas, au fil du temps, on a pu diriger plusieurs projets).




Il y a évidemment d’autres représentations possibles. Par exemple, si une tâche disparaît, tout ce qui a été réalisé pour cette tâche devrait disparaître (d’où une relation de composition entre tâche et PROJET_COMPETENCE_EMPLOYE). A vous de voir.

Qu’est-ce qu’une équipe dans votre système ? La composition d’une équipe n’est-elle pas déjà virtuellement présente du fait des classes ci-dessus ? Vous me direz sans doute que non, mais pourriez-vous commenter ?

En attendant, le diagramme logique (disons SQL) correspondant à ce DC est le suivant :



A plus tard

[supras31]

à propos de l’équipe , une équipe c'est la composition des employés qui participent dans ce projet donné donc il y avait la notion d'équipe qui est responsable de la création de ce projet et qui va assurer des formations au clients si le projet demande des formations et pour chacun des employé on note son rôle dans la formation.
de même à propos des missions , un projet peut demander ou pas une mission et donc qui sera réalisée par les membres de cette équipe responsable du projet
donc on notera pour les employés leur rôle dans la mission
par exemple une mission de collecte de données du service clientèle un membre de l équipe peut participer en faisant quelque chose dans cette mission .
j 'ai voulu dire que pour la boite de développement que je vais réaliser ce projet qui est un projet qui permet la gestion des projets informatiques est ce que je peux supposer qu un employé n'est spécialiste que dans une technologie donnée surtout que dans la boite il y avait 2 spécialités principales : .NET et JEE .
et laisser la direction des projet décider lesquels des employés affecter au projet en connaissant la technologie du projet ?

[supras31]

de même je comprends pas cette classe d 'association et ce qu elle permet de faire : projet_compétences , pourriez vous m'expliquer le role des classes associations et de même pourquoi projet compétences est composée de tache_projet_competence
Merci beaucoup ,
Cordialement

[fsmrel]

Bonsoir supras31,

de même je comprends pas cette classe d 'association et ce qu elle permet de faire : projet_compétences , pourriez vous m'expliquer le role des classes associations et de même pourquoi projet compétences est composée de tache_projet_competence

Comme je l’ai dit, d’un côté on doit savoir a priori quelles sont les compétences dont on a besoin pour un projet (comme dans les offres d’emploi dans les journaux ou chez DVP...) : c’est le rôle de la classe PROJET_COMPETENCE de nous le dire. D’un autre côté, on a les CV des employés, donc leurs compétences (classe COMPETENCE_EMPLOYE). A l’intersection des deux, on a les employés ayant les compétences requises par projet (PROJET_COMPETENCE_EMPLOYE). Maintenant, si n’importe qui peut faire n’importe quoi (ça n’était pas rare que j’observe cela du temps où l’on m’appelait pour faire des audits de projets partant en barigoule), ces classes ne servent à rien. A vous de voir.

[supras31]

merci beaucoup fsmrel pour votre réponse .
maintenant au niveau des requête j’espère que vous pouvez me donner une idée :
comment dois je remplir les tables ?
je crois qu 'on doit :
1-remplir table des employés
2-remplir table des compétences
3-remplir table projet_compétence
4-affecter compétences aux projets
mais après je dois affecter employés aux projets
comment dois je procéder ainsi ?
j’espère bien trouver une réponse de vous expert senior
de même au niveau de la génération du MLD ,j obtiens le même schéma mais avec de nouvelles données
Merci beaucoup

[fsmrel]

Bonsoir supras31,


Il s’agit d’abord de produire un diagramme logique (MLD, modèle logique des données) à partir du diagramme de classes, puis un Modèle physique des données (MPD) à partir du diagramme logique. Prenons le cas du diagramme logique que j’ai proposé dans le post #2. En fait, j’ai demandé à l’AGL de produire directement le MPD à partir du DC :

Dans la barre de menus : Outils > Générer un Modèle Physique de Données.

Une fois le MPD produit, on le retouche (comme je l’ai fait dans le post #2), car l’AGL n’a pas tous les paramètres pour générer le MPD attendu. Je présente à nouveau celui que j’ai obtenu (et retouché) :




Il reste à produire le script SQL de création des tables. Quand le MPD est affiché :

Barre de menus > SGBD > Générer la base de données

On produit ainsi le script :

 
CREATE TABLE COMPETENCE 
(
   id_competence        INT                  NOT NULL,
   libelle_competence   VARCHAR(64)          NOT NULL,
   CONSTRAINT COMPETENCE_PK PRIMARY KEY (id_competence)
) ;

CREATE TABLE EMPLOYE 
(
   id_employe           INT                  NOT NULL,
   matricule            VARCHAR(5)           NOT NULL,
   nom_employe          VARCHAR(64)          NOT NULL,
   prenom_employe       VARCHAR(64)          NOT NULL,
   date_embauche        DATE                 NOT NULL,
   grade                CHAR(3)              NOT NULL,
   CONSTRAINT EMPLOYE_PK PRIMARY KEY (id_employe),
   CONSTRAINT EMPLOYE_AK UNIQUE (matricule)
) ;

CREATE TABLE FONCTION 
(
   id_fonction          INT                  NOT NULL,
   libelle_fonction     VARCHAR(64)          NOT NULL,
   CONSTRAINT FONCTION_PK PRIMARY KEY (id_fonction)
) ;

CREATE TABLE COMPETENCE_EMPLOYE 
(
   id_employe           INT                  NOT NULL,
   id_competence        INT                  NOT NULL,
   niveau               INT                  NOT NULL,
   CONSTRAINT COMPETENCE_EMPLOYE_PK PRIMARY KEY (id_employe, id_competence),
   CONSTRAINT COMPETENCE_EMPLOYE_EMPLOYE_FK FOREIGN KEY (id_employe)
      REFERENCES EMPLOYE (id_employe),
   CONSTRAINT COMPETENCE_EMPLOYE_COMPETENCE_FK FOREIGN KEY (id_competence)
      REFERENCES COMPETENCE (id_competence)
) ;

CREATE TABLE CHEF_DE_PROJET 
(
   id_employe           INT                  NOT NULL,
   CONSTRAINT CHEF_DE_PROJET_PK PRIMARY KEY (id_employe),
   CONSTRAINT CHEF_DE_PROJET_EMPLOYE_FK FOREIGN KEY (id_employe)
      REFERENCES EMPLOYE (id_employe)
) ;

CREATE TABLE PROJET 
(
   id_projet            INT                  NOT NULL,
   id_employe_chef      INT                  NOT NULL,
   nom_projet           VARCHAR(64)          NOT NULL,
   date_debut_projet    DATE                 NOT NULL,
   duree_projet         INT                  NOT NULL,
   CONSTRAINT PROJET_PK PRIMARY KEY (id_projet),
   CONSTRAINT PROJET_CHEF_DE_PROJET_FK FOREIGN KEY (id_employe_chef)
      REFERENCES CHEF_DE_PROJET (id_employe)
) ;

CREATE TABLE PROJET_COMPETENCE 
(
   id_projet            INT                  NOT NULL,
   id_competence        INT                  NOT NULL,
   CONSTRAINT PROJET_COMPETENCE_PK PRIMARY KEY (id_projet, id_competence),
   CONSTRAINT PROJET_COMPETENCE_PROJET_FK FOREIGN KEY (id_projet)
      REFERENCES PROJET (id_projet),
   CONSTRAINT PROJET_COMPETENCE_COMPETENCE_FK FOREIGN KEY (id_competence)
      REFERENCES COMPETENCE (id_competence)
) ;

CREATE TABLE PROJET_COMPETENCE_EMPLOYE 
(
   id_projet            INT                  NOT NULL,
   id_competence        INT                  NOT NULL,
   id_employe           INT                  NOT NULL,
   CONSTRAINT PROJET_COMPETENCE_EMPLOYE_PK PRIMARY KEY (id_projet, id_competence, id_employe),
   CONSTRAINT PROJET_COMPETENCE_EMPLOYE_COMPETENCE_EMPLOYE_FK FOREIGN KEY (id_employe, id_competence)
      REFERENCES COMPETENCE_EMPLOYE (id_employe, id_competence),
   CONSTRAINT PROJET_COMPETENCE_EMPLOYE_PROJET_COMPETENCE_FK FOREIGN KEY (id_projet, id_competence)
      REFERENCES PROJET_COMPETENCE (id_projet, id_competence)
) ;

CREATE TABLE TACHE 
(
   id_projet            INT                  NOT NULL,
   id_tache             INT                  NOT NULL,
   libelle_tache        VARCHAR(64)          NOT NULL,
   CONSTRAINT TACHE_PK PRIMARY KEY (id_projet, id_tache),
   CONSTRAINT TACHE_PROJET_FK01 FOREIGN KEY (id_projet)
      REFERENCES PROJET (id_projet)
) ;

CREATE TABLE PTE 
(
   id_projet            INT                  NOT NULL,
   id_tache             INT                  NOT NULL,
   id_employe           INT                  NOT NULL,
   id_competence        INT                  NOT NULL,
   id_fonction          INT                  NOT NULL,
   CONSTRAINT PTE_PK PRIMARY KEY (id_projet, id_tache, id_employe),
   CONSTRAINT PTE_TACHE_FK FOREIGN KEY (id_projet, id_tache)
      REFERENCES TACHE (id_projet, id_tache),
   CONSTRAINT PTE_PROJET_COMPETENCE_EMPLOYE_FK FOREIGN KEY (id_projet, id_competence, id_employe)
      REFERENCES PROJET_COMPETENCE_EMPLOYE (id_projet, id_competence, id_employe),
   CONSTRAINT PTE_FONCTION_FK FOREIGN KEY (id_fonction)
      REFERENCES FONCTION (id_fonction)
) ;

Supposons que le SGBD utilisé soit MySQL : pour pouvoir rejouer le script, il faudra le faire précéder d’un script pour faire le ménage (ordre des DROP à respecter !) :

DROP TABLE IF EXISTS PTE ; 
DROP TABLE IF EXISTS TACHE ; 
DROP TABLE IF EXISTS PROJET_COMPETENCE_EMPLOYE ;
DROP TABLE IF EXISTS PROJET_COMPETENCE ;
DROP TABLE IF EXISTS PROJET ;
DROP TABLE IF EXISTS CHEF_DE_PROJET ;
DROP TABLE IF EXISTS COMPETENCE_EMPLOYE ;
DROP TABLE IF EXISTS FONCTION ;
DROP TABLE IF EXISTS EMPLOYE ;
DROP TABLE IF EXISTS COMPETENCE ;

Un début de jeu d’essai :

 
INSERT INTO COMPETENCE (id_competence, libelle_competence) VALUES (1, 'compétence 1') ;
INSERT INTO COMPETENCE (id_competence, libelle_competence) VALUES (2, 'compétence 2') ;
INSERT INTO COMPETENCE (id_competence, libelle_competence) VALUES (3, 'compétence 3') ;
INSERT INTO COMPETENCE (id_competence, libelle_competence) VALUES (4, 'compétence 4') ;

SELECT *, '' AS '<= ' FROM COMPETENCE ;

INSERT INTO EMPLOYE (id_employe, matricule, nom_employe, prenom_employe, date_embauche, grade) VALUES (1, 'a01', 'Naudin', 'Fernand', '2000-02-01', 'g01') ;
INSERT INTO EMPLOYE (id_employe, matricule, nom_employe, prenom_employe, date_embauche, grade) VALUES (2, 'b01', 'Volfoni', 'Raoul', '2001-05-01', 'g02') ;
INSERT INTO EMPLOYE (id_employe, matricule, nom_employe, prenom_employe, date_embauche, grade) VALUES (3, 'b02', 'Volfoni', 'Paul', '2001-05-01', 'g02') ;
INSERT INTO EMPLOYE (id_employe, matricule, nom_employe, prenom_employe, date_embauche, grade) VALUES (4, 'c01', 'Delafoy', 'Antoine', '2005-10-17', 'h01') ;

SELECT *, '' AS '<= ' FROM EMPLOYE ;

INSERT INTO FONCTION (id_fonction, libelle_fonction) VALUES (1, 'fonction 1') ;
INSERT INTO FONCTION (id_fonction, libelle_fonction) VALUES (2, 'fonction 2') ;
INSERT INTO FONCTION (id_fonction, libelle_fonction) VALUES (3, 'fonction 3') ;

SELECT *, '' AS '<= ' FROM FONCTION ;

INSERT INTO COMPETENCE_EMPLOYE (id_employe, id_competence, niveau) VALUES (1, 1, 1) ;
INSERT INTO COMPETENCE_EMPLOYE (id_employe, id_competence, niveau) VALUES (1, 3, 1) ;
INSERT INTO COMPETENCE_EMPLOYE (id_employe, id_competence, niveau) VALUES (2, 2, 2) ;
INSERT INTO COMPETENCE_EMPLOYE (id_employe, id_competence, niveau) VALUES (2, 3, 1) ;
INSERT INTO COMPETENCE_EMPLOYE (id_employe, id_competence, niveau) VALUES (2, 1, 3) ;
INSERT INTO COMPETENCE_EMPLOYE (id_employe, id_competence, niveau) VALUES (3, 1, 2) ;
INSERT INTO COMPETENCE_EMPLOYE (id_employe, id_competence, niveau) VALUES (3, 2, 4) ;
INSERT INTO COMPETENCE_EMPLOYE (id_employe, id_competence, niveau) VALUES (4, 3, 4) ;

SELECT *, '' AS '<= ' FROM COMPETENCE_EMPLOYE ;

INSERT INTO CHEF_DE_PROJET (id_employe) VALUES (1) ;
INSERT INTO CHEF_DE_PROJET (id_employe) VALUES (2) ;

SELECT *, '' AS '<= ' FROM CHEF_DE_PROJET ;

INSERT INTO PROJET (id_projet, id_employe_chef, nom_projet, date_debut_projet, duree_projet) VALUES (1, 1, 'projet 1', '2014-02-15', 12) ;
INSERT INTO PROJET (id_projet, id_employe_chef, nom_projet, date_debut_projet, duree_projet) VALUES (2, 2, 'projet 2', '2014-04-06', 8) ;
INSERT INTO PROJET (id_projet, id_employe_chef, nom_projet, date_debut_projet, duree_projet) VALUES (3, 1, 'projet 3', '2015-01-05', 24) ;

SELECT *, '' AS '<= ' FROM PROJET ;

INSERT INTO PROJET_COMPETENCE (id_projet, id_competence) VALUES (1, 1) ;
INSERT INTO PROJET_COMPETENCE (id_projet, id_competence) VALUES (1, 3) ;
INSERT INTO PROJET_COMPETENCE (id_projet, id_competence) VALUES (2, 1) ;
INSERT INTO PROJET_COMPETENCE (id_projet, id_competence) VALUES (2, 2) ;
INSERT INTO PROJET_COMPETENCE (id_projet, id_competence) VALUES (3, 1) ;

SELECT *, '' AS '<= ' FROM PROJET_COMPETENCE ;

INSERT INTO PROJET_COMPETENCE_EMPLOYE (id_projet, id_competence, id_employe) VALUES (1, 1, 1) ;
INSERT INTO PROJET_COMPETENCE_EMPLOYE (id_projet, id_competence, id_employe) VALUES (1, 3, 1) ;
INSERT INTO PROJET_COMPETENCE_EMPLOYE (id_projet, id_competence, id_employe) VALUES (1, 3, 4) ;
INSERT INTO PROJET_COMPETENCE_EMPLOYE (id_projet, id_competence, id_employe) VALUES (2, 1, 2) ;
INSERT INTO PROJET_COMPETENCE_EMPLOYE (id_projet, id_competence, id_employe) VALUES (2, 2, 3) ;

SELECT *, '' AS '<= ' FROM PROJET_COMPETENCE_EMPLOYE ;

INSERT INTO TACHE (id_projet, id_tache, libelle_tache) VALUES (1, 1, 'projet 1, tâche 1') ;
INSERT INTO TACHE (id_projet, id_tache, libelle_tache) VALUES (1, 2, 'projet 1, tâche 2') ;
INSERT INTO TACHE (id_projet, id_tache, libelle_tache) VALUES (1, 3, 'projet 1, tâche 3') ;
INSERT INTO TACHE (id_projet, id_tache, libelle_tache) VALUES (2, 1, 'projet 2, tâche 1') ;
INSERT INTO TACHE (id_projet, id_tache, libelle_tache) VALUES (2, 2, 'projet 2, tâche 2') ;
INSERT INTO TACHE (id_projet, id_tache, libelle_tache) VALUES (3, 1, 'projet 3, tâche 1') ;
INSERT INTO TACHE (id_projet, id_tache, libelle_tache) VALUES (3, 2, 'projet 3, tâche 2') ;

SELECT *, '' AS '<= ' FROM TACHE ;

INSERT INTO PTE (id_projet, id_tache, id_employe, id_competence, id_fonction) VALUES (1, 1, 1, 1, 1) ;
INSERT INTO PTE (id_projet, id_tache, id_employe, id_competence, id_fonction) VALUES (1, 2, 1, 3, 2) ;
INSERT INTO PTE (id_projet, id_tache, id_employe, id_competence, id_fonction) VALUES (1, 1, 4, 3, 3) ;
INSERT INTO PTE (id_projet, id_tache, id_employe, id_competence, id_fonction) VALUES (2, 1, 2, 1, 3) ;
INSERT INTO PTE (id_projet, id_tache, id_employe, id_competence, id_fonction) VALUES (2, 2, 3, 2, 3) ;

SELECT *, '' AS '<= ' FROM PTE ;

Et quand une réponse à pu vous éclairer, n’oubliez pas de voter.

Bon courage...

[supras31]

Salut, merci fsmrel pour votre réponse et désole pour le dérangement .
mais dans l'application que je dois développer:
il faut que lors de l'affectation des employés aux projet
on sélectionne un projet ,et on montre la liste des employés disponibles et devant chaque employé un bouton affecter .
ainsi la création des informations relatives au projet doit être en premier et puis la sélection des compétences requises par le projet
puis afficher les employés qui ont ces compétences avec un bouton affecter
de même au niveau des taches , leur gestion doit être séparée ,car c'est le chef du projet dans mon cas qui doit créer les taches relatives à son projet
et affecter les taches aux employés.
de même on devrait bien supprimer une affectation
je comprends pas à ce moment quelles sont les relations responsables des affectations au projet
et celles responsables des affectations au taches .
ce que je trouve jusqu'à maintenant
comment affecter employés aux taches et on souhaite pour chaque employé son rôle dans une tache donnée .
de même comment puisse je affecter un employé avec des requêtes sql c'est à dire quelles sont les tables qu on doit y insérer des données pour présenter cette affectation.
je pense qu on doit de même lier la table tache aux employé non ?
Merci bien bien sur pour votre aide jusqu'à maintenant

[fsmrel]

Bonsoir supras31,


Avec les tables fournies par l’AGL, on devrait répondre au besoin.

Commençons par quelque travaux préliminaires : ajoutons quelques employés supplémentaires dans la table EMPLOYE, dotons-les de leurs compétences, nommons Jean Trancène et Pierre Ponce chefs de projets, créons des projets nouveaux (Aristote et Socrate), et définissons les compétences requises pour les projets Aristote et Socrate.

(1) Ajout des employés supplémentaires dans la table EMPLOYE :

 
INSERT INTO EMPLOYE (id_employe, matricule, nom_employe, prenom_employe, date_embauche, grade) VALUES (5, 'b04', 'Trancène', 'Jean', '2007-07-14', 'g01') ;
INSERT INTO EMPLOYE (id_employe, matricule, nom_employe, prenom_employe, date_embauche, grade) VALUES (6, 'b07', 'Bonneau', 'Jean', '2009-05-01', 'h02') ;
INSERT INTO EMPLOYE (id_employe, matricule, nom_employe, prenom_employe, date_embauche, grade) VALUES (7, 'b08', 'Ponce', 'Pierre', '2009-07-01', 'h02') ;
INSERT INTO EMPLOYE (id_employe, matricule, nom_employe, prenom_employe, date_embauche, grade) VALUES (8, 'c05', 'Titegoutte', 'Justine', '2009-09-01', 'g02') ;
INSERT INTO EMPLOYE (id_employe, matricule, nom_employe, prenom_employe, date_embauche, grade) VALUES (9, 'c06', 'Titegoutte', 'Corinne', '2009-09-02', 'g01') ;
INSERT INTO EMPLOYE (id_employe, matricule, nom_employe, prenom_employe, date_embauche, grade) VALUES (10, 'c07', 'Letracteur', 'Igor', '2010-01-01', 'g02') ;
INSERT INTO EMPLOYE (id_employe, matricule, nom_employe, prenom_employe, date_embauche, grade) VALUES (11, 'c08', 'Letracteur', 'Hercule', '2010-01-01', 'g02') ;
INSERT INTO EMPLOYE (id_employe, matricule, nom_employe, prenom_employe, date_embauche, grade) VALUES (12, 'c09', 'Hocquart de Tours', 'Adhémar', '2010-05-01', 'g01') ;
INSERT INTO EMPLOYE (id_employe, matricule, nom_employe, prenom_employe, date_embauche, grade) VALUES (13, 'd01', 'Surlessièges', 'Amedeus', '2010-05-02', 'g01') ;
INSERT INTO EMPLOYE (id_employe, matricule, nom_employe, prenom_employe, date_embauche, grade) VALUES (14, 'd02', 'Labarrière', 'Hildefonse', '2010-05-03', 'g01') ;

(2) Compétences dont on dote les nouveaux employés (table COMPETENCE_EMPLOYE) :

 
INSERT INTO COMPETENCE_EMPLOYE (id_employe, id_competence, niveau) SELECT (SELECT id_employe FROM EMPLOYE WHERE matricule = 'b04')
     , (SELECT id_competence FROM COMPETENCE WHERE libelle_competence = 'compétence 1'), 2 ;

INSERT INTO COMPETENCE_EMPLOYE (id_employe, id_competence, niveau) SELECT (SELECT id_employe FROM EMPLOYE WHERE matricule = 'b04')
     , (SELECT id_competence FROM COMPETENCE WHERE libelle_competence = 'compétence 2'), 2 ;     

INSERT INTO COMPETENCE_EMPLOYE (id_employe, id_competence, niveau) SELECT (SELECT id_employe FROM EMPLOYE WHERE matricule = 'b04')
     , (SELECT id_competence FROM COMPETENCE WHERE libelle_competence = 'compétence 3'), 2 ;
	
INSERT INTO COMPETENCE_EMPLOYE (id_employe, id_competence, niveau) SELECT (SELECT id_employe FROM EMPLOYE WHERE matricule = 'c05')
     , (SELECT id_competence FROM COMPETENCE WHERE libelle_competence = 'compétence 1'), 2 ;
     
INSERT INTO COMPETENCE_EMPLOYE (id_employe, id_competence, niveau) SELECT (SELECT id_employe FROM EMPLOYE WHERE matricule = 'c05')
     , (SELECT id_competence FROM COMPETENCE WHERE libelle_competence = 'compétence 3'), 2 ;
     
INSERT INTO COMPETENCE_EMPLOYE (id_employe, id_competence, niveau) SELECT (SELECT id_employe FROM EMPLOYE WHERE matricule = 'c06')
     , (SELECT id_competence FROM COMPETENCE WHERE libelle_competence = 'compétence 1'), 3 ;     
    
INSERT INTO COMPETENCE_EMPLOYE (id_employe, id_competence, niveau) SELECT (SELECT id_employe FROM EMPLOYE WHERE matricule = 'c06')
     , (SELECT id_competence FROM COMPETENCE WHERE libelle_competence = 'compétence 3'), 3 ;     
    
INSERT INTO COMPETENCE_EMPLOYE (id_employe, id_competence, niveau) SELECT (SELECT id_employe FROM EMPLOYE WHERE matricule = 'c06')
     , (SELECT id_competence FROM COMPETENCE WHERE libelle_competence = 'compétence 4'), 2 ;     
     
INSERT INTO COMPETENCE_EMPLOYE (id_employe, id_competence, niveau) SELECT (SELECT id_employe FROM EMPLOYE WHERE matricule = 'c07')
     , (SELECT id_competence FROM COMPETENCE WHERE libelle_competence = 'compétence 1'), 2 ;     
    
INSERT INTO COMPETENCE_EMPLOYE (id_employe, id_competence, niveau) SELECT (SELECT id_employe FROM EMPLOYE WHERE matricule = 'c07')
     , (SELECT id_competence FROM COMPETENCE WHERE libelle_competence = 'compétence 2'), 1 ;  
         
INSERT INTO COMPETENCE_EMPLOYE (id_employe, id_competence, niveau) SELECT (SELECT id_employe FROM EMPLOYE WHERE matricule = 'c08')
     , (SELECT id_competence FROM COMPETENCE WHERE libelle_competence = 'compétence 1'), 2 ;
     
INSERT INTO COMPETENCE_EMPLOYE (id_employe, id_competence, niveau) SELECT (SELECT id_employe FROM EMPLOYE WHERE matricule = 'c09')
     , (SELECT id_competence FROM COMPETENCE WHERE libelle_competence = 'compétence 3'), 1 ;
    
INSERT INTO COMPETENCE_EMPLOYE (id_employe, id_competence, niveau) SELECT (SELECT id_employe FROM EMPLOYE WHERE matricule = 'd02')
     , (SELECT id_competence FROM COMPETENCE WHERE libelle_competence = 'compétence 4'), 2 ;    

(3) Nomination de Jean Trancène et Pierre Ponce comme chefs de projets :

 
INSERT INTO CHEF_DE_PROJET (id_employe) 
    SELECT id_employe FROM EMPLOYE WHERE matricule = 'b04' ;
    
INSERT INTO CHEF_DE_PROJET (id_employe) 
    SELECT id_employe FROM EMPLOYE WHERE matricule = 'b08' ;
    

(4) Création des projets Aristote et Socrate.

( J’ai ajouté une colonne code_projet à la table PROJET)

 
INSERT INTO PROJET (id_projet, code_projet, id_employe_chef, nom_projet, date_debut_projet, duree_projet)
    SELECT COALESCE(MAX(id_projet) +1, 1), 'ari', (SELECT id_employe FROM EMPLOYE WHERE matricule = 'b04'), 'Aristote', '2015-04-02', 6
    FROM   PROJET ;

INSERT INTO PROJET (id_projet, code_projet, id_employe_chef, nom_projet, date_debut_projet, duree_projet)
    SELECT COALESCE(MAX(id_projet) +1, 1), 'soc', (SELECT id_employe FROM EMPLOYE WHERE matricule = 'b08'), 'Socrate', '2015-04-07', 12
    FROM   PROJET ;

(5) Définition des compétences requises pour les projets Aristote et Socrate :

 
INSERT INTO PROJET_COMPETENCE (id_projet, id_competence) SELECT (SELECT id_projet FROM PROJET WHERE code_projet = 'ari')
  , (SELECT id_competence FROM COMPETENCE WHERE libelle_competence = 'compétence 1') ;
  
INSERT INTO PROJET_COMPETENCE (id_projet, id_competence) SELECT (SELECT id_projet FROM PROJET WHERE code_projet = 'ari')
  , (SELECT id_competence FROM COMPETENCE WHERE libelle_competence = 'compétence 3') ;

INSERT INTO PROJET_COMPETENCE (id_projet, id_competence) SELECT (SELECT id_projet FROM PROJET WHERE code_projet = 'soc')
  , (SELECT id_competence FROM COMPETENCE WHERE libelle_competence = 'compétence 2') ;
  
INSERT INTO PROJET_COMPETENCE (id_projet, id_competence) SELECT (SELECT id_projet FROM PROJET WHERE code_projet = 'soc')
  , (SELECT id_competence FROM COMPETENCE WHERE libelle_competence = 'compétence 4') ;

On sait fournir la liste des employés qui ne sont pas déjà affectés à d’autres projets, qui ne sont pas chefs de projet et qui ont au moins une des compétences requises pour un projet (par exemple pour le projet Aristote) :

 
SELECT matricule, nom_employe, prenom_employe, libelle_competence
FROM   EMPLOYE AS t JOIN COMPETENCE_EMPLOYE AS u ON t.id_employe = u.id_employe
                    JOIN PROJET_COMPETENCE AS v ON u.id_competence = v.id_competence
                    JOIN PROJET AS w ON v.id_projet = w.id_projet
                    JOIN COMPETENCE AS s ON v.id_competence = s.id_competence
WHERE code_projet = 'ari'
AND  NOT EXISTS (SELECT ''                 --  Ne pas sélectionner des employés déjà affectés à d'autres projets  
                 FROM   PTE AS y
                 WHERE  t.id_employe = y.id_employe) 
AND  NOT EXISTS (SELECT ''               -- Ne pas sélectionner des chefs de projets !
                 FROM   CHEF_DE_PROJET AS z
                 WHERE  t.id_employe = z.id_employe)
ORDER BY matricule, libelle_competence ;                  

La requête ci-dessus permet de fournir la liste des employés qui ont au moins une des compétences requises pour le projet, mais s’il doivent avoir toutes les compétences, la requête est évidemment à modifier. En tout cas, on sait répondre à la question : « Quels employés sont disponibles et ont les compétences voulues pour être affectés au projet Aristote ».

Comme on sait créer dans la table PROJET_COMPETENCE_EMPLOYE les affectations des employés retenus pour le projet Aristote, avec les compétences requises (voir dans mon message précédent les INSERT correspondants), on saura donc sans problème qui est affecté au projet, avec quelles compétences.

je pense qu’on doit de même lier la table tache aux employé non ?

Non, car cela engendrerait une redondance, et la redondance est l’ennemie des bases de données !

Pour savoir à quelle(s) tâche(s) un employé est affecté :

 
SELECT  nom_projet, libelle_tache, matricule, nom_employe, prenom_employe, '' AS '<= affectation des employés aux tâches'
FROM    EMPLOYE AS x JOIN PTE AS y ON x.id_employe = y.id_employe
                     JOIN TACHE AS z ON y.id_projet = z.id_projet AND y.id_tache = z.id_tache
                     JOIN PROJET AS t ON z.id_projet = t.id_projet 
ORDER BY nom_projet, libelle_tache, matricule ;

on devrait bien supprimer une affectation

Pour supprimer une affectation d’un employé (matricule = 'a01') à une tâche (Projet = 'Projet 1' , tâche = 'projet 1, tâche 1') :

 
DELETE FROM PTE
    WHERE EXISTS (SELECT ''
                  FROM   EMPLOYE AS x, TACHE  AS z, PROJET AS t  
                  WHERE  matricule = 'a01' AND nom_projet = 'Projet 1' AND z.libelle_tache = 'projet 1, tâche 1'
                    AND  x.id_employe = PTE.id_employe
                    AND  z.id_projet = PTE.id_projet AND PTE.id_tache = z.id_tache
                    AND  z.id_projet = t.id_projet) ;

Le principe est le même pour supprimer une affectation d’un employé (matricule = 'c99') à un projet (nom_projet = 'Projet 1') :

 
DELETE FROM PROJET_COMPETENCE_EMPLOYE
       WHERE EXISTS (SELECT ''
                     FROM   EMPLOYE AS x, PROJET AS y
                     WHERE  x.id_employe = PROJET_COMPETENCE_EMPLOYE.id_employe
                     AND    y.id_projet = PROJET_COMPETENCE_EMPLOYE.id_projet
                     AND    matricule = 'c99' AND  nom_projet = 'Projet 1') ;

[supras31]

Merci beaucoup monsieur fsmrel maintenant je suis en train d'ajouter la notion des formations et des clients et des missions et des depenses externes relatives à un projet .
je pense que ça serait tout correct et qui ne pose pas de problèmes au niveau du développement
de même je vais essayer d’implémenter les scripts que vous m'avez donné ci-dessus .
encore une fois un grand merci pour ce support de votre coté que j'ai pas trouvé dans mon encadreur à la faculté qui est censé m'aider .
j’espère bien que vous pourriez m'aider aujourd'hui en vérifiant le diagramme de classe s'il est bon ou non et qui peut être utilisé pour commencez le développement de mon projet de fin d’études .
Cordialement.

[supras31]

Bonsoir monsieur fsmrel à propos du diagramme que vous m'avez donné ,voilà ci dessous ce que l'AGL m'a généré , est ce que je dois supprimer les clés primaires qui n'existent pas dans votre de schéma ??

et de même je pense que votre schéma est très logique et merci pour votre aide , mais désol pour le dérangement
maintenant je dois créer les missions et les formations et les dépenses et de juste gérer les affectations des employés participants dans un projet au missions relatives à un projet et au formations relatives à un projet
donc comme vous le voyez : un projet peut avoir au minimum une formation chez le client concerné par le projet
et un projet peut nécessiter des missions ou pas selon le cas donc cela donne une cardinalité 0/*


mais le problème qui se pose est :
comment gérer la relation entre les employés invoqués au projet et leur affectation au mission ou bien aux formations sans perdre tous ce qu'on a fait ci dessus.
excusez moi une fois en espérant que vous pourriez m'aider j'ai trop essayer , mais comme vous avez dit la redondance est l'ennemie des bases de données , je ne trouve pas jusqu'à ce moment une solution pour générer une base de données et commencer le développement de l'application et qui prend beaucoup de temps , surtout que j'ai que 2 mois encore et j'ai très peur de ne pas accomplir mon projet et ne pas réussir l'année scolaire

[fsmrel]

Bonsoir supras,

Pour le moment je suis très pris. Je ne pourrai pas regarder avant mardi.

Désolé,

A bientôt quand même

[supras31]

Salut Monsieur voilà ci dessous le modèle physique de données que power amc m'a généré , est ce que je dois changer cet outil car il y avait les attributs :
Pro_id_projet et po_id_comp dans la table fonction qui n'existent pas dans votre modèle logique
comme vous pouvez le voyer , que dois je faire afin d'en profiter des requêtes sql que vous m 'avez donné

[supras31]

de même monsieur je vois pas comment ça se fait l'affectation d'un employé à un projet
j'avais plus de temps en attente de votre aide , je dois commencer le développement le plutôt possible

[fsmrel]

Bonsoir supras31,

voici le modèle physique de données que power amc m'a généré , est ce que je dois changer cet outil car il y avait les attributs :
Pro_id_projet et po_id_comp dans la table fonction qui n'existent pas dans votre modèle logique

On ne va pas changer d’outil^^, mais retoucher ce qu’il a produit. Par exemple, la table PROJET_COMPETENCE_EMPLOYE est le résultat de l’equi-join des tables PROJET_COMPETENCE et COMPETENCE_EMPLOYE, ce qui fait que la compétence figure deux fois dans PROJET_COMPETENCE_EMPLOYE, car PowerAMC n’est pas censé savoir qu’on préférerait une jointure naturelle, c'est-à-dire que la compétence ne figure qu’une fois.

La compétence est donc présente deux fois dans la table PROJET_COMPETENCE_EMPLOYE, donc une fois de trop. Dans mon MLD précédent, elle est représentée par les attributs id_competence, et COM_id_competence :




Dans votre MLD, il s’agit des attributs id_comp et pro_id_comp, mais le raisonnement à tenir est le même.
Comme on veut que la compétence ne figure qu’une fois dans la table PROJET_COMPETENCE_EMPLOYE, il faut y éliminer soit l’attribut id_competence, soit l’attribut COM_id_competence. Par exemple, choisissons d’éliminer COM_id_competence : en l’occurrence, cet attribut appartient à la clé étrangère fk1 = {id_employe, COM_id_competence} connectant PROJET_COMPETENCE_EMPLOYE et COMPETENCE_EMPLOYE. On le constate en cliquant sur la flèche connectant les deux tables dans le modèle, ce qui provoque l’ouverture de la fenêtre correspondante :




Chez vous, il s’agit plutôt de cliquer sur le lien entre PROJET_COMPETENCE_EMPLOYE et PROJET_COMPETENCE, mais la démarche à suivre est la même.

En cliquant sur l’onglet « Jointures » on provoque l’ouverture d’une fenêtre dans laquelle figurent (à gauche) les attributs de la clé primaire {id_employe, id_competence} de la table « parente » COMPETENCE_EMPLOYE, et à droite les attributs de la clé étrangère fk1 = {id_employe, COM_id_competence} de la table « fille » COMPETENCE_EMPLOYE :




Pour modifier la clé étrangère fk1 en {id_employe, id_competence}, dans cette fenêtre on clique sur l’attribut COM_id_competence, puis sur le bouton qui lui est associé :





Ce qui provoque l’affichage de la sélection des attributs de la table COMPETENCE_EMPLOYE. Comme on voudrait que la clé étrangère soit {id_employe, id_competence} à la place de {id_employe, COM_id_competence}, on clique sur l’attribut id_competence dans la sélection :




L’attribut COM_id_competence ne participe plus à aucune clé étrangère :




On peut donc le supprimer :





Dans votre MLD, le ménage est à faire sur le lien entre PROJET_COMPETENCE_EMPLOYE et PROJET_COMPETENCE, mais, comme je l’ai déjà dit, la démarche à suivre est la même.

_____________________________________


En passant : réordonner les attributs dans les clés primaires.

L’ordre des attributs dans la clé primaire d’une table n’est pas forcément celui qu’on attend, PowerAMC définissant parfois cet ordre au hasard. Par exemple, pour reprendre la table PROJET_COMPETENCE_EMPLOYE, cet ordre est le suivant : id_projet, id_competence, id_employe, alors qu’on préférerait qu’il soit : id_projet, id_employe, id_competence.

Pour changer cela :

Double-cliquer sur la table, puis cliquer sur l’onglet « Clés » :




Double-cliquer sur la ligne qui contient le nom de la clé (competence_id_1 dans l’exemple), on a alors accès à la fenêtre « Propriétés de la clé » :




Cliquer sur l’onglet « Colonnes », apparaissent alors les noms des attributs (colonnes) de la clé :



Pour remonter id_employe devant id_competence, sélectionner la ligne correspondante et utiliser la flèche à cet effet :



___________________________________


J’ai relu vos messages et je constate qu’il faut effectivement modéliser la classe EQUIPE. Je n’avais pas vu qu’une équipe avait un nom et que certains employés pouvaient faire partie de cette équipe, sans pour autant participer à des projets...


On va donc faire renaître la classe EQUIPE, en l’associant à la classe PROJET et à la classe EMPLOYE :



Vous remarquerez que j’ai utilisé un relation de composition qui sémantiquement ne s’impose peut-être pas entre EQUIPE et PROJET. Mais ceci va permettre de résoudre un problème qui se posera au niveau MLD, et surtout SQL, je veux parler de la mise en œuvre d’une contrainte de chemin, qui autrement nécessiterait la mise en œuvre d’au moins un trigger. Je dis qu’il y a contrainte de chemin quand partant d’un point A pour aller au point Z, on peut avoir plus d’un parcours. En l’occurrence, partant de PROJET_COMPETENCE_EMPLOYE, on peut aller jusqu’à EQUIPE en passant soit par COMPETENCE_EMPLOYE puis EMPLOYE, soit par COMPETENCE_EMPLOYE puis COMPETENCE et PROJET, soit par PROJET_COMPETENCE puis PROJET, soit par TACHE puis PROJET. Exemple : l’employé emp1 est affecté à la tâche ta1 du projet pr1 qui est du ressort de l’équipe eq1, mais rien n’empêche que (passant par COMPETENCE_EMPLOYE puis EMPLOYE) cet employé fasse partie de l’équipe eq2...


MLD correspondant, en procédant à des aménagements, identiques à ceux j’ai décrit ci-dessus :



Du fait de la propagation de l’attribut id_equipe jusqu’à la table PTE et comme cet attribut n’y figure qu’une seule fois, la contrainte de chemin est automtiquement résolue. Pour une dérivation correcte du DC en MLD, cela nécessitait la mise en oeuvre de la relation de composition entre les classes EQUIPE et PROJET.


Script de création des tables

CREATE TABLE COMPETENCE 
(
   id_competence        Int                  Not null,
   libelle_competence   Varchar(64)          Not null,
   CONSTRAINT COMPETENCE_PK PRIMARY KEY (id_competence)
) ;

CREATE TABLE EQUIPE 
(
   id_equipe            Int                  Not null,
   nom_equipe           Varchar(64)          Not null,
   disponibilite        Varchar(64)          Not null,
   CONSTRAINT EQUIPE_PK PRIMARY KEY (id_equipe)
) ;

CREATE TABLE EMPLOYE 
(
   id_equipe            Int                  Not null,
   id_employe           Int                  Not null,
   matricule            Varchar(5)           Not null,
   nom_employe          Varchar(64)          Not null,
   prenom_employe       Varchar(64)          Not null,
   date_embauche        Date                 Not null,
   grade                Varchar(3)           Not null,
   CONSTRAINT EMPLOYE_PK PRIMARY KEY (id_equipe, id_employe),
   CONSTRAINT EMPLOYE_AK UNIQUE (matricule),
   CONSTRAINT EMPLOYE_EQUIPE_FK FOREIGN KEY (id_equipe)
      REFERENCES EQUIPE (id_equipe)
) ;

CREATE TABLE CHEF_DE_PROJET 
(
   id_equipe            Int                  Not null,
   id_employe           Int                  Not null,
   CONSTRAINT CHEF_DE_PROJET_PK PRIMARY KEY (id_equipe, id_employe),
   CONSTRAINT CHEF_DE_PROJET_EMPLOYE_FK FOREIGN KEY (id_equipe, id_employe)
      REFERENCES EMPLOYE( id_equipe, id_employe)
) ;

CREATE TABLE PROJET 
(
   id_equipe            Int                  Not null,
   id_projet            Int                  Not null,
   code_projet          char(3)              Not Null,
   id_employe_chef      Int                  Not null,
   nom_projet           Varchar(64)          Not null,
   date_debut_projet    Date                 Not null,
   duree_projet         Int                  Not null,
   CONSTRAINT PROJET_PK PRIMARY KEY (id_equipe, id_projet),
   CONSTRAINT PROJET_AK UNIQUE (code_projet),
   CONSTRAINT PROJET_CHEF_DE_PROJET_FK FOREIGN KEY (id_equipe, id_employe_chef)
      REFERENCES CHEF_DE_PROJET (id_equipe, id_employe),
   CONSTRAINT PROJET_EQUIPE_FK FOREIGN KEY (id_equipe)
      REFERENCES EQUIPE (id_equipe)
) ;

CREATE TABLE PROJET_COMPETENCE 
(
   id_equipe            Int                  Not null,
   id_projet            Int                  Not null,
   id_competence        Int                  Not null,
   CONSTRAINT PROJET_COMPETENCE_PK PRIMARY KEY (id_equipe, id_projet, id_competence),
   CONSTRAINT PROJET_COMPETENCE_PROJET_FK FOREIGN KEY (id_equipe, id_projet)
      REFERENCES PROJET (id_equipe, id_projet),
   CONSTRAINT PROJET_COMPETENCE_COMPETENCE_FK FOREIGN KEY (id_competence)
      REFERENCES COMPETENCE (id_competence)
) ;

CREATE TABLE TACHE 
(
   id_equipe            Int                  Not null,
   id_projet            Int                  Not null,
   id_tache             Int                  Not null,
   libelle_tache        Varchar(64)          Not null,
   CONSTRAINT TACHE_PK PRIMARY KEY (id_equipe, id_projet, id_tache),
   CONSTRAINT TACHE_PROJET_FK FOREIGN KEY (id_equipe, id_projet)
      REFERENCES PROJET (id_equipe, id_projet)
) ;

CREATE TABLE COMPETENCE_EMPLOYE 
(
   id_equipe            Int                  Not null,
   id_employe           Int                  Not null,
   id_competence        Int                  Not null,
   niveau               Int                  Not null,
   CONSTRAINT COMPETENCE_EMPLOYE_PK PRIMARY KEY (id_equipe, id_employe, id_competence),
   CONSTRAINT COMPETENCE_EMPLOYE_EMPLOYE_FK FOREIGN KEY (id_equipe, id_employe)
      REFERENCES EMPLOYE (id_equipe, id_employe),
   CONSTRAINT COMPETENCE_EMPLOYE_COMPETENCE_FK FOREIGN KEY (id_competence)
      REFERENCES COMPETENCE (id_competence)
) ;

CREATE TABLE PROJET_COMPETENCE_EMPLOYE 
(
   id_equipe            Int                  Not null,
   id_projet            Int                  Not null,
   id_employe           Int                  Not null,
   id_competence        Int                  Not null,
   CONSTRAINT PROJET_COMPETENCE_EMPLOYE_PK PRIMARY KEY (id_equipe, id_projet, id_employe, id_competence),
   CONSTRAINT PROJET_COMPETENCE_EMPLOYE_COMPETENCE_EMPLOYE_FK FOREIGN KEY (id_equipe, id_employe, id_competence)
      REFERENCES COMPETENCE_EMPLOYE (id_equipe, id_employe, id_competence),
   CONSTRAINT PROJET_COMPETENCE_EMPLOYE_PROJET_COMPETENCE_FK FOREIGN KEY (id_equipe, id_projet, id_competence)
      REFERENCES PROJET_COMPETENCE (id_equipe, id_projet, id_competence)
) ;

CREATE TABLE PTE 
(
   id_equipe            Int                  Not null,
   id_projet            Int                  Not null,
   id_tache             Int                  Not null,
   id_employe           Int                  Not null,
   id_competence        Int                  Not null,
   libelle_fonction     Varchar(64)          Not null,
   CONSTRAINT PTE_PK PRIMARY KEY (id_equipe, id_projet, id_tache, id_employe),
   CONSTRAINT PTE_TACHE_FK FOREIGN KEY (id_equipe, id_projet, id_tache)
      REFERENCES TACHE (id_equipe, id_projet, id_tache),
   CONSTRAINT PTE_PROJET_COMPETENCE_EMPLOYE_FK FOREIGN KEY (id_equipe, id_projet, id_employe, id_competence)
      REFERENCES PROJET_COMPETENCE_EMPLOYE (id_equipe, id_projet, id_employe, id_competence)
) ;

Je n'ai pas terminé, dès que je peux, je m’occupe de vous en priorité.

[supras31]

Merci pour votre aide , mais est ce de même on doit reprendre comment serait la création d une équipe et de même la ajout des employés ayant les comeptences requises à un projet , parfois on peut avoir un employé qui avait les compétences mais on peut ne pas l'affecter à un projet , et de même lequel se fait avant l ajout d équipe ou bien l ajout d un employé à un projet ,
j'avais des contraintes de modélisation à suivre à cause des diagrammes de séquences mais je peut les changer
Merci beaucoup pour votre aide , mais comme j'ai dis je dois commencer le développement cette semaine , il me reste plus de temps donc si vous avez du temps prière de me pas laisser , merci beaucoup encore une fois pour cette aide
et n oubliez pas que le projet ne comporte pas que la création d équipe et l affectation car je dois modéliser aussi les missions et les formations relatives à un projet et de même affecter des employés participants au projet à ces missions données , de même si vous avez une idée de création d'un espace de discussion concernant un projet

[fsmrel]

Bonjour supras31,

est ce de même on doit reprendre comment serait la création d une équipe et de même la ajout des employés ayant les compétences requises à un projet , parfois on peut avoir un employé qui avait les compétences mais on peut ne pas l'affecter à un projet , et de même lequel se fait avant l ajout d équipe ou bien l ajout d un employé à un projet ,
j'avais des contraintes de modélisation à suivre à cause des diagrammes de séquences mais je peut les changer

Dans le diagramme de classes, on traite du Quoi mais pas du Comment (What not How). Ainsi, on a une classe EQUIPE, une classe EMPLOYE, une classe COMPETENCE_EMPLOYE, une classe PROJET_COMPTENCE, donc tous les éléments prérequis pour pouvoir affecter un employé à un projet, c'est-à-dire créer une instance de la classe PROJET_COMPETENCE_EMPLOYE : Si le projet pr1 est confié à l’équipe eq1, et requiert la compétence comp1, comme on sait quels employés de l’équipe e1 ont cette compétence, alors on sait quel(s) employés(s) affecter à pr1. En tout cas, cela est évident du point de vue du MLD et du script SQL que je vous ai proposés.

Remarques annexes :

Concernant le type des données, évitez le type FLOAT (virgule flottante), remplacez par le type DECIMAL (virgule fixe). Dimensionnez de façon raisonnable le type VARCHAR (qui occupe de la place) : VARCHAR(254) pour un matricule ça fait vraiment beaucoup, même chose pour un nom, un prénom, etc.

Prévoyez une table (donc une classe en amont) pour gérer les fonctions, même chose pour les niveaux.

Table PROJET :

(a) Pour ma part, je renommerais id_employe en id_employe_chef, mais ça n’est pas une obligation.

(b) si vous retenez la paire d’attributs {debut_projet, fin_projet}, alors l’attribut duree_projet est calculable, donc redondant et doit disparaîte de la table. A l’inverse, vous pouvez retenir la paire {debut_projet, duree_projet}, auquel cas c’est l’attribut fin_projet qui doit disparaître (solution préconisée par les spécialistes de SQL).

Pour éviter de surcharger le MLD/MPD et le rendre illisible, évitez de faire apparaître le nom des contraintes (FK_PROJET_C_PROJET_CO_COMPETEN, etc.) :

Outils > Préférences d’affichage > Général > Référence : Sélectionner « Aucun » :

Je vais regarder la suite (formations, etc.), mais j’aimerais bien qu’on arrive à conclure les affectations des employés aux projets.

[fsmrel]

Bonsoir supras31,

je vois pas comment ça se fait l'affectation d'un employé à un projet
j'avais plus de temps en attente de votre aide , je dois commencer le développement le plutôt possible.

L’affectation d’un employé à un projet n’est possible que si cet employé a les compétences requises pour ce projet (table PROJET_COMPETENCE_EMPLOYE) .

Reprenons donc la série des INSERT en tenant compte de la modélisation où figure la classe EQUIPE. A noter que j’ai ajouté l’attribut code_projet dans l’en-tête de la table PROJET :

 
CREATE TABLE PROJET 
(
   id_equipe            Int                  Not null,
   id_projet            Int                  Not null,
   code_projet          char(3)              Not Null,
   id_employe_chef      Int                  Not null,
   nom_projet           Varchar(64)          Not null,
   date_debut_projet    Date                 Not null,
   duree_projet         Int                  Not null,
   CONSTRAINT PROJET_PK PRIMARY KEY (id_equipe, id_projet),
   CONSTRAINT PROJET_AK UNIQUE (code_projet),
   CONSTRAINT PROJET_CHEF_DE_PROJET_FK FOREIGN KEY (id_equipe, id_employe_chef)
      REFERENCES CHEF_DE_PROJET (id_equipe, id_employe),
   CONSTRAINT PROJET_EQUIPE_FK FOREIGN KEY (id_equipe)
      REFERENCES EQUIPE (id_equipe)
) ;

(1) - On sait créer des compétences :

 
INSERT INTO COMPETENCE (id_competence, libelle_competence) VALUES (1, 'compétence 1') ;
INSERT INTO COMPETENCE (id_competence, libelle_competence) VALUES (2, 'compétence 2') ;
INSERT INTO COMPETENCE (id_competence, libelle_competence) VALUES (3, 'compétence 3') ;
INSERT INTO COMPETENCE (id_competence, libelle_competence) VALUES (4, 'compétence 4') ;

SELECT *, '' AS '<= COMPETENCE' FROM COMPETENCE ;

(2) - On sait créer des fonctions :

 
INSERT INTO FONCTION (id_fonction, libelle_fonction) VALUES (1, 'fonction 1') ;
INSERT INTO FONCTION (id_fonction, libelle_fonction) VALUES (2, 'fonction 2') ;
INSERT INTO FONCTION (id_fonction, libelle_fonction) VALUES (3, 'fonction 3') ;

SELECT *, '' AS '<= FONCTION' FROM FONCTION ;

(3) - On sait créer des équipes :

 
INSERT INTO EQUIPE (id_equipe, nom_equipe, disponibilite) VALUES (1, 'equipe 1', 'dispo 1') ;
INSERT INTO EQUIPE (id_equipe, nom_equipe, disponibilite) VALUES (2, 'equipe 2', 'dispo 2') ;
INSERT INTO EQUIPE (id_equipe, nom_equipe, disponibilite) VALUES (3, 'equipe 3', 'dispo 3') ;

SELECT *, '' AS '<= EQUIPE' FROM EQUIPE ;

(4) - On sait ajouter des employés dans la table EMPLOYE :

 
INSERT INTO EMPLOYE (id_equipe, id_employe, matricule, nom_employe, prenom_employe, date_embauche, grade) 
    VALUES (1, 5, 'b04', 'Trancène', 'Jean', '2007-07-14', 'g01') ;
INSERT INTO EMPLOYE (id_equipe, id_employe, matricule, nom_employe, prenom_employe, date_embauche, grade) 
    VALUES (1, 6, 'b07', 'Bonneau', 'Jean', '2009-05-01', 'h02') ;
INSERT INTO EMPLOYE (id_equipe, id_employe, matricule, nom_employe, prenom_employe, date_embauche, grade) 
    VALUES (1, 7, 'b08', 'Ponce', 'Pierre', '2009-07-01', 'h02') ;
INSERT INTO EMPLOYE (id_equipe, id_employe, matricule, nom_employe, prenom_employe, date_embauche, grade) 
    VALUES (1, 8, 'c05', 'Titegoutte', 'Justine', '2009-09-01', 'g02') ;
INSERT INTO EMPLOYE (id_equipe, id_employe, matricule, nom_employe, prenom_employe, date_embauche, grade) 
    VALUES (1, 9, 'c06', 'Titegoutte', 'Corinne', '2009-09-02', 'g01') ;
INSERT INTO EMPLOYE (id_equipe, id_employe, matricule, nom_employe, prenom_employe, date_embauche, grade) 
    VALUES (1, 10, 'c07', 'Letracteur', 'Igor', '2010-01-01', 'g02') ;
INSERT INTO EMPLOYE (id_equipe, id_employe, matricule, nom_employe, prenom_employe, date_embauche, grade)
     VALUES (1, 11, 'c08', 'Letracteur', 'Hercule', '2010-01-01', 'g02') ;
INSERT INTO EMPLOYE (id_equipe, id_employe, matricule, nom_employe, prenom_employe, date_embauche, grade)
     VALUES (1, 12, 'c09', 'Hocquart de Tours', 'Adhémar', '2010-05-01', 'g01') ;
INSERT INTO EMPLOYE (id_equipe, id_employe, matricule, nom_employe, prenom_employe, date_embauche, grade) 
    VALUES (1, 13, 'd01', 'Surlessièges', 'Amedeus', '2010-05-02', 'g01') ;
INSERT INTO EMPLOYE (id_equipe, id_employe, matricule, nom_employe, prenom_employe, date_embauche, grade) 
    VALUES (1, 14, 'd02', 'Labarrière', 'Ildefonse', '2010-05-03', 'g01') ;
    
INSERT INTO EMPLOYE (id_equipe, id_employe, matricule, nom_employe, prenom_employe, date_embauche, grade) 
    VALUES (2, 21, 'e01', 'Mimolette', 'Franz', '2008-05-21', 'g02') ;
INSERT INTO EMPLOYE (id_equipe, id_employe, matricule, nom_employe, prenom_employe, date_embauche, grade) 
    VALUES (2, 22, 'e02', 'Jazz', 'Manu', '2008-05-22', 'g03') ;    
    
SELECT *, '' AS '<= EMPLOYE' FROM EMPLOYE ;

(5) - On sait définir les compétences des employés :

 
INSERT INTO COMPETENCE_EMPLOYE (id_equipe, id_employe, id_competence, niveau) SELECT
       (SELECT id_equipe FROM EMPLOYE WHERE matricule = 'b04')
     , (SELECT id_employe FROM EMPLOYE WHERE matricule = 'b04')
     , (SELECT id_competence FROM COMPETENCE WHERE libelle_competence = 'compétence 1'), 2 ;

INSERT INTO COMPETENCE_EMPLOYE (id_equipe, id_employe, id_competence, niveau) SELECT
       (SELECT id_equipe FROM EMPLOYE WHERE matricule = 'b04')
     , (SELECT id_employe FROM EMPLOYE WHERE matricule = 'b04')
     , (SELECT id_competence FROM COMPETENCE WHERE libelle_competence = 'compétence 2'), 2 ;     

INSERT INTO COMPETENCE_EMPLOYE (id_equipe, id_employe, id_competence, niveau) SELECT 
      (SELECT id_equipe FROM EMPLOYE WHERE matricule = 'b04')
     , (SELECT id_employe FROM EMPLOYE WHERE matricule = 'b04')
     , (SELECT id_competence FROM COMPETENCE WHERE libelle_competence = 'compétence 3'), 2 ;    
	
INSERT INTO COMPETENCE_EMPLOYE (id_equipe, id_employe, id_competence, niveau) SELECT 
      (SELECT id_equipe FROM EMPLOYE WHERE matricule = 'c05')
     , (SELECT id_employe FROM EMPLOYE WHERE matricule = 'c05')
     , (SELECT id_competence FROM COMPETENCE WHERE libelle_competence = 'compétence 1'), 2 ;
	
INSERT INTO COMPETENCE_EMPLOYE (id_equipe, id_employe, id_competence, niveau) SELECT 
       (SELECT id_equipe FROM EMPLOYE WHERE matricule = 'c05')
     , (SELECT id_employe FROM EMPLOYE WHERE matricule = 'c05')
     , (SELECT id_competence FROM COMPETENCE WHERE libelle_competence = 'compétence 3'), 2 ;
     
INSERT INTO COMPETENCE_EMPLOYE (id_equipe, id_employe, id_competence, niveau) SELECT 
       (SELECT id_equipe FROM EMPLOYE WHERE matricule = 'c06')
     , (SELECT id_employe FROM EMPLOYE WHERE matricule = 'c06')
     , (SELECT id_competence FROM COMPETENCE WHERE libelle_competence = 'compétence 1'), 3 ;     
     
INSERT INTO COMPETENCE_EMPLOYE (id_equipe, id_employe, id_competence, niveau) SELECT 
       (SELECT id_equipe FROM EMPLOYE WHERE matricule = 'c06')
     , (SELECT id_employe FROM EMPLOYE WHERE matricule = 'c06')
     , (SELECT id_competence FROM COMPETENCE WHERE libelle_competence = 'compétence 3'), 3 ;     
     
INSERT INTO COMPETENCE_EMPLOYE (id_equipe, id_employe, id_competence, niveau) SELECT 
       (SELECT id_equipe FROM EMPLOYE WHERE matricule = 'c06')
     , (SELECT id_employe FROM EMPLOYE WHERE matricule = 'c06')
     , (SELECT id_competence FROM COMPETENCE WHERE libelle_competence = 'compétence 4'), 2 ;     
     
INSERT INTO COMPETENCE_EMPLOYE (id_equipe, id_employe, id_competence, niveau) SELECT 
       (SELECT id_equipe FROM EMPLOYE WHERE matricule = 'c07')
     , (SELECT id_employe FROM EMPLOYE WHERE matricule = 'c07')
     , (SELECT id_competence FROM COMPETENCE WHERE libelle_competence = 'compétence 1'), 2 ;     
     
INSERT INTO COMPETENCE_EMPLOYE (id_equipe, id_employe, id_competence, niveau) SELECT 
       (SELECT id_equipe FROM EMPLOYE WHERE matricule = 'c07')
     , (SELECT id_employe FROM EMPLOYE WHERE matricule = 'c07')
     , (SELECT id_competence FROM COMPETENCE WHERE libelle_competence = 'compétence 2'), 1 ;  
          
INSERT INTO COMPETENCE_EMPLOYE (id_equipe, id_employe, id_competence, niveau) SELECT 
       (SELECT id_equipe FROM EMPLOYE WHERE matricule = 'c08')
     , (SELECT id_employe FROM EMPLOYE WHERE matricule = 'c08')
     , (SELECT id_competence FROM COMPETENCE WHERE libelle_competence = 'compétence 1'), 2 ;
     
INSERT INTO COMPETENCE_EMPLOYE (id_equipe, id_employe, id_competence, niveau) SELECT 
       (SELECT id_equipe FROM EMPLOYE WHERE matricule = 'c09')
     , (SELECT id_employe FROM EMPLOYE WHERE matricule = 'c09')
     , (SELECT id_competence FROM COMPETENCE WHERE libelle_competence = 'compétence 3'), 1 ;
    
INSERT INTO COMPETENCE_EMPLOYE (id_equipe, id_employe, id_competence, niveau) SELECT 
       (SELECT id_equipe FROM EMPLOYE WHERE matricule = 'd02')
     , (SELECT id_employe FROM EMPLOYE WHERE matricule = 'd02')
     , (SELECT id_competence FROM COMPETENCE WHERE libelle_competence = 'compétence 4'), 2 ;    
   
SELECT *, '' AS '<= COMPETENCE_EMPLOYE' FROM COMPETENCE_EMPLOYE ;

(6) - Nomination de Jean Trancène et Pierre Ponce comme chefs de projets (équipe 1), Franz Mimolette comme chef de projet (équipe 2) :

 
INSERT INTO CHEF_DE_PROJET (id_equipe, id_employe) 
    SELECT id_equipe, id_employe FROM EMPLOYE WHERE matricule = 'b04' ;
    
INSERT INTO CHEF_DE_PROJET (id_equipe, id_employe) 
    SELECT id_equipe, id_employe FROM EMPLOYE WHERE matricule = 'b08' ;
    
INSERT INTO CHEF_DE_PROJET (id_equipe, id_employe) 
    SELECT id_equipe, id_employe FROM EMPLOYE WHERE matricule = 'e01' ;
    
SELECT *, '' AS '<= CHEF_DE_PROJET' FROM CHEF_DE_PROJET ;

(7) - Créons les projets Aristote et Socrate (pour l'équipe 1), Platon (pour l'équipe 2) :

 
INSERT INTO PROJET (id_equipe, Id_projet, code_projet, id_employe_chef, nom_projet, date_debut_projet, duree_projet)
    SELECT (SELECT id_equipe FROM EQUIPE WHERE nom_equipe = 'equipe 1')
           , 1
           , 'ari'
           , (SELECT id_employe FROM EMPLOYE WHERE matricule = 'b04'), 'Aristote', '2015-04-02', 6               
    FROM   EQUIPE AS x
    WHERE nom_equipe = 'equipe 1'
;
INSERT INTO PROJET (id_equipe, Id_projet, code_projet, id_employe_chef, nom_projet, date_debut_projet, duree_projet)
    SELECT (SELECT id_equipe FROM EQUIPE WHERE nom_equipe = 'equipe 1')
           , 2
           , 'soc'
           , (SELECT id_employe FROM EMPLOYE WHERE matricule = 'b08'), 'Socrate', '2015-04-07', 12               
    FROM   EQUIPE AS x
    WHERE nom_equipe = 'equipe 1'
;
INSERT INTO PROJET (id_equipe, Id_projet, code_projet, id_employe_chef, nom_projet, date_debut_projet, duree_projet)
    SELECT (SELECT id_equipe FROM EQUIPE WHERE nom_equipe = 'equipe 2')
           , 1
           , 'pla'
           , (SELECT id_employe FROM EMPLOYE WHERE matricule = 'e01'), 'Platon', '2015-04-08', 8               
    FROM   EQUIPE AS x
    WHERE nom_equipe = 'equipe 2'
;

SELECT *, '' AS '<= PROJET' FROM PROJET ;

(8) - On sait définir les compétences requises pour les projets Aristote, Socrate et Platon :

 
INSERT INTO PROJET_COMPETENCE (id_equipe, id_projet, id_competence) SELECT
    (SELECT id_equipe FROM EQUIPE WHERE nom_equipe = 'equipe 1')   
  , (SELECT id_projet FROM PROJET WHERE code_projet = 'ari')
  , (SELECT id_competence FROM COMPETENCE WHERE libelle_competence = 'compétence 1') ;
  
INSERT INTO PROJET_COMPETENCE (id_equipe, id_projet, id_competence) SELECT 
    (SELECT id_equipe FROM EQUIPE WHERE nom_equipe = 'equipe 1')   
  , (SELECT id_projet FROM PROJET WHERE code_projet = 'ari')
  , (SELECT id_competence FROM COMPETENCE WHERE libelle_competence = 'compétence 3') ;

INSERT INTO PROJET_COMPETENCE (id_equipe, id_projet, id_competence) SELECT 
    (SELECT id_equipe FROM EQUIPE WHERE nom_equipe = 'equipe 1') 
  , (SELECT id_projet FROM PROJET WHERE code_projet = 'soc')
  , (SELECT id_competence FROM COMPETENCE WHERE libelle_competence = 'compétence 2') ;
  
INSERT INTO PROJET_COMPETENCE (id_equipe, id_projet, id_competence) SELECT 
    (SELECT id_equipe FROM EQUIPE WHERE nom_equipe = 'equipe 1'	) 
  , (SELECT id_projet FROM PROJET WHERE code_projet = 'soc')
  , (SELECT id_competence FROM COMPETENCE WHERE libelle_competence = 'compétence 4') ;
  
INSERT INTO PROJET_COMPETENCE (id_equipe, id_projet, id_competence) SELECT 
    (SELECT id_equipe FROM EQUIPE WHERE nom_equipe = 'equipe 2') 
  , (SELECT id_projet FROM PROJET WHERE code_projet = 'pla')
  , (SELECT id_competence FROM COMPETENCE WHERE libelle_competence = 'compétence 1') ;
  
INSERT INTO PROJET_COMPETENCE (id_equipe, id_projet, id_competence) SELECT 
    (SELECT id_equipe FROM EQUIPE WHERE nom_equipe = 'equipe 2') 
  , (SELECT id_projet FROM PROJET WHERE code_projet = 'pla')
  , (SELECT id_competence FROM COMPETENCE WHERE libelle_competence = 'compétence 4') ;
  
SELECT *, '' AS '<= PROJET_COMPETENCE' FROM PROJET_COMPETENCE order by 1, 2, 3 ;

(9) - On sait affecter les employés aux projets de leur équipe parce qu’ils ont les compétences requises :

 
INSERT INTO PROJET_COMPETENCE_EMPLOYE (id_equipe, id_projet, id_employe, id_competence) SELECT
    (SELECT id_equipe FROM EQUIPE WHERE nom_equipe = 'equipe 1')
  , (SELECT id_projet FROM PROJET WHERE code_projet = 'ari') 
  , (SELECT id_employe FROM EMPLOYE WHERE matricule = 'b07')
  , (SELECT id_competence FROM COMPETENCE WHERE libelle_competence = 'compétence 1') ;  
  
INSERT INTO PROJET_COMPETENCE_EMPLOYE (id_equipe, id_projet, id_employe, id_competence) SELECT
    (SELECT id_equipe FROM EQUIPE WHERE nom_equipe = 'equipe 1')
  , (SELECT id_projet FROM PROJET WHERE code_projet = 'ari') 
  , (SELECT id_employe FROM EMPLOYE WHERE matricule = 'b07')
  , (SELECT id_competence FROM COMPETENCE WHERE libelle_competence = 'compétence 3') ;    

INSERT INTO PROJET_COMPETENCE_EMPLOYE (id_equipe, id_projet, id_employe, id_competence) SELECT
    (SELECT id_equipe FROM EQUIPE WHERE nom_equipe = 'equipe 1')
  , (SELECT id_projet FROM PROJET WHERE code_projet = 'ari') 
  , (SELECT id_employe FROM EMPLOYE WHERE matricule = 'c05')
  , (SELECT id_competence FROM COMPETENCE WHERE libelle_competence = 'compétence 1') ;  
  
INSERT INTO PROJET_COMPETENCE_EMPLOYE (id_equipe, id_projet, id_employe, id_competence) SELECT
    (SELECT id_equipe FROM EQUIPE WHERE nom_equipe = 'equipe 1')
  , (SELECT id_projet FROM PROJET WHERE code_projet = 'ari') 
  , (SELECT id_employe FROM EMPLOYE WHERE matricule = 'c05')
  , (SELECT id_competence FROM COMPETENCE WHERE libelle_competence = 'compétence 3') ;  
  
SELECT *, '' AS '<= PROJET_COMPETENCE_EMPLOYE' FROM PROJET_COMPETENCE_EMPLOYE order by 1, 2, 3 ;

(10) - Pour savoir quels employés sont affectés aux projets de leur équipe :

 
SELECT DISTINCT id_equipe, id_projet, id_employe
FROM   PROJET_COMPETENCE_EMPLOYE ;

[fsmrel]

Bonsoir supras31,

c'est à dire un logiciel peut nécessiter une formation

un projet peut avoir au minimum une formation chez le client concerné par le projet

une équipe c'est la composition des employés qui participent dans ce projet donné donc il y avait la notion d'équipe qui est responsable de la création de ce projet et qui va assurer des formations au clients si le projet demande des formations et pour chacun des employé on note son rôle dans la formation.

Pourquoi ne pas considérer une formation comme une tâche particulière (spécialisation) ?

gestion des missions à l’étranger, si un projet nécessite une mission à l’étranger.

un projet peut demander ou pas une mission et donc qui sera réalisée par les membres de cette équipe responsable du projet
donc on notera pour les employés leur rôle dans la mission

Là encore, pourquoi ne pas considérer une mission comme une tâche particulière (spécialisation) ?



Le diagramme de classes pourrait alors ressembler à ceci :




Et le MLD à cela :

[supras31]

ce que je n'ai pas compris dans votre diagramme est ce que ça serait automatique l'affectation d'un employé à un projet ?
comment ça se fait l affectation
la logique me dit que on peut trouver des employés qu ont les compétences requises pr un projet mais ils ne seront pas pas affectés à ce projet car ils ne sont pas disponibles ou bien même 2 projets peuvent nécessiter les mêmes compétences alors dans ce cas on peut visualiser l employé sur l’écran mais l 'affecter seulement à 1 projet et pas aux 2 projets .
le processus d'affectation doit géré c'est avoir une liste des employés et puis effectuer une requête sql pour affecter l employé au projet