feat: review admin teams views for importance inclusion

components/admin/team-detail/team-detail-client-wrapper.tsx

@@ -15,6 +15,7 @@ interface TeamDetailClientWrapperProps {
 interface SkillAnalysis {
   skillName: string;
   category: string;
+  importance: "incontournable" | "majeure" | "standard";
   experts: Array<{
     name: string;
     level: number;
@@ -29,14 +30,27 @@ interface SkillAnalysis {
   expertCount: number;
   learnerCount: number;
   proficiencyRate: number;
+  coverage: number;
 }
 
 interface TeamInsights {
   averageTeamLevel: number;
   totalExperts: number;
   totalLearners: number;
-  skillGaps: number;
-  strongSkills: number;
+  skillGaps: {
+    incontournable: number;
+    majeure: number;
+    standard: number;
+  };
+  strongSkills: {
+    incontournable: number;
+    majeure: number;
+    standard: number;
+  };
+  criticalSkillsCoverage: {
+    incontournable: number;
+    majeure: number;
+  };
 }
 
 export function TeamDetailClientWrapper({
@@ -51,16 +65,24 @@ export function TeamDetailClientWrapper({
     // Analyser les compétences avec les vraies données
     const skillMap = new Map<string, any>();
 
+    // Créer un Map pour stocker les infos d'importance des skills
+    const skillImportanceMap = new Map<string, string>();
+    team.topSkills.forEach((skill) => {
+      skillImportanceMap.set(skill.skillName, skill.importance);
+    });
+
     team.members.forEach((member) => {
       member.skills.forEach((skill) => {
         if (!skillMap.has(skill.skillName)) {
           skillMap.set(skill.skillName, {
             skillName: skill.skillName,
             category: skill.category,
+            importance: skillImportanceMap.get(skill.skillName) || "standard",
             experts: [],
             learners: [],
             averageLevel: 0,
             totalEvaluations: 0,
+            coverage: 0,
           });
         }
 
@@ -94,9 +116,19 @@ export function TeamDetailClientWrapper({
           learnerCount: skill.learners.length,
           proficiencyRate:
             (skill.experts.length / skill.totalEvaluations) * 100,
+          coverage: (skill.experts.length / team.totalMembers) * 100,
         })
       )
-      .sort((a, b) => b.averageLevel - a.averageLevel);
+      .sort((a, b) => {
+        // D'abord par importance
+        const importanceOrder = { incontournable: 2, majeure: 1, standard: 0 };
+        const importanceDiff =
+          importanceOrder[b.importance] - importanceOrder[a.importance];
+        if (importanceDiff !== 0) return importanceDiff;
+
+        // Ensuite par niveau moyen
+        return b.averageLevel - a.averageLevel;
+      });
 
     setSkillAnalysis(skills);
   }, [team]);
@@ -151,8 +183,29 @@ export function TeamDetailClientWrapper({
       (sum, member) => sum + member.skills.filter((s) => s.wantsToLearn).length,
       0
     ),
-    skillGaps: skillAnalysis.filter((s) => s.averageLevel < 1.5).length,
-    strongSkills: skillAnalysis.filter((s) => s.averageLevel >= 2.5).length,
+    skillGaps: {
+      incontournable: skillAnalysis.filter(
+        (s) => s.importance === "incontournable" && s.coverage < 75
+      ).length,
+      majeure: skillAnalysis.filter(
+        (s) => s.importance === "majeure" && s.coverage < 60
+      ).length,
+      standard: skillAnalysis.filter(
+        (s) => s.importance === "standard" && s.averageLevel < 1.5
+      ).length,
+    },
+    strongSkills: {
+      incontournable: skillAnalysis.filter(
+        (s) => s.importance === "incontournable" && s.coverage >= 75
+      ).length,
+      majeure: skillAnalysis.filter(
+        (s) => s.importance === "majeure" && s.coverage >= 60
+      ).length,
+      standard: skillAnalysis.filter(
+        (s) => s.importance === "standard" && s.averageLevel >= 2.5
+      ).length,
+    },
+    criticalSkillsCoverage: team.criticalSkillsCoverage,
   };
 
   return (