Features/delete skill and sub skill category

server/generated/graphqlEden.ts

@@ -141,6 +141,7 @@ export type Mutation = {
   createRoom?: Maybe<Room>;
   deleteProjectRole?: Maybe<ProjectRole>;
   deleteProjectTeamMember?: Maybe<ProjectTeamMember>;
+  deleteSkillCategory?: Maybe<Scalars['String']>;
   deleteSkillsFromMember?: Maybe<Member>;
   enterRoom?: Maybe<Room>;
   exitRoom?: Maybe<Room>;
@@ -218,6 +219,11 @@ export type MutationDeleteProjectTeamMemberArgs = {
 };
 
 
+export type MutationDeleteSkillCategoryArgs = {
+  request?: InputMaybe<DeleteSkillCategoryInput>;
+};
+
+
 export type MutationDeleteSkillsFromMemberArgs = {
   request?: InputMaybe<DeleteSkillsFromMemberInput>;
 };
@@ -770,6 +776,16 @@ export type DeleteProjectTeamMemberInput = {
   roleID: Scalars['ID'];
 };
 
+export type DeleteSkillCategoryInput = {
+  _id?: InputMaybe<Array<InputMaybe<Scalars['ID']>>>;
+  lightcastID?: InputMaybe<Array<InputMaybe<Scalars['ID']>>>;
+};
+
+export type DeleteSkillSubCategoryInput = {
+  _id?: InputMaybe<Array<InputMaybe<Scalars['ID']>>>;
+  lightcastID?: InputMaybe<Array<InputMaybe<Scalars['ID']>>>;
+};
+
 export type EnterExitRoomInput = {
   memberID?: InputMaybe<Scalars['ID']>;
   roomID?: InputMaybe<Scalars['ID']>;

server/graphql/resolvers/skillCategory/mutation/deleteSkillCategory.ts

@@ -0,0 +1,93 @@
+import { SkillCategory } from "../../../../models/skillCategoryModel";
+import { SkillSubCategory } from "../../../../models/skillSubCategoryModel";
+import { Skills } from "../../../../models/skillModel";
+import {
+  DeleteSkillCategoryInput,
+  SkillCategory as SkillCategoryType,
+} from "../../../../generated";
+import { ApolloError } from "apollo-server-express";
+
+const deleteSkillCategory = async (
+  parent: any,
+  args: { request: DeleteSkillCategoryInput },
+  context: any,
+  info: any,
+) => {
+  const { _id, lightcastID } = args.request;
+
+  if (!_id || lightcastID) {
+    throw new ApolloError("Please provide an _id or a lightcastID for the skillcategory to delete");
+  }
+
+  let toDeleteCategory = {};
+
+  if (_id) {
+    toDeleteCategory = { _id: _id };
+  } else {
+    toDeleteCategory = { lightcastID: lightcastID };
+  }
+
+  try {
+    //find the skillcategory models
+    const skillsCategory: SkillCategoryType[] = await SkillCategory.find(toDeleteCategory);
+    let documentDeleted = 0;
+    if (skillsCategory.length) {
+      for (let i = 0; i < skillsCategory.length; i++) {
+        const skillCategoryToDelete: SkillCategoryType = skillsCategory[i];
+        let skill = await Skills.findOne({ skillCategoriesID: skillCategoryToDelete._id });
+
+        if (skill) {
+          let filteredskill: any = skill.skillCategoriesID?.filter((skill: any) => {
+            return skill != skillCategoryToDelete._id;
+          });
+
+          await Skills.findOneAndUpdate(
+            {
+              _id: skill._id,
+            },
+
+            {
+              $set: {
+                skillCategoriesID: filteredskill,
+              },
+            },
+          );
+        }
+
+        let skillsubCategory = await SkillSubCategory.findOne({
+          categorySkills: skillCategoryToDelete._id,
+        });
+
+        if (skillsubCategory) {
+          let filteredsubCategory = skillsubCategory.categorySkills?.filter((subCategory: any) => {
+            return subCategory != skillCategoryToDelete._id;
+          });
+
+          await SkillSubCategory.findOneAndUpdate(
+            {
+              _id: skillsubCategory._id,
+            },
+
+            {
+              $set: {
+                categorySkills: filteredsubCategory,
+              },
+            },
+          );
+        }
+
+        await SkillCategory.deleteOne({ _id: skillCategoryToDelete._id });
+        documentDeleted++;
+      }
+    } else {
+      throw new ApolloError("No data matches the passed parameter");
+    }
+    return documentDeleted;
+  } catch (err: any) {
+    throw new ApolloError(err.message, err.extensions?.code || "deleteSkillCategory", {
+      component: "skillCategoryMutation > deleteSkillCategory",
+    });
+  }
+};
+
+export default deleteSkillCategory;

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

@@ -1,6 +1,8 @@
 import updateSkillCategory from "./updateSkillCategory";
+import deleteSkillCategory from "./deleteSkillCategory";
 
 
 export default {
-    updateSkillCategory
+    updateSkillCategory,
+    deleteSkillCategory
 }

server/graphql/resolvers/skillCategory/mutation/updateSkillCategory.ts

@@ -59,8 +59,8 @@ const updateSkillCategory = async (
     console.log("skillcategory data", skillCategoryData)
     return skillCategoryData;
   } catch (err: any) {
-    throw new ApolloError(err.message, err.extensions?.code || "DATABASE_FIND_TWEET_ERROR", {
-      component: "tSkillCategoryMutation > updateSkillCategory",
+    throw new ApolloError(err.message, err.extensions?.code || "updateSkillCategory", {
+      component: "SkillCategoryMutation > updateSkillCategory",
     });
   }
 };

server/graphql/resolvers/skillCategory/objectResolvers/skillSubCategories.ts

@@ -11,8 +11,8 @@ const skillSubCategories = async (parent: SkillCategory, args: any, context: any
 
     return SkillSubCategoryData;
   } catch (err: any) {
-    throw new ApolloError(err.message, err.extensions?.code || "DATABASE_SEARCH_ERROR", {
-      component: "skillSubCategoryResolver > skillsubCategories",
+    throw new ApolloError(err.message, err.extensions?.code || "skillsubCategories", {
+      component: "SkillCategoryResolver > skillsubCategories",
       user: context.req.user?._id,
     });
   }

server/graphql/resolvers/skillCategory/objectResolvers/skills.ts

@@ -14,8 +14,8 @@ const skills = async (
 
     return skillData;
   } catch (err: any) {
-    throw new ApolloError(err.message, err.extensions?.code || "DATABASE_SEARCH_ERROR", {
-      component: "skillCategoryResolver > skills",
+    throw new ApolloError(err.message, err.extensions?.code || "skills", {
+      component: "SkillCategoryResolver > skills",
       user: context.req.user?._id,
     });
   }

server/graphql/resolvers/skillCategory/query/findSkillCategory.ts

@@ -22,16 +22,16 @@ const findSkillCategories = async (
   } else if (lightcastID) {
     searchQuery = { lightcastID: lightcastID };
   } else {
-    throw new ApolloError("You need to specify the _id or lightcastID of the skill category");
+    searchQuery = {}
   }
 
   try {
     let skillCategoryData = await SkillCategory.find(searchQuery);
 
     return skillCategoryData;
   } catch (err: any) {
-    throw new ApolloError(err.message, err.extensions?.code || "DATABASE_FIND_TWEET_ERROR", {
-      component: "tskillCategoryQuery > findSkillCategory",
+    throw new ApolloError(err.message, err.extensions?.code || "findSkillCategory", {
+      component: "skillCategoryQuery > findSkillCategory",
     });
   }
 };

server/graphql/resolvers/skillSubCategory/mutation/deleteSkillSubCategory.ts

@@ -0,0 +1,90 @@
+import { SkillSubCategory } from "../../../../models/skillSubCategoryModel";
+import { SkillCategory } from "../../../../models/skillCategoryModel";
+import { Skills } from "../../../../models/skillModel";
+import {
+  DeleteSkillSubCategoryInput,
+  SkillSubCategory as SkillSubCategoryType,
+} from "../../../../generated";
+import { ApolloError } from "apollo-server-express";
+
+const deleteSkillSubCategory = async (
+  parent: any,
+  args: { request: DeleteSkillSubCategoryInput },
+  context: any,
+  info: any,
+) => {
+  const { _id, lightcastID } = args.request;
+  if (!_id || lightcastID) {
+    throw new ApolloError(
+      "Please provide an _id or a lightcastID for the Skillsubcategory to delete",
+    );
+  }
+
+  let toDeleteCategory = {};
+
+  if (_id) {
+    toDeleteCategory = { _id: _id };
+  } else {
+    toDeleteCategory = { lightcastID: lightcastID };
+  }
+
+  try {
+    //find the skillcategory models
+    const skillSubCategory: SkillSubCategoryType[] = await SkillSubCategory.find(toDeleteCategory);
+    let documentDeleted = 0;
+    if (skillSubCategory.length) {
+      for (let i = 0; i < skillSubCategory.length; i++) {
+        const skillSubCategoryToDelete: SkillSubCategoryType = skillSubCategory[i];
+        let skill = await Skills.findOne({ skillSubCategoriesID: skillSubCategoryToDelete._id });
+
+        if (skill) {
+          let filteredskill: any = skill.skillCategoriesID?.filter((skill: any) => {
+            return skill != skillSubCategoryToDelete._id;
+          });
+
+          await Skills.findOneAndUpdate(
+            {
+              _id: skill._id,
+            },
+
+            {
+              $set: {
+                skillSubCategoriesID: filteredskill,
+              },
+            },
+          );
+        }
+
+        let skillCategory = await SkillCategory.findOne({
+          skillSubCategories: skillSubCategoryToDelete._id,
+        });
+
+        if (skillCategory) {
+          let filteredCategory = skillCategory.skillSubCategories?.filter((subCategory: any) => {
+            return subCategory != skillSubCategoryToDelete._id;
+          });
+
+          await SkillCategory.findOneAndUpdate(
+            {
+              _id: skillCategory._id,
+            },
+
+            {
+              $set: {
+                skillSubCategories: filteredCategory,
+              },
+            },
+          );
+        }
+        await SkillSubCategory.deleteOne({ _id: skillSubCategoryToDelete._id });
+        documentDeleted++;
+      }
+    } else {
+      throw new ApolloError("No data matches the passed parameter");
+    }
+
+    return documentDeleted;
+  } catch (err: any) {}
+};
+
+export default deleteSkillSubCategory;

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

@@ -1,6 +1,8 @@
 import updateSkillSubCategory from "./updateSkillSubCategory";
+import deleteSkillSubCategory from "./deleteSkillSubCategory";
 
 
 export default {
-    updateSkillSubCategory
+    updateSkillSubCategory,
+    deleteSkillSubCategory
 }

server/graphql/resolvers/skillSubCategory/mutation/updateSkillSubCategory.ts

@@ -55,8 +55,8 @@ import {
 
       return skillSubCategoryData;
     } catch (err: any) {
-      throw new ApolloError(err.message, err.extensions?.code || "DATABASE_FIND_TWEET_ERROR", {
-        component: "tmemberSkillSubCategory > updateSkillSubCategory",
+      throw new ApolloError(err.message, err.extensions?.code || "updateSkillSubCategory", {
+        component: "SkillSubCategoryMutation > updateSkillSubCategory",
       });
     }
   };

server/graphql/resolvers/skillSubCategory/objectResolvers/categorySkills.ts

@@ -15,7 +15,7 @@ const categorySkills = async (
 
     return categoryData;
   } catch (err: any) {
-    throw new ApolloError(err.message, err.extensions?.code || "DATABASE_SEARCH_ERROR", {
+    throw new ApolloError(err.message, err.extensions?.code || "categorySkills", {
       component: "skillSubCategoryResolver > categorySkills",
       user: context.req.user?._id,
     });

server/graphql/resolvers/skillSubCategory/objectResolvers/skills.ts

@@ -15,7 +15,7 @@ const skills = async (
 
     return skillData;
   } catch (err: any) {
-    throw new ApolloError(err.message, err.extensions?.code || "DATABASE_SEARCH_ERROR", {
+    throw new ApolloError(err.message, err.extensions?.code || "skills", {
       component: "skillSubCategoryResolver > skills",
       user: context.req.user?._id,
     });

server/graphql/resolvers/skillSubCategory/query/findSkillSubCategories.ts

@@ -29,8 +29,8 @@ const findSkillSubCategories = async (
     skillSubCategoryData = await SkillSubCategory.find(searchQuery);
     return skillSubCategoryData;
   } catch (err: any) {
-    throw new ApolloError(err.message, err.extensions?.code || "DATABASE_FIND_TWEET_ERROR", {
-      component: "tmemberQuery > findSkillSubCategories",
+    throw new ApolloError(err.message, err.extensions?.code || "findSkillSubCategories", {
+      component: "SkillSubQuery > findSkillSubCategories",
     });
   }
 };

server/graphql/resolvers/skills/mutation/addRelatedSkills.ts

@@ -19,15 +19,13 @@ const addRelatedSkills = async (
 
   skillData = await Skills.findOne({ _id: skillID });
 
-
   relatedSkillsData = await Skills.find({ _id: relatedSkillIDs });
 
   console.log("relatedSkilldata", relatedSkillsData);
   let result;
 
   try {
     for (let i = 0; i < relatedSkillsData.length; i++) {
-
       const skillsArrayToSaveRelatedSkills = skillData.relatedSkills ? skillData.relatedSkills : [];
       const currentRelatedSkill = relatedSkillsData[i];
 
@@ -44,10 +42,12 @@ const addRelatedSkills = async (
         },
         { new: true },
       );
-
-      const relatedSkilledArray = relatedSkillsData[i].relatedSkills ? relatedSkillsData[i].relatedSkills: <any>[];
+
+      const relatedSkilledArray = relatedSkillsData[i].relatedSkills
+        ? relatedSkillsData[i].relatedSkills
+        : <any>[];
       if (!relatedSkilledArray.includes(skillData._id as Skill)) {
-         relatedSkilledArray.push(skillData._id);
+        relatedSkilledArray.push(skillData._id);
       }
 
       await Skills.findOneAndUpdate(
@@ -60,13 +60,13 @@ const addRelatedSkills = async (
         { new: true },
       );
     }
+    console.log("skillData ", skillData);
+    return skillData;
   } catch (err: any) {
-    throw new ApolloError(err.message, err.extensions?.code || "DATABASE_FIND_TWEET_ERROR", {
-      component: "tSkillMutation > addRelatedSkills",
+    throw new ApolloError(err.message, err.extensions?.code || "addRelatedSkills", {
+      component: "SkillMutation > addRelatedSkills",
     });
   }
-  console.log("skillData ", skillData);
-  return skillData;
 };
 
 export default addRelatedSkills;