catchup-library-web 1.0.0 → 1.0.2

package/src/utilization/CatchtivityUtilization.ts

@@ -0,0 +1,1566 @@
+import i18n from "../language/i18n";
+
+export const retrieveColorByScore = (score: number) => {
+  if (score <= 25) {
+    return "#F96666";
+  } else if (score > 25 && score <= 50) {
+    return "#f98d66";
+  } else if (score > 50 && score <= 75) {
+    return "#cbd357";
+  } else {
+    return "#ABD357";
+  }
+};
+
+export const retrieveContentTypeOptionList = (textOnly: boolean) => {
+  if (textOnly) {
+    return [
+      {
+        id: "TEXT",
+        value: "TEXT",
+        text: i18n.t("TEXT"),
+        icon: "/icons/text-gray.png",
+      },
+    ];
+  } else {
+    return [
+      {
+        id: "TEXT",
+        value: "TEXT",
+        text: i18n.t("TEXT"),
+        icon: "/icons/text-gray.png",
+      },
+      {
+        id: "IMAGE",
+        value: "IMAGE",
+        text: i18n.t("IMAGE"),
+        icon: "/icons/image-gray.png",
+      },
+      {
+        id: "VIDEO",
+        value: "VIDEO",
+        text: i18n.t("VIDEO"),
+        icon: "/icons/video-gray.png",
+      },
+      {
+        id: "AUDIO",
+        value: "AUDIO",
+        text: i18n.t("AUDIO"),
+        icon: "/icons/audio-gray.png",
+      },
+    ];
+  }
+};
+
+export const retrieveStatusOptionList = () => {
+  return [
+    {
+      value: "ACTIVE",
+      text: i18n.t("ACTIVE"),
+    },
+    {
+      value: "PASSIVE",
+      text: i18n.t("PASSIVE"),
+    },
+  ];
+};
+
+export const retrieveDurationTypeOptionList = () => {
+  return [
+    { value: "NONE", text: i18n.t("NONE") },
+    { value: "ALL", text: i18n.t("ALL") },
+    { value: "EACH", text: i18n.t("EACH") },
+  ];
+};
+
+export const retrieveDurationInMinutesOptionList = (durationType: string) => {
+  if (durationType === "ALL") {
+    return [
+      { value: 15, text: 15 },
+      { value: 30, text: 30 },
+      { value: 45, text: 45 },
+      { value: 60, text: 60 },
+      { value: 75, text: 75 },
+      { value: 90, text: 90 },
+      { value: 105, text: 105 },
+      { value: 120, text: 120 },
+    ];
+  } else if (durationType === "EACH") {
+    return [
+      { value: 1, text: 1 },
+      { value: 2, text: 2 },
+      { value: 3, text: 3 },
+      { value: 5, text: 5 },
+      { value: 10, text: 10 },
+    ];
+  }
+  return [];
+};
+
+export const retrieveDurationInSecondsOptionList = () => {
+  return [
+    { value: 15, text: `15 ${i18n.t("seconds")}` },
+    { value: 20, text: `20 ${i18n.t("seconds")}` },
+    { value: 25, text: `25 ${i18n.t("seconds")}` },
+    { value: 30, text: `30 ${i18n.t("seconds")}` },
+    { value: 35, text: `35 ${i18n.t("seconds")}` },
+    { value: 40, text: `40 ${i18n.t("seconds")}` },
+    { value: 45, text: `45 ${i18n.t("seconds")}` },
+  ];
+};
+
+export const retrieveTaxonomyType = () => {
+  return [
+    {
+      value: "BLOOM",
+      text: i18n.t("BLOOM"),
+    },
+  ];
+};
+
+export const retrieveTaxonomyGroupName = () => {
+  return [
+    {
+      type: "BLOOM",
+      value: "BLOOM",
+      text: i18n.t("BLOOM"),
+    },
+  ];
+};
+
+export const retrieveTaxonomyName = () => {
+  return [
+    {
+      stage: 1,
+      groupName: "BLOOM",
+      value: "REMEMBER",
+      text: i18n.t("REMEMBER"),
+    },
+    {
+      stage: 2,
+      groupName: "BLOOM",
+      value: "UNDERSTAND",
+      text: i18n.t("UNDERSTAND"),
+    },
+    {
+      stage: 3,
+      groupName: "BLOOM",
+      value: "APPLY",
+      text: i18n.t("APPLY"),
+    },
+    {
+      stage: 4,
+      groupName: "BLOOM",
+      value: "ANALYZE",
+      text: i18n.t("ANALYZE"),
+    },
+    {
+      stage: 5,
+      groupName: "BLOOM",
+      value: "EVALUATE",
+      text: i18n.t("EVALUATE"),
+    },
+    {
+      stage: 6,
+      groupName: "BLOOM",
+      value: "CREATE",
+      text: i18n.t("CREATE"),
+    },
+  ];
+};
+
+export const constructInputWithSpecialExpressionList = (inputText: string) => {
+  const inputPartList = [];
+  if (!inputText) return [];
+  const splittedBold = inputText.split("**");
+  let isBold = false;
+  for (let i = 0; i < splittedBold.length; i++) {
+    let isUnderline = false;
+    const splittedUnderline = splittedBold[i].split("__");
+    for (let j = 0; j < splittedUnderline.length; j++) {
+      let isEquation = false;
+      const splittedEquation = splittedUnderline[j].split("`");
+      for (let k = 0; k < splittedEquation.length; k++) {
+        inputPartList.push({
+          value: splittedEquation[k],
+          isEquation,
+          isUnderline,
+          isBold,
+        });
+        isEquation = !isEquation;
+      }
+      isUnderline = !isUnderline;
+    }
+    isBold = !isBold;
+  }
+  return inputPartList;
+};
+
+export const retrieveStandardExamTypeOptionList = () => {
+  return [
+    { value: "AYT", text: "AYT" },
+    { value: "TYT", text: "TYT" },
+    { value: "LGS", text: "LGS" },
+  ];
+};
+
+export const retrieveStandardExamTypeIcon = (baseReportType: string) => {
+  if (baseReportType === "TYT") {
+    return "/icons/tyt.png";
+  } else if (baseReportType === "AYT") {
+    return "/icons/ayt.png";
+  } else if (baseReportType === "LGS") {
+    return "/icons/lgs.png";
+  }
+};
+
+export const retrieveCoterieTypeFromStandardExamCoterieType = (
+  standardExamType: string,
+  standardExamCoterieType: string
+) => {
+  if (standardExamCoterieType === "TURKISH") {
+    return "TURKISH";
+  } else if (standardExamCoterieType === "SCIENCE") {
+    return "SCIENCE";
+  } else if (
+    (standardExamType === "TYT" || standardExamType === "AYT") &&
+    standardExamCoterieType === "PHYSICS"
+  ) {
+    return "PHYSICS";
+  } else if (
+    standardExamType === "LGS" &&
+    standardExamCoterieType === "PHYSICS"
+  ) {
+    return "SOCIAL_STUDIES";
+  } else if (
+    (standardExamType === "TYT" || standardExamType === "AYT") &&
+    standardExamCoterieType === "CHEMISTRY"
+  ) {
+    return "CHEMISTRY";
+  } else if (
+    standardExamType === "LGS" &&
+    standardExamCoterieType === "CHEMISTRY"
+  ) {
+    return "SOCIAL_STUDIES";
+  } else if (
+    (standardExamType === "TYT" || standardExamType === "AYT") &&
+    standardExamCoterieType === "BIOLOGY"
+  ) {
+    return "BIOLOGY";
+  } else if (
+    standardExamType === "LGS" &&
+    standardExamCoterieType === "BIOLOGY"
+  ) {
+    return "SOCIAL_STUDIES";
+  } else if (
+    (standardExamType === "TYT" || standardExamType === "AYT") &&
+    standardExamCoterieType === "HISTORY"
+  ) {
+    return "HISTORY";
+  } else if (
+    (standardExamType === "TYT" || standardExamType === "AYT") &&
+    standardExamCoterieType === "GEOGRAPHY"
+  ) {
+    return "GEOGRAPHY";
+  } else if (
+    (standardExamType === "LGS" && standardExamCoterieType === "HISTORY") ||
+    (standardExamType === "LGS" && standardExamCoterieType === "GEOGRAPHY") ||
+    standardExamCoterieType === "REVOLUTION_HISTORY"
+  ) {
+    return "SOCIAL_STUDIES";
+  } else if (
+    standardExamCoterieType === "HISTORY_I" ||
+    standardExamCoterieType === "HISTORY_II"
+  ) {
+    return "HISTORY";
+  } else if (
+    standardExamCoterieType === "GEOGRAPHY_I" ||
+    standardExamCoterieType === "GEOGRAPHY_II"
+  ) {
+    return "GEOGRAPHY";
+  } else if (
+    standardExamCoterieType === "MATHEMATICS" ||
+    standardExamCoterieType === "GEOMETRY"
+  ) {
+    return "MATHEMATICS";
+  } else if (
+    standardExamCoterieType === "PHILOSOPHY" ||
+    standardExamCoterieType === "PHILOSOPHY_OR_CULTURE_AND_RELIGION_KNOWLEDGE"
+  ) {
+    return "PHILOSOPHY";
+  } else if (
+    (standardExamType === "TYT" || standardExamType === "AYT") &&
+    standardExamCoterieType === "CULTURE_AND_RELIGION_KNOWLEDGE"
+  ) {
+    return "CULTURE_AND_RELIGION_KNOWLEDGE";
+  } else if (
+    standardExamType === "LGS" &&
+    standardExamCoterieType === "CULTURE_AND_RELIGION_KNOWLEDGE"
+  ) {
+    return "CULTURE_AND_RELIGION_KNOWLEDGE";
+  } else if (standardExamCoterieType === "ENGLISH") {
+    return "ENGLISH";
+  } else if (standardExamCoterieType === "LITERATURE") {
+    return "LITERATURE";
+  }
+};
+
+export const retrieveStandardExamCoterieTypeOptionListByStandardExamType = (
+  standardExamType: string
+) => {
+  if (standardExamType === "TYT") {
+    return retrieveStandardExamCoterieTypeOptionList().filter(
+      (item) =>
+        item.value === "TURKISH" ||
+        item.value === "HISTORY" ||
+        item.value === "GEOGRAPHY" ||
+        item.value === "PHILOSOPHY" ||
+        item.value === "CULTURE_AND_RELIGION_KNOWLEDGE" ||
+        item.value === "MATHEMATICS" ||
+        item.value === "GEOMETRY" ||
+        item.value === "PHYSICS" ||
+        item.value === "CHEMISTRY" ||
+        item.value === "BIOLOGY"
+    );
+  } else if (standardExamType === "AYT") {
+    return retrieveStandardExamCoterieTypeOptionList().filter(
+      (item) =>
+        item.value === "LITERATURE" ||
+        item.value === "HISTORY_I" ||
+        item.value === "HISTORY_II" ||
+        item.value === "GEOGRAPHY_I" ||
+        item.value === "GEOGRAPHY_II" ||
+        item.value === "PHILOSOPHY" ||
+        item.value === "PHILOSOPHY_OR_CULTURE_AND_RELIGION_KNOWLEDGE" ||
+        item.value === "MATHEMATICS" ||
+        item.value === "GEOMETRY" ||
+        item.value === "PHYSICS" ||
+        item.value === "CHEMISTRY" ||
+        item.value === "BIOLOGY" ||
+        item.value === "ENGLISH"
+    );
+  } else if (standardExamType === "LGS") {
+    return retrieveStandardExamCoterieTypeOptionList().filter(
+      (item) =>
+        item.value === "TURKISH" ||
+        item.value === "REVOLUTION_HISTORY" ||
+        item.value === "CULTURE_AND_RELIGION_KNOWLEDGE" ||
+        item.value === "MATHEMATICS" ||
+        item.value === "SCIENCE" ||
+        item.value === "ENGLISH"
+    );
+  } else return [];
+};
+
+const retrieveStandardExamCoterieTypeOptionList = () => {
+  return [
+    { value: "TURKISH", text: i18n.t("TURKISH") },
+    { value: "SCIENCE", text: i18n.t("SCIENCE") },
+    { value: "HISTORY", text: i18n.t("HISTORY") },
+    { value: "GEOGRAPHY", text: i18n.t("GEOGRAPHY") },
+    { value: "PHILOSOPHY", text: i18n.t("PHILOSOPHY") },
+    {
+      value: "CULTURE_AND_RELIGION_KNOWLEDGE",
+      text: i18n.t("CULTURE_AND_RELIGION_KNOWLEDGE"),
+    },
+    { value: "MATHEMATICS", text: i18n.t("MATHEMATICS") },
+    { value: "GEOMETRY", text: i18n.t("GEOMETRY") },
+    { value: "PHYSICS", text: i18n.t("PHYSICS") },
+    { value: "CHEMISTRY", text: i18n.t("CHEMISTRY") },
+    { value: "BIOLOGY", text: i18n.t("BIOLOGY") },
+    { value: "LITERATURE", text: i18n.t("LITERATURE") },
+    { value: "HISTORY_I", text: i18n.t("HISTORY_I") },
+    { value: "HISTORY_II", text: i18n.t("HISTORY_II") },
+    { value: "GEOGRAPHY_I", text: i18n.t("GEOGRAPHY_I") },
+    { value: "GEOGRAPHY_II", text: i18n.t("GEOGRAPHY_II") },
+    {
+      value: "PHILOSOPHY_OR_CULTURE_AND_RELIGION_KNOWLEDGE",
+      text: i18n.t("PHILOSOPHY_OR_CULTURE_AND_RELIGION_KNOWLEDGE"),
+    },
+    { value: "ENGLISH", text: i18n.t("ENGLISH") },
+    { value: "REVOLUTION_HISTORY", text: i18n.t("REVOLUTION_HISTORY") },
+  ];
+};
+
+const retrieveValidationRequirementList_AYT = () => {
+  return [
+    {
+      value: "LITERATURE",
+      count: 24,
+    },
+    {
+      value: "HISTORY_I",
+      count: 10,
+    },
+    {
+      value: "HISTORY_II",
+      count: 11,
+    },
+    {
+      value: "GEOGRAPHY_I",
+      count: 6,
+    },
+    {
+      value: "GEOGRAPHY_II",
+      count: 11,
+    },
+    {
+      value: "PHILOSOPHY",
+      count: 12,
+    },
+    {
+      value: "PHILOSOPHY_OR_CULTURE_AND_RELIGION_KNOWLEDGE",
+      count: 6,
+    },
+    {
+      value: "MATHEMATICS",
+      count: 30,
+    },
+    {
+      value: "GEOMETRY",
+      count: 10,
+    },
+    {
+      value: "PHYSICS",
+      count: 14,
+    },
+    {
+      value: "CHEMISTRY",
+      count: 13,
+    },
+    {
+      value: "BIOLOGY",
+      count: 13,
+    },
+    {
+      value: "ENGLISH",
+      count: 80,
+    },
+  ];
+};
+
+const retrieveValidationRequirementList_TYT = () => {
+  return [
+    {
+      value: "TURKISH",
+      count: 40,
+    },
+    {
+      value: "HISTORY",
+      count: 5,
+    },
+    {
+      value: "GEOGRAPHY",
+      count: 5,
+    },
+    {
+      value: "PHILOSOPHY",
+      count: 5,
+    },
+    {
+      value: "CULTURE_AND_RELIGION_KNOWLEDGE",
+      count: 5,
+    },
+    {
+      value: "MATHEMATICS",
+      count: 30,
+    },
+    {
+      value: "GEOMETRY",
+      count: 10,
+    },
+    {
+      value: "PHYSICS",
+      count: 7,
+    },
+    {
+      value: "CHEMISTRY",
+      count: 7,
+    },
+    {
+      value: "BIOLOGY",
+      count: 6,
+    },
+  ];
+};
+
+const retrieveValidationRequirementList_LGS = () => {
+  return [
+    {
+      value: "TURKISH",
+      count: 20,
+    },
+    {
+      value: "REVOLUTION_HISTORY",
+      count: 10,
+    },
+    {
+      value: "CULTURE_AND_RELIGION_KNOWLEDGE",
+      count: 10,
+    },
+    {
+      value: "MATHEMATICS",
+      count: 20,
+    },
+    {
+      value: "SCIENCE",
+      count: 20,
+    },
+    {
+      value: "ENGLISH",
+      count: 10,
+    },
+  ];
+};
+
+export const retrieveValidationRequirementList = (
+  selectedStandardExamType: string
+) => {
+  if (selectedStandardExamType === "TYT") {
+    return retrieveValidationRequirementList_TYT();
+  } else if (selectedStandardExamType === "AYT") {
+    return retrieveValidationRequirementList_AYT();
+  } else if (selectedStandardExamType === "LGS") {
+    return retrieveValidationRequirementList_LGS();
+  }
+  return [];
+};
+
+export const constructActivityItemListWithSolutionForAI = (
+  bodyMap: any,
+  materialMap: any,
+  type: string,
+  imageContentList: any
+) => {
+  const itemList = [];
+  Object.keys(bodyMap).forEach((key) => {
+    const bodyItem = bodyMap[key];
+    if (bodyItem.type === "IMAGE") {
+      if (imageContentList && imageContentList.length > 0) {
+        const foundImageContent = imageContentList.find(
+          (imageContent: any) => imageContent.url === bodyItem.value
+        );
+        itemList.push({
+          type: "text",
+          text: foundImageContent.content,
+        });
+      } else {
+        itemList.push({
+          type: "image_url",
+          imageUrl: bodyItem.value,
+        });
+      }
+    } else {
+      itemList.push({
+        type: "text",
+        text: bodyItem.value.replaceAll("@@", "___________"),
+      });
+    }
+  });
+  if (type === "ORDERING") {
+    if (Object.keys(materialMap).length > 0) {
+      itemList.push({
+        type: "text",
+        text: `${i18n.t("correct_order")}: `,
+      });
+      Object.keys(materialMap).forEach((key) => {
+        itemList.push({
+          type: "text",
+          text: materialMap[key],
+        });
+      });
+    }
+  } else if (type === "DROPDOWN") {
+    if (Object.keys(materialMap).length > 0) {
+      itemList.push({
+        type: "text",
+        text: `${i18n.t("correct_blanks")}: `,
+      });
+      Object.keys(materialMap).forEach((key, index) => {
+        itemList.push({
+          type: "text",
+          text: `${i18n.t("blank")} ${index + 1}: ${
+            Object.keys(materialMap[key])[0]
+          }`,
+        });
+      });
+    }
+  } else if (type === "MCSA") {
+    if (Object.keys(materialMap).length > 0) {
+      const answer = Object.keys(materialMap)[0];
+      materialMap[answer].forEach((option: string) => {
+        itemList.push({
+          type: "text",
+          text: option,
+        });
+      });
+      materialMap[answer].forEach((option: string) => {
+        if (option === answer) {
+          itemList.push({
+            type: "text",
+            text: `[${i18n.t("answer").toUpperCase()}]${option}`,
+          });
+        }
+      });
+    }
+  } else if (type === "MCMA") {
+    if (Object.keys(materialMap).length > 0) {
+      const answer = Object.keys(materialMap)[0];
+      materialMap[answer].forEach((option: string) => {
+        itemList.push({
+          type: "text",
+          text: option,
+        });
+      });
+      const splittedTextList = answer.split("§");
+      materialMap[answer].forEach((option: string) => {
+        if (splittedTextList.includes(option)) {
+          itemList.push({
+            type: "text",
+            text: `[${i18n.t("answer").toUpperCase()}]${option}`,
+          });
+        }
+      });
+    }
+  } else if (type === "MATCHING") {
+    if (Object.keys(materialMap).length > 0) {
+      itemList.push({
+        type: "text",
+        text: `${i18n.t("correct_matching")}: `,
+      });
+      Object.keys(materialMap).forEach((key, index) => {
+        const matchingKey = Object.keys(materialMap[key])[0];
+        const matchingValue = materialMap[key][matchingKey];
+        itemList.push({
+          type: "text",
+          text: `${matchingKey}: ${matchingValue}`,
+        });
+      });
+    }
+  } else if (type === "GROUPING") {
+    if (Object.keys(materialMap).length > 0) {
+      itemList.push({
+        type: "text",
+        text: `${i18n.t("correct_grouping")}: `,
+      });
+      Object.keys(materialMap).forEach((key, index) => {
+        let text = `${i18n.t("group")} ${index + 1}: `;
+        itemList.push({
+          type: "text",
+          text: text,
+        });
+
+        const groupName = Object.keys(materialMap[key])[0];
+        let currentText = "";
+        materialMap[key][groupName].forEach((item: string) => {
+          currentText += `${item}, `;
+        });
+        currentText = currentText.substring(0, currentText.length - 2);
+        itemList.push({
+          type: "text",
+          text: `${groupName}: ${currentText}`,
+        });
+      });
+    }
+  } else if (type === "FILL_IN_THE_BLANKS") {
+    if (Object.keys(materialMap).length > 0) {
+      itemList.push({
+        type: "text",
+        text: `${i18n.t("correct_blanks")}: `,
+      });
+      Object.keys(materialMap).forEach((key, index) => {
+        materialMap[key].forEach((item: string) => {
+          itemList.push({
+            type: "text",
+            text: `${i18n.t("blank")} ${index + 1}: ${item}`,
+          });
+        });
+      });
+    }
+  } else if (type === "OPEN_ENDED") {
+  } else if (type === "TRUE_FALSE") {
+    if (materialMap.trueList && Object.keys(materialMap.trueList).length > 0) {
+      materialMap.trueList.forEach((item: string) => {
+        itemList.push({
+          type: "text",
+          text: `[${i18n.t("correct").toUpperCase()}]${item}`,
+        });
+      });
+    }
+
+    if (
+      materialMap.falseList &&
+      Object.keys(materialMap.falseList).length > 0
+    ) {
+      materialMap.falseList.forEach((item: string) => {
+        itemList.push({
+          type: "text",
+          text: `[${i18n.t("incorrect").toUpperCase()}]${item}`,
+        });
+      });
+    }
+  }
+
+  return itemList;
+};
+
+export const constructActivityItemListWithAnswersForAI = (
+  bodyMap: any,
+  materialMap: any,
+  type: string
+) => {
+  const itemList = [];
+  if (type === "ORDERING") {
+    Object.keys(bodyMap).forEach((key) => {
+      const bodyItem = JSON.parse(bodyMap[key]);
+      if (bodyItem.type === "IMAGE") {
+        itemList.push({
+          type: "image_url",
+          imageUrl: bodyItem.value,
+        });
+      } else {
+        itemList.push({
+          type: "text",
+          text: bodyItem.value,
+        });
+      }
+    });
+    if (Object.keys(materialMap).length > 0) {
+      itemList.push({
+        type: "text",
+        text: `${i18n.t("correct_order")}: `,
+      });
+      Object.keys(materialMap).forEach((key) => {
+        itemList.push({
+          type: "text",
+          text: materialMap[key],
+        });
+      });
+    }
+  } else if (type === "DROPDOWN") {
+    Object.keys(bodyMap).forEach((key) => {
+      const bodyItem = JSON.parse(bodyMap[key]);
+      if (bodyItem.type === "IMAGE") {
+        itemList.push({
+          type: "image_url",
+          imageUrl: bodyItem.value,
+        });
+      } else {
+        itemList.push({
+          type: "text",
+          text: bodyItem.value.replaceAll("@@", "___________"),
+        });
+      }
+    });
+    if (Object.keys(materialMap).length > 0) {
+      itemList.push({
+        type: "text",
+        text: `${i18n.t("correct_blanks")}: `,
+      });
+      Object.keys(materialMap).forEach((key, index) => {
+        itemList.push({
+          type: "text",
+          text: `${index + 1}. ${Object.keys(materialMap[key])[0]}`,
+        });
+      });
+    }
+  } else if (type === "MCSA") {
+    Object.keys(bodyMap).forEach((key) => {
+      const bodyItem = JSON.parse(bodyMap[key]);
+      if (bodyItem.type === "IMAGE") {
+        itemList.push({
+          type: "image_url",
+          imageUrl: bodyItem.value,
+        });
+      } else {
+        itemList.push({
+          type: "text",
+          text: bodyItem.value,
+        });
+      }
+    });
+    if (Object.keys(materialMap).length > 0) {
+      itemList.push({
+        type: "text",
+        text: `${i18n.t("correct_answer")}: `,
+      });
+      Object.keys(materialMap).forEach((key) => {
+        itemList.push({
+          type: "text",
+          text: key,
+        });
+      });
+    }
+  } else if (type === "MCMA") {
+    Object.keys(bodyMap).forEach((key) => {
+      const bodyItem = JSON.parse(bodyMap[key]);
+      if (bodyItem.type === "IMAGE") {
+        itemList.push({
+          type: "image_url",
+          imageUrl: bodyItem.value,
+        });
+      } else {
+        itemList.push({
+          type: "text",
+          text: bodyItem.value,
+        });
+      }
+    });
+    if (Object.keys(materialMap).length > 0) {
+      itemList.push({
+        type: "text",
+        text: `${i18n.t("correct_answers")}: `,
+      });
+      const splittedTextList = Object.keys(materialMap)[0].split("§");
+      splittedTextList.forEach((item) => {
+        const parsedItemList = JSON.parse(item);
+        for (const parsedItem of parsedItemList) {
+          itemList.push({
+            type: "text",
+            text: parsedItem,
+          });
+        }
+      });
+    }
+  } else if (type === "MATCHING") {
+    Object.keys(bodyMap).forEach((key) => {
+      const bodyItem = JSON.parse(bodyMap[key]);
+      if (bodyItem.type === "IMAGE") {
+        itemList.push({
+          type: "image_url",
+          imageUrl: bodyItem.value,
+        });
+      } else {
+        itemList.push({
+          type: "text",
+          text: bodyItem.value,
+        });
+      }
+    });
+    if (Object.keys(materialMap).length > 0) {
+      itemList.push({
+        type: "text",
+        text: `${i18n.t("correct_answers")}: `,
+      });
+      Object.keys(materialMap).forEach((key, index) => {
+        itemList.push({
+          type: "text",
+          text: `${i18n.t("match")} ${index + 1}:`,
+        });
+        itemList.push({
+          type: "text",
+          text: `${key}: ${materialMap[key]}`,
+        });
+      });
+    }
+  } else if (type === "GROUPING") {
+    Object.keys(bodyMap).forEach((key) => {
+      const bodyItem = JSON.parse(bodyMap[key]);
+      if (bodyItem.type === "IMAGE") {
+        itemList.push({
+          type: "image_url",
+          imageUrl: bodyItem.value,
+        });
+      } else {
+        itemList.push({
+          type: "text",
+          text: bodyItem.value,
+        });
+      }
+    });
+    if (Object.keys(materialMap).length > 0) {
+      itemList.push({
+        type: "text",
+        text: `${i18n.t("correct_answers")}: `,
+      });
+      Object.keys(materialMap).forEach((key, index) => {
+        let text = `${i18n.t("group")} ${index + 1}: `;
+        itemList.push({
+          type: "text",
+          text: text,
+        });
+
+        const groupName = key;
+        let currentText = "";
+        materialMap[groupName].forEach((item: string) => {
+          currentText += `${item}, `;
+        });
+        currentText = currentText.substring(0, currentText.length - 2);
+        itemList.push({
+          type: "text",
+          text: `${groupName}: [${currentText}]`,
+        });
+      });
+    }
+  } else if (type === "FILL_IN_THE_BLANKS") {
+    Object.keys(bodyMap).forEach((key) => {
+      const bodyItem = JSON.parse(bodyMap[key]);
+      if (bodyItem.type === "IMAGE") {
+        itemList.push({
+          type: "image_url",
+          imageUrl: bodyItem.value,
+        });
+      } else {
+        itemList.push({
+          type: "text",
+          text: bodyItem.value.replaceAll("@@", "___________"),
+        });
+      }
+    });
+    if (Object.keys(materialMap).length > 0) {
+      itemList.push({
+        type: "text",
+        text: `${i18n.t("correct_blanks")}: `,
+      });
+      Object.keys(materialMap).forEach((key, index) => {
+        JSON.parse(materialMap[key]).forEach((item: string) => {
+          itemList.push({
+            type: "text",
+            text: `${index + 1}. ${item}`,
+          });
+        });
+      });
+    }
+  } else if (type === "OPEN_ENDED") {
+    Object.keys(bodyMap).forEach((key) => {
+      const bodyItem = JSON.parse(bodyMap[key]);
+      if (bodyItem.type === "IMAGE") {
+        itemList.push({
+          type: "image_url",
+          imageUrl: bodyItem.value,
+        });
+      } else {
+        itemList.push({
+          type: "text",
+          text: bodyItem.value,
+        });
+      }
+    });
+  } else if (type === "TRUE_FALSE") {
+    Object.keys(bodyMap).forEach((key) => {
+      const bodyItem = JSON.parse(bodyMap[key]);
+      if (bodyItem.type === "IMAGE") {
+        itemList.push({
+          type: "image_url",
+          imageUrl: bodyItem.value,
+        });
+      } else {
+        itemList.push({
+          type: "text",
+          text: bodyItem.value,
+        });
+      }
+    });
+    if (materialMap.trueList && Object.keys(materialMap.trueList).length > 0) {
+      itemList.push({
+        type: "text",
+        text: `${i18n.t("correct_answers")}: `,
+      });
+      materialMap.trueList.forEach((item: string) => {
+        itemList.push({
+          type: "text",
+          text: item,
+        });
+      });
+    }
+    if (
+      materialMap.falseList &&
+      Object.keys(materialMap.falseList).length > 0
+    ) {
+      itemList.push({
+        type: "text",
+        text: `${i18n.t("incorrect_answers")}: `,
+      });
+      materialMap.falseList.forEach((item: string) => {
+        itemList.push({
+          type: "text",
+          text: item,
+        });
+      });
+    }
+  }
+
+  return itemList;
+};
+
+export const retrieveActivityTemplateDTOOptionList = (
+  activityTemplateSet: any
+) => {
+  return activityTemplateSet.map((activityTemplateDTO: any) => ({
+    id: activityTemplateDTO.id,
+    value: activityTemplateDTO.id,
+    text: i18n.t(activityTemplateDTO.type),
+  }));
+};
+
+const retrieveDefaultOrderingDataMap = (orderingMaterialMap: any) => {
+  const dataMap: any = {};
+  Object.keys(orderingMaterialMap)
+    .sort(() => 0.5 - Math.random())
+    .forEach((key, index) => {
+      dataMap[index] = key;
+    });
+
+  return dataMap;
+};
+
+const retrieveDefaultDropdownMap = (dropdownMaterialMap: any) => {
+  const dataMap: any = {};
+  Object.keys(dropdownMaterialMap).forEach((key) => {
+    dataMap[key] = "DEFAULT_OPTION";
+  });
+  return dataMap;
+};
+
+const retrieveDefaultMCSAMap = (MCSAMaterialMap: any) => {
+  const dataMap: any = {};
+  Object.keys(MCSAMaterialMap).forEach((key, index) => {
+    dataMap[key] = "ANSWER_KEY";
+  });
+  return dataMap;
+};
+
+const retrieveDefaultMCMAMap = (MCMAMaterialMap: any) => {
+  const dataMap: any = {};
+  Object.keys(MCMAMaterialMap).forEach((key, index) => {
+    dataMap[key] = [];
+  });
+  return dataMap;
+};
+
+const retrieveDefaultMatchingMap = (matchingMaterialMap: any) => {
+  const dataMap: any = {};
+  Object.keys(matchingMaterialMap).forEach((key, index) => {
+    dataMap[key] = "";
+  });
+  return dataMap;
+};
+
+const retrieveDefaultGroupingMap = (groupingMaterialMap: any) => {
+  const dataMap: any = {};
+  Object.keys(groupingMaterialMap).forEach((key, index) => {
+    dataMap[key] = [];
+  });
+  return dataMap;
+};
+
+const retrieveDefaultFillInTheBlanksMap = (fillInTheBlanksMaterialMap: any) => {
+  const dataMap: any = {};
+  Object.keys(fillInTheBlanksMaterialMap).forEach((key) => {
+    dataMap[key] = "";
+  });
+  return dataMap;
+};
+
+const retrieveDefaultOpenEndedMap = () => {
+  return { ANSWER: "" };
+};
+
+const retrieveDefaultTrueFalseMap = () => {
+  return { trueList: [], falseList: [] };
+};
+
+export const retrieveCurrentDefaultDataMap = (
+  activityTemplate: any,
+  activityData: any
+) => {
+  const defaultDataMap: any = {
+    activityTemplateId: activityTemplate.id,
+    type: activityTemplate.type,
+  };
+  if (activityTemplate.type === "ORDERING") {
+    defaultDataMap.answerMap = retrieveDefaultOrderingDataMap(
+      activityData.orderingMaterialMap
+    );
+  } else if (activityTemplate.type === "DROPDOWN") {
+    defaultDataMap.answerMap = retrieveDefaultDropdownMap(
+      activityData.dropdownMaterialMap
+    );
+  } else if (activityTemplate.type === "MCSA") {
+    defaultDataMap.answerMap = retrieveDefaultMCSAMap(
+      activityData.MCSAMaterialMap
+    );
+  } else if (activityTemplate.type === "MCMA") {
+    defaultDataMap.answerMap = retrieveDefaultMCMAMap(
+      activityData.MCMAMaterialMap
+    );
+  } else if (activityTemplate.type === "MATCHING") {
+    defaultDataMap.answerMap = retrieveDefaultMatchingMap(
+      activityData.matchingMaterialMap
+    );
+  } else if (activityTemplate.type === "GROUPING") {
+    defaultDataMap.answerMap = retrieveDefaultGroupingMap(
+      activityData.groupingMaterialMap
+    );
+  } else if (activityTemplate.type === "FILL_IN_THE_BLANKS") {
+    defaultDataMap.answerMap = retrieveDefaultFillInTheBlanksMap(
+      activityData.fillInTheBlanksMaterialMap
+    );
+  } else if (activityTemplate.type === "OPEN_ENDED") {
+    defaultDataMap.answerMap = retrieveDefaultOpenEndedMap();
+  } else if (activityTemplate.type === "TRUE_FALSE") {
+    defaultDataMap.answerMap = retrieveDefaultTrueFalseMap();
+  }
+  return defaultDataMap;
+};
+
+export const constructActivityAnswerMap = (
+  activityTemplate: any,
+  activityData: any
+) => {
+  if (activityTemplate.type === "ORDERING") {
+    activityData.orderingMaterialMap = JSON.parse(
+      activityData.orderingMaterialMap
+    );
+  } else if (activityTemplate.type === "DROPDOWN") {
+    activityData.dropdownMaterialMap = JSON.parse(
+      activityData.dropdownMaterialMap
+    );
+  } else if (activityTemplate.type === "MCSA") {
+    activityData.MCSAMaterialMap = JSON.parse(activityData.MCSAMaterialMap);
+  } else if (activityTemplate.type === "MCMA") {
+    activityData.MCMAMaterialMap = JSON.parse(activityData.MCMAMaterialMap);
+  } else if (activityTemplate.type === "MATCHING") {
+    activityData.matchingMaterialMap = JSON.parse(
+      activityData.matchingMaterialMap
+    );
+  } else if (activityTemplate.type === "GROUPING") {
+    activityData.groupingMaterialMap = JSON.parse(
+      activityData.groupingMaterialMap
+    );
+  } else if (activityTemplate.type === "FILL_IN_THE_BLANKS") {
+    activityData.fillInTheBlanksMaterialMap = JSON.parse(
+      activityData.fillInTheBlanksMaterialMap
+    );
+  } else if (activityTemplate.type === "OPEN_ENDED") {
+    activityData.openEndedMaterialMap = {};
+  } else if (activityTemplate.type === "TRUE_FALSE") {
+    activityData.trueFalseMaterialMap = { trueList: [], falseList: [] };
+  }
+  return retrieveCurrentDefaultDataMap(activityTemplate, activityData);
+};
+
+export const ignoreMathematicalExpression = (inputText: string) => {
+  return inputText
+    .replaceAll("{", "")
+    .replaceAll("}", "")
+    .replaceAll("_", "")
+    .replaceAll("^", "")
+    .replaceAll("\\frac", "")
+    .replaceAll("\\text", "")
+    .replaceAll("\\sqrt", "");
+};
+
+export const checkIfAnswerIsEmpty = (answer: any) => {
+  const { data } = answer;
+  if (data && data.length > 0) {
+    const foundAnswer = data[0];
+    const { type, answerMap } = foundAnswer;
+    if (type === "ORDERING") {
+      return false;
+    } else if (type === "DROPDOWN") {
+      for (const key of Object.keys(answerMap)) {
+        if (answerMap[key] !== "DEFAULT_OPTION") {
+          return false;
+        }
+      }
+    } else if (type === "MCSA") {
+      const key = Object.keys(answerMap)[0];
+      if (answerMap[key] !== "ANSWER_KEY") {
+        return false;
+      }
+    } else if (type === "MCMA") {
+      const key = Object.keys(answerMap)[0];
+      if (answerMap[key].length !== 0) {
+        return false;
+      }
+    } else if (type === "MATCHING") {
+      for (const key of Object.keys(answerMap)) {
+        if (answerMap[key]) {
+          return false;
+        }
+      }
+    } else if (type === "GROUPING") {
+      for (const key of Object.keys(answerMap)) {
+        if (answerMap[key].length !== 0) {
+          return false;
+        }
+      }
+    } else if (type === "FILL_IN_THE_BLANKS") {
+      for (const key of Object.keys(answerMap)) {
+        if (answerMap[key]) {
+          return false;
+        }
+      }
+    } else if (type === "OPEN_ENDED") {
+      const key = Object.keys(answerMap)[0];
+      if (answerMap[key]) {
+        return false;
+      }
+    } else if (type === "TRUE_FALSE") {
+      return (
+        answerMap.trueList.length === 0 && answerMap.falseList.length === 0
+      );
+    }
+  }
+  return true;
+};
+
+export const constructActivityAnswerStateList = (
+  answerList: any,
+  activityList: any
+) => {
+  const stateList: any = [];
+  activityList.forEach((activity: any, index: number) => {
+    stateList.push({
+      index,
+      id: activity.id,
+      state: checkActivityAnswerState(answerList, activity),
+    });
+  });
+  return stateList;
+};
+
+export const retrieveActivityAnswerFromAnswerList = (
+  answerList: any,
+  activity: any
+) => {
+  // if (!answerList || !activity) return;
+  return answerList.find(
+    (answer: any) =>
+      parseFloat(answer.activityDTO.id) === parseFloat(activity.id)
+  );
+};
+
+export const checkActivityAnswerState = (answerList: any, activity: any) => {
+  const activityAnswer = retrieveActivityAnswerFromAnswerList(
+    answerList,
+    activity
+  );
+  if (!activityAnswer) {
+    return "NOT_EXISTS";
+  }
+  const { data } = activityAnswer;
+  if (!data) return "NOT_EXISTS";
+  const parsedData = JSON.parse(data);
+  if (
+    parsedData.filter((item: any) => !item.isEmpty).length === parsedData.length
+  ) {
+    return "ANSWERED";
+  } else {
+    return "EMPTY";
+  }
+};
+
+export const findBestFitActivity = (
+  activity: any,
+  individualModelList: any,
+  outcomeModelList: any
+) => {
+  const { activityTemplateDTOList, data, coterieType, categoryIdList } =
+    activity;
+  const parsedData = JSON.parse(data);
+  const {
+    orderingTaxonomyMap,
+    dropdownTaxonomyMap,
+    MCSATaxonomyMap,
+    MCMATaxonomyMap,
+    matchingTaxonomyMap,
+    groupingTaxonomyMap,
+    fillInTheBlanksTaxonomyMap,
+    openEndedTaxonomyMap,
+    trueFalseTaxonomyMap,
+  } = parsedData;
+  const taxonomyMap: any = {};
+  if (orderingTaxonomyMap) {
+    taxonomyMap["orderingTaxonomyMap"] = JSON.parse(orderingTaxonomyMap);
+  }
+  if (dropdownTaxonomyMap) {
+    taxonomyMap["dropdownTaxonomyMap"] = JSON.parse(dropdownTaxonomyMap);
+  }
+  if (MCSATaxonomyMap) {
+    taxonomyMap["MCSATaxonomyMap"] = JSON.parse(MCSATaxonomyMap);
+  }
+  if (MCMATaxonomyMap) {
+    taxonomyMap["MCMATaxonomyMap"] = JSON.parse(MCMATaxonomyMap);
+  }
+  if (matchingTaxonomyMap) {
+    taxonomyMap["matchingTaxonomyMap"] = JSON.parse(matchingTaxonomyMap);
+  }
+  if (groupingTaxonomyMap) {
+    taxonomyMap["groupingTaxonomyMap"] = JSON.parse(groupingTaxonomyMap);
+  }
+  if (fillInTheBlanksTaxonomyMap) {
+    taxonomyMap["fillInTheBlanksTaxonomyMap"] = JSON.parse(
+      fillInTheBlanksTaxonomyMap
+    );
+  }
+  if (trueFalseTaxonomyMap) {
+    taxonomyMap["trueFalseTaxonomyMap"] = JSON.parse(trueFalseTaxonomyMap);
+  }
+  if (openEndedTaxonomyMap) {
+    taxonomyMap["openEndedTaxonomyMap"] = JSON.parse(openEndedTaxonomyMap);
+  }
+  let coterieField = "VERBAL";
+  if (
+    coterieType === "MATHEMATICS" ||
+    coterieType === "BIOLOGY" ||
+    coterieType === "PHYSICS" ||
+    coterieType === "CHEMISTRY" ||
+    coterieType === "SCIENCE"
+  ) {
+    coterieField = "NUMERIC";
+  }
+  let foundModel;
+  let isOutcomeFound = true;
+  if (categoryIdList.length > 0) {
+    const categoryId = categoryIdList[0];
+    foundModel = outcomeModelList.find(
+      (outcomeModel: any) => outcomeModel.outcomeId === categoryId
+    );
+    if (!foundModel) isOutcomeFound = false;
+  } else {
+    isOutcomeFound = false;
+  }
+  if (!isOutcomeFound) {
+    foundModel = individualModelList.find(
+      (individualModel: any) => individualModel.coterieField === coterieField
+    );
+  }
+
+  let bestScore = Number.MAX_SAFE_INTEGER;
+  let bestActivityTemplate;
+  let bestActivityTemplateList = [];
+  const activityTemplateValueMap: any = {};
+  for (const activityTemplateDTO of activityTemplateDTOList) {
+    const { type } = activityTemplateDTO;
+    let currentTaxonomyMap;
+    if (type === "ORDERING") {
+      currentTaxonomyMap = taxonomyMap["orderingTaxonomyMap"];
+    } else if (type === "DROPDOWN") {
+      currentTaxonomyMap = taxonomyMap["dropdownTaxonomyMap"];
+    } else if (type === "MCSA") {
+      currentTaxonomyMap = taxonomyMap["MCSATaxonomyMap"];
+    } else if (type === "MCMA") {
+      currentTaxonomyMap = taxonomyMap["MCMATaxonomyMap"];
+    } else if (type === "MATCHING") {
+      currentTaxonomyMap = taxonomyMap["matchingTaxonomyMap"];
+    } else if (type === "GROUPING") {
+      currentTaxonomyMap = taxonomyMap["groupingTaxonomyMap"];
+    } else if (type === "FILL_IN_THE_BLANKS") {
+      currentTaxonomyMap = taxonomyMap["fillInTheBlanksTaxonomyMap"];
+    } else if (type === "OPEN_ENDED") {
+      currentTaxonomyMap = taxonomyMap["openEndedTaxonomyMap"];
+    } else if (type === "TRUE_FALSE") {
+      currentTaxonomyMap = taxonomyMap["trueFalseTaxonomyMap"];
+    }
+
+    const {
+      type: taxonomyType,
+      groupName: taxonomyGroupName,
+      name: taxonomyName,
+    } = currentTaxonomyMap;
+    const taxonomyString =
+      taxonomyType.toLowerCase() +
+      taxonomyGroupName.toLowerCase().charAt(0).toUpperCase() +
+      taxonomyGroupName.toLowerCase().substring(1) +
+      taxonomyName.toLowerCase().charAt(0).toUpperCase() +
+      taxonomyName.toLowerCase().substring(1);
+
+    const currentTaxonomyScore = foundModel[taxonomyString];
+    const splittedTypeList = type.split("_");
+    let activityTemplateString = "";
+    for (let i = 0; i < splittedTypeList.length; i++) {
+      const currentType = splittedTypeList[i].toLowerCase();
+      if (i === 0) {
+        activityTemplateString += currentType;
+      } else {
+        activityTemplateString +=
+          currentType.charAt(0).toUpperCase() + currentType.substring(1);
+      }
+    }
+    const currentActivityTemplateScore = foundModel[activityTemplateString];
+    const currentScore = currentTaxonomyScore * currentActivityTemplateScore;
+    activityTemplateValueMap[type] = currentScore;
+    if (currentScore < bestScore) {
+      bestScore = currentScore;
+      bestActivityTemplate = type;
+      bestActivityTemplateList = [type];
+    } else if (currentScore === bestScore) {
+      bestActivityTemplateList.push(type);
+    }
+  }
+
+  return {
+    bestScore,
+    bestActivityTemplate,
+    bestActivityTemplateList,
+    activityTemplateValueMap,
+  };
+};
+
+export const retrieveContestTypeOptionList = () => {
+  return [
+    {
+      value: "QUIZ",
+      text: i18n.t("QUIZ"),
+    },
+  ];
+};
+
+export const retrieveFrequencyTypeOptionList = () => {
+  return [
+    {
+      value: "WEEKLY",
+      text: i18n.t("WEEKLY"),
+    },
+  ];
+};
+
+export const retrieveDistintCoterieTypeFromCatchtivityApplicationDTO = (
+  catchtivityApplicationDTOList: any
+) => {
+  const coterieTypeList = [];
+  for (const catchtivityApplicationDTO of catchtivityApplicationDTOList) {
+    const { catchtivityDTO } = catchtivityApplicationDTO;
+    const { coterieType } = catchtivityDTO;
+    if (
+      coterieTypeList.findIndex(
+        (foundCoterieType) => foundCoterieType === coterieType
+      ) === -1
+    ) {
+      coterieTypeList.push(coterieType);
+    }
+  }
+  return coterieTypeList;
+};
+
+export const retrieveClockTimeLeft = (
+  type: string,
+  value: number,
+  durationType: string,
+  durationInMinutes: number,
+  activityProgressDTOSet: any,
+  activity: any
+) => {
+  if (type === "CATCHTIVITY" || type === "CATCHXAM" || type === "CONTEST") {
+    if (durationType === "ALL") {
+      return durationInMinutes
+        ? durationInMinutes * 60 -
+            retrieveTotalTimeSpentInSeconds(activityProgressDTOSet)
+        : 0;
+    } else if (durationType === "EACH") {
+      return durationInMinutes
+        ? durationInMinutes * 60 -
+            retrieveEachTimeSpentInSeconds(activityProgressDTOSet, activity)
+        : 0;
+    } else return 0;
+  } else if (type === "ACTIVITY") {
+    return (
+      value - retrieveEachTimeSpentInSeconds(activityProgressDTOSet, activity)
+    );
+  }
+  return 0;
+};
+
+export const retrieveEachTimeSpentInSeconds = (
+  activityProgressList: any,
+  activity: any
+) => {
+  if (!activityProgressList || !activity) return 0;
+  const foundActivityProgress = activityProgressList.find(
+    (activityProgress: any) =>
+      parseFloat(activityProgress.activityDTO.id) === parseFloat(activity.id)
+  );
+  if (foundActivityProgress) {
+    return foundActivityProgress.timeSpent / 1000;
+  }
+  return 0;
+};
+
+export const retrieveTotalTimeSpentInSeconds = (activityProgressList: any) => {
+  let timeSpent = 0;
+  if (!activityProgressList) return 0;
+  activityProgressList.forEach((activityProgress: any) => {
+    timeSpent += activityProgress.timeSpent;
+  });
+  return timeSpent / 1000;
+};
+
+export const retrieveTotalTimeSpentInMinutes = (activityProgressList: any) => {
+  return retrieveTotalTimeSpentInSeconds(activityProgressList) / 60;
+};
+
+export const parseContentMapFromData = (data: any) => {
+  return JSON.parse(data.contentMap);
+};
+
+export const parseBodyMapFromData = (data: any, type: string) => {
+  if (type === "ORDERING") {
+    return JSON.parse(data.orderingBodyMap);
+  } else if (type === "DROPDOWN") {
+    return JSON.parse(data.dropdownBodyMap);
+  } else if (type === "MCSA") {
+    return JSON.parse(data.MCSABodyMap);
+  } else if (type === "MCMA") {
+    return JSON.parse(data.MCMABodyMap);
+  } else if (type === "MATCHING") {
+    return JSON.parse(data.matchingBodyMap);
+  } else if (type === "GROUPING") {
+    return JSON.parse(data.groupingBodyMap);
+  } else if (type === "FILL_IN_THE_BLANKS") {
+    return JSON.parse(data.fillInTheBlanksBodyMap);
+  } else if (type === "OPEN_ENDED") {
+    return JSON.parse(data.openEndedBodyMap);
+  } else if (type === "TRUE_FALSE") {
+    return JSON.parse(data.trueFalseBodyMap);
+  }
+};
+
+export const parseMaterialMapFromData = (data: any, type: string) => {
+  if (type === "ORDERING") {
+    return JSON.parse(data.orderingMaterialMap);
+  } else if (type === "DROPDOWN") {
+    const dropdownMaterialMap = JSON.parse(data.dropdownMaterialMap);
+    Object.keys(dropdownMaterialMap).forEach((materialKey) => {
+      dropdownMaterialMap[materialKey] = JSON.parse(
+        dropdownMaterialMap[materialKey]
+      );
+      const answerKey = Object.keys(dropdownMaterialMap[materialKey])[0];
+      dropdownMaterialMap[materialKey][answerKey] = JSON.parse(
+        dropdownMaterialMap[materialKey][answerKey]
+      );
+    });
+    return dropdownMaterialMap;
+  } else if (type === "MCSA") {
+    const MCSAMaterialMap = JSON.parse(data.MCSAMaterialMap);
+    Object.keys(MCSAMaterialMap).forEach((key) => {
+      MCSAMaterialMap[key] = JSON.parse(MCSAMaterialMap[key]);
+    });
+    return MCSAMaterialMap;
+  } else if (type === "MCMA") {
+    const MCMAMaterialMap = JSON.parse(data.MCMAMaterialMap);
+    Object.keys(MCMAMaterialMap).forEach((key) => {
+      MCMAMaterialMap[key] = JSON.parse(MCMAMaterialMap[key]);
+    });
+    return MCMAMaterialMap;
+  } else if (type === "MATCHING") {
+    return JSON.parse(data.matchingMaterialMap);
+  } else if (type === "GROUPING") {
+    const groupingMaterialMap = JSON.parse(data.groupingMaterialMap);
+    Object.keys(groupingMaterialMap).forEach((key) => {
+      groupingMaterialMap[key] = JSON.parse(groupingMaterialMap[key]);
+    });
+    return groupingMaterialMap;
+  } else if (type === "FILL_IN_THE_BLANKS") {
+    return JSON.parse(data.fillInTheBlanksMaterialMap);
+  } else if (type === "OPEN_ENDED") {
+    return {};
+  } else if (type === "TRUE_FALSE") {
+    const trueFalseMaterialMap = JSON.parse(data.trueFalseMaterialMap);
+    Object.keys(trueFalseMaterialMap).forEach((key) => {
+      trueFalseMaterialMap[key] = JSON.parse(trueFalseMaterialMap[key]);
+    });
+    return trueFalseMaterialMap;
+  }
+};