Features/update project team member

server/graphql/resolvers/projects/mutation/addProjectTeamMember.ts

@@ -19,55 +19,59 @@ const addProjectTeamMember = async (
   console.log("Mutation > addProjectTeamMember > args.request = ", args.request);
   const { memberID, roleID, projectID } = args.request;
 
-  if (!memberID && !roleID && !projectID)
-    throw new ApolloError("memberId, roleID and projectID are required");
-  //get the project and member
-  let [project, member] = await Promise.all([
-    Projects.findOne({ _id: projectID }) as Project,
-    Members.findOne({ _id: memberID }) as Member,
-  ]);
+  try {
+    if (!memberID && !roleID && !projectID)
+      throw new ApolloError("memberId, roleID and projectID are required");
+    //get the project and member
+    let [project, member] = await Promise.all([
+      Projects.findOne({ _id: projectID }) as Project,
+      Members.findOne({ _id: memberID }) as Member,
+    ]);
 
-  if (!project) throw new ApolloError("The project does not exist");
-  if (!member) throw new ApolloError("The member does not exist");
+    if (!project) throw new ApolloError("The project does not exist");
+    if (!member) throw new ApolloError("The member does not exist");
 
-  const projectRoles = project.roles as ProjectRole[];
-  //check if the roleID is included🌳
-  const role = projectRoles.find(role => role._id === roleID) as ProjectRole;
-  if (!role) throw new ApolloError("The role does not exist on the project");
+    const projectRoles = project.roles as ProjectRole[];
+    //check if the roleID is included🌳
+    const role = projectRoles.find(role => role._id === roleID) as ProjectRole;
+    if (!role) throw new ApolloError("The role does not exist on the project");
 
-  let teamMembers: any = project.teamMembers;
+    let teamMembers: any = project.teamMembers;
 
-  let newTeamMember = {
-    memberID: memberID,
-    roleID: roleID,
-    phase: PhaseProjectTeamMemberEnum.Committed,
-  };
+    let newTeamMember = {
+      memberID: memberID,
+      roleID: roleID,
+      phase: PhaseProjectTeamMemberEnum.Committed,
+    };
 
-  console.log("team members", teamMembers)
+    if (teamMembers?.length) {
+      //add the new team member
+      const alreadyExist = teamMembers.find((member: any) => member?.memberID === memberID);
+      if (!alreadyExist) teamMembers.push(newTeamMember);
+    } else {
+      teamMembers = [newTeamMember];
+    }
 
-  if (teamMembers?.length) {
-    //add the new team member
-    const alreadyExist = teamMembers.find((member: any) => member?.memberID === memberID);
-    if (!alreadyExist) teamMembers.push(newTeamMember);
-  } else {
-    teamMembers = [newTeamMember];
-  }
-
-  project = await Projects.findOneAndUpdate(
-    { _id: projectID },
-    {
-      $set: { teamMembers: teamMembers },
-    },
-    { new: true },
-  );
+    project = await Projects.findOneAndUpdate(
+      { _id: projectID },
+      {
+        $set: { teamMembers: teamMembers },
+      },
+      { new: true },
+    );
 
-  console.log("project details 🚚 ", project)
+    console.log("project details 🚚 ", project);
 
-  return {
-    info: member,
-    role: role,
-    phase: newTeamMember.phase,
-  };
+    return {
+      info: member,
+      role: role,
+      phase: newTeamMember.phase,
+    };
+  } catch (err: any) {
+    throw new ApolloError(err.message, err.extensions?.code || "addProjectTeamMember", {
+      component: "ProjectMutation > addProjectTeamMember",
+    });
+  }
 };
 
 export default addProjectTeamMember;

server/graphql/resolvers/projects/mutation/deleteProjectTeamMember.ts

@@ -0,0 +1,66 @@
+import { Projects } from "../../../../models/projectModel";
+import { Members } from "../../../../models/memberModel";
+import {
+  Project,
+  ProjectTeamMember,
+  ProjectRole,
+  Member,
+  DeleteProjectTeamMemberInput,
+} from "../../../../generated";
+import { ApolloError } from "apollo-server-express";
+
+const deleteProjectTeamMember = async (
+  parent: any,
+  args: { request: DeleteProjectTeamMemberInput },
+  context: any,
+  info: any,
+): Promise<ProjectTeamMember> => {
+  try {
+    const { memberID, projectID, roleID } = args.request;
+    console.log("Mutation > deleteProjectTeamMember > args.request = ", args.request);
+    //get the project
+    let [project, member] = await Promise.all([
+      Projects.findOne({ _id: projectID }) as Project,
+      Members.findOne({ _id: memberID }) as Member,
+    ]);
+
+    if (!project) throw new ApolloError("The project does not exist");
+    if (!member) throw new ApolloError("The member does not exist");
+
+    const teamMember: any = project.teamMembers?.find(
+      (member: any) => member.memberID === memberID,
+    );
+    if (!teamMember) throw new ApolloError("Team member does not exist");
+
+    const projectRoles = project.roles as ProjectRole[];
+
+    const role = projectRoles.find(role => role._id === roleID) as ProjectRole;
+    if (!role) throw new ApolloError("The role does not exist on the project");
+    //remove the team member
+    const remainTeamMembers: any = project.teamMembers?.find(
+      (member: any) => member.memberID !== memberID,
+    );
+
+    project = await Projects.findOneAndUpdate(
+      {
+        _id: projectID,
+      },
+      { $set: { teamMembers: remainTeamMembers } },
+
+      { new: true },
+    );
+
+    console.log("project", project);
+    return {
+      info: member,
+      role: role,
+      phase: teamMember.phase,
+    };
+  } catch (err: any) {
+    throw new ApolloError(err.message, err.extensions?.code || "deleteProjectTeamMember", {
+      component: "ProjectMutation > deleteProjectTeamMember",
+    });
+  }
+};
+
+export default deleteProjectTeamMember;

server/graphql/resolvers/projects/mutation/index.ts

@@ -4,6 +4,9 @@ import addProjectRole from "./addProjectRole";
 import updateProjectRole from "./updateProjectRole";
 import deleteProjectRole from "./deleteProjectRole"
 import addProjectTeamMember from "./addProjectTeamMember";
+import updateProjectTeamMember from "./updateProjectTeamMember";
+import deleteProjectTeamMember from "./deleteProjectTeamMember";
+
 
 
 export default {
@@ -12,5 +15,7 @@ export default {
     addProjectRole,
     updateProjectRole,
     deleteProjectRole,
-    addProjectTeamMember
+    addProjectTeamMember,
+    updateProjectTeamMember,
+    deleteProjectTeamMember
 }

server/graphql/resolvers/projects/mutation/updateProjectTeamMember.ts

@@ -0,0 +1,80 @@
+import { Projects } from "../../../../models/projectModel";
+import { Members } from "../../../../models/memberModel";
+import {
+  Project,
+  ProjectTeamMember,
+  ProjectRole,
+  Member,
+  UpdateProjectTeamMemberInput,
+} from "../../../../generated";
+import { ApolloError } from "apollo-server-express";
+
+const updateProjectTeamMember = async (
+  parent: any,
+  args: { request: UpdateProjectTeamMemberInput },
+  context: any,
+  info: any,
+): Promise<ProjectTeamMember> => {
+  const { memberID, projectID, phase, roleID } = args.request;
+  console.log("Mutation > updateProjectTeamMember > args.request = ", args.request);
+
+  if (!projectID && !memberID && !roleID)
+    throw new ApolloError("The projectID, roleID and memberID is required");
+
+  if (!phase) throw new ApolloError("The phase is required");
+
+  try {
+    let [project, member] = await Promise.all([
+      Projects.findOne({ _id: projectID }) as Project,
+      Members.findOne({ _id: memberID }) as Member,
+    ]);
+
+    if (!project) throw new ApolloError("The project does not exist");
+    if (!member) throw new ApolloError("The member does not exist");
+
+    const projectRoles = project.roles as ProjectRole[];
+
+    const role = projectRoles.find(role => role._id === roleID) as ProjectRole;
+    if (!role) throw new ApolloError("The role does not exist on the project");
+
+    //find the member in the teamMembers array
+    let teamMembers: any = project.teamMembers;
+    const teamMemberToEdit = teamMembers?.find((member: any) => member.memberID === memberID);
+
+    if (!teamMemberToEdit) throw new ApolloError("The member does not exist in the project team");
+
+    //update the fields
+    teamMemberToEdit.roleID = roleID;
+    if (phase) {
+      teamMemberToEdit.phase = phase;
+    }
+
+    const remainTeamMembers = teamMembers.filter((member: any) => member.memberID !== memberID);
+
+    remainTeamMembers.push(teamMemberToEdit);
+
+    //save the edit to the 🇩B
+
+    project = await Projects.findOneAndUpdate(
+      {
+        _id: projectID,
+      },
+      { $set: { teamMembers: remainTeamMembers } },
+
+      { new: true },
+    );
+
+    console.log("project", project);
+    return {
+      info: member,
+      role: role,
+      phase: phase,
+    };
+  } catch (err: any) {
+    throw new ApolloError(err.message, err.extensions?.code || "updateProjectTeamMember", {
+      component: "ProjectMutation > updateProjectTeamMember",
+    });
+  }
+};
+
+export default updateProjectTeamMember;