catchup-library-web 1.13.1 → 1.14.0

package/src/components/activities/ActivityPreviewByAnswerData.tsx

@@ -13,7 +13,10 @@ import ActivitySolutionContent from "./solution-content/ActivitySolutionContent"
 import ActivityEvaluationRubricContent from "./evaluation-rubric-content/ActivityEvaluationRubricContent";
 import DividerLine from "../dividers/DividerLine";
 import i18n from "../../language/i18n";
-import { constructActivityAnswerMap } from "../../utilization/CatchtivityUtilization";
+import {
+  constructActivityAnswerMap,
+  retrieveDifficultyByActivityTypeFromData,
+} from "../../utilization/CatchtivityUtilization";
 import { IActivityPreviewByAnswerDataProps } from "../../properties/ActivityProperties";
 import ActivityEmptyContent from "./empty-content/ActivityEmptyContent";
 
@@ -25,14 +28,13 @@ const ActivityPreviewByAnswerData = ({
   typeOptionList = [],
   showSolution = false,
   showEvaluationRubric = false,
-  showTaxonomy = true,
+  showDifficulty = true,
   isFullScreen = false,
   showCorrectAnswer = false,
 }: IActivityPreviewByAnswerDataProps) => {
   const [key, setKey] = useState(new Date().getTime());
   const [selectedType, setSelectedType] = useState<string | null>(null);
   const [optionList, setOptionList] = useState<any[]>([]);
-  // Define proper types for answer data
   interface AnswerItem {
     type: string;
     isEmpty?: boolean;
@@ -46,13 +48,11 @@ const ActivityPreviewByAnswerData = ({
 
   const [answer, setAnswer] = useState<Answer>({ data: [] });
 
-  // Reset component when data changes
   useEffect(() => {
     if (!data) return;
     setKey(new Date().getTime());
   }, [data]);
 
-  // Helper function to check if answer map exists for a specific type
   const checkAnswerMapExists = (type: string): AnswerItem | null => {
     if (data && data.answerMap && Array.isArray(data.answerMap)) {
       const foundAnswer = data.answerMap.find(
@@ -63,37 +63,6 @@ const ActivityPreviewByAnswerData = ({
     return null;
   };
 
-  // Helper function to retrieve taxonomy name from activity type
-  const retrieveTaxonomyNameFromActivityType = (type: string) => {
-    if (!data) return "";
-
-    let taxonomyMap = { name: "" };
-
-    const taxonomyMapNames: { [key: string]: string } = {
-      ORDERING: "orderingTaxonomyMap",
-      DROPDOWN: "dropdownTaxonomyMap",
-      MCSA: "MCSATaxonomyMap",
-      MCMA: "MCMATaxonomyMap",
-      MATCHING: "matchingTaxonomyMap",
-      GROUPING: "groupingTaxonomyMap",
-      FILL_IN_THE_BLANKS: "fillInTheBlanksTaxonomyMap",
-      OPEN_ENDED: "openEndedTaxonomyMap",
-      TRUE_FALSE: "trueFalseTaxonomyMap",
-    };
-
-    const mapName = taxonomyMapNames[type];
-    if (mapName && data[mapName]) {
-      try {
-        taxonomyMap = JSON.parse(data[mapName]);
-      } catch (error) {
-        console.error(`Error parsing taxonomy map for ${type}:`, error);
-      }
-    }
-
-    return taxonomyMap.name || "";
-  };
-
-  // Construct answer data based on available activity types
   useEffect(() => {
     if (!data) return;
 
@@ -146,7 +115,6 @@ const ActivityPreviewByAnswerData = ({
     constructAnswerBasedOnData();
   }, [data, lockedType]);
 
-  // Set up option list for type selection
   useEffect(() => {
     if (!data || !answer.data.length) return;
 
@@ -163,19 +131,20 @@ const ActivityPreviewByAnswerData = ({
       );
     }
 
-    if (showTaxonomy) {
+    if (showDifficulty) {
       setOptionList(
         currentTypeOptionList.map((typeOption: any) => ({
           ...typeOption,
-          subText: i18n.t(retrieveTaxonomyNameFromActivityType(typeOption.id)),
+          subText: i18n.t(
+            retrieveDifficultyByActivityTypeFromData(typeOption.id, data)
+          ),
         }))
       );
     } else {
       setOptionList(currentTypeOptionList);
     }
-  }, [data, answer.data, lockedType, typeOptionList, showTaxonomy]);
+  }, [data, answer.data, lockedType, typeOptionList, showDifficulty]);
 
-  // Render the appropriate activity content based on selected type
   const RenderSelectedActivityContent = () => {
     const commonProps = {
       answer,

package/src/components/activities/ActivityPreviewByData.tsx

@@ -1,5 +1,8 @@
 import { useEffect, useState } from "react";
-import { constructAnswerBasedOnData } from "../../utilization/CatchtivityUtilization";
+import {
+  constructAnswerBasedOnData,
+  retrieveDifficultyByActivityTypeFromData,
+} from "../../utilization/CatchtivityUtilization";
 import DropdownActivityContent from "./DropdownActivityContent";
 import FillInTheBlanksActivityContent from "./FillInTheBlanksActivityContent";
 import GroupingActivityContent from "./GroupingActivityContent";
@@ -23,7 +26,7 @@ const ActivityPreviewByData = ({
   typeOptionList,
   showSolution,
   showEvaluationRubric,
-  showTaxonomy,
+  showDifficulty,
   isFullScreen,
 }: IActivityPreviewByDataProps) => {
   const [key, setKey] = useState(new Date().getTime());
@@ -52,33 +55,6 @@ const ActivityPreviewByData = ({
   }, [typeOptionList, lockedType]);
 
   useEffect(() => {
-    const retrieveTaxonomyNameByActivityTypeFromData = (
-      type: string | null
-    ) => {
-      let taxonomyMap = {
-        name: "",
-      };
-      if (type === "ORDERING") {
-        taxonomyMap = JSON.parse(data["orderingTaxonomyMap"]);
-      } else if (type === "DROPDOWN") {
-        taxonomyMap = JSON.parse(data["dropdownTaxonomyMap"]);
-      } else if (type === "MCSA") {
-        taxonomyMap = JSON.parse(data["MCSATaxonomyMap"]);
-      } else if (type === "MCMA") {
-        taxonomyMap = JSON.parse(data["MCMATaxonomyMap"]);
-      } else if (type === "MATCHING") {
-        taxonomyMap = JSON.parse(data["matchingTaxonomyMap"]);
-      } else if (type === "GROUPING") {
-        taxonomyMap = JSON.parse(data["groupingTaxonomyMap"]);
-      } else if (type === "FILL_IN_THE_BLANKS") {
-        taxonomyMap = JSON.parse(data["fillInTheBlanksTaxonomyMap"]);
-      } else if (type === "OPEN_ENDED") {
-        taxonomyMap = JSON.parse(data["openEndedTaxonomyMap"]);
-      } else if (type === "TRUE_FALSE") {
-        taxonomyMap = JSON.parse(data["trueFalseTaxonomyMap"]);
-      }
-      return taxonomyMap.name;
-    };
     if (!data) return;
     if (!typeOptionList) return;
     if (typeOptionList.length === 0) return;
@@ -88,19 +64,19 @@ const ActivityPreviewByData = ({
         (typeOption: any) => typeOption.id === lockedType
       );
     }
-    if (showTaxonomy) {
+    if (showDifficulty) {
       setOptionList(
         currentTypeOptionList.map((typeOption: any) => ({
           ...typeOption,
           subText: i18n.t(
-            retrieveTaxonomyNameByActivityTypeFromData(typeOption.id)
+            retrieveDifficultyByActivityTypeFromData(typeOption.id, data)
           ),
         }))
       );
     } else {
       setOptionList(currentTypeOptionList);
     }
-  }, [data, lockedType, typeOptionList, showTaxonomy]);
+  }, [data, lockedType, typeOptionList, showDifficulty]);
 
   if (!data) return;
   const answer = constructAnswerBasedOnData(data);

package/src/properties/ActivityProperties.ts

@@ -223,7 +223,7 @@ export interface IActivityPreviewByDataProps {
   showDescription: boolean;
   lockedType: string;
   typeOptionList: any[];
-  showTaxonomy: boolean;
+  showDifficulty: boolean;
   showSolution: boolean;
   showEvaluationRubric: boolean;
   isFullScreen: boolean;
@@ -237,7 +237,7 @@ export interface IActivityPreviewByAnswerDataProps {
   typeOptionList?: any[];
   showSolution?: boolean;
   showEvaluationRubric?: boolean;
-  showTaxonomy?: boolean;
+  showDifficulty?: boolean;
   isFullScreen?: boolean;
   showCorrectAnswer?: boolean;
 }

package/src/utilization/CatchtivityUtilization.ts

@@ -109,93 +109,6 @@ export const retrieveDurationInSecondsOptionList = () => {
   ];
 };
 
-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 constructInputWithSpecialExpressionList = (inputText: string) => {
   const inputPartList = [];
   if (!inputText) return [];
@@ -1477,45 +1390,45 @@ export const findBestFitActivity = (
     activity;
   const parsedData = JSON.parse(data);
   const {
-    orderingTaxonomyMap,
-    dropdownTaxonomyMap,
-    MCSATaxonomyMap,
-    MCMATaxonomyMap,
-    matchingTaxonomyMap,
-    groupingTaxonomyMap,
-    fillInTheBlanksTaxonomyMap,
-    openEndedTaxonomyMap,
-    trueFalseTaxonomyMap,
+    orderingDifficulty,
+    dropdownDifficulty,
+    MCSADifficulty,
+    MCMADifficulty,
+    matchingDifficulty,
+    groupingDifficulty,
+    fillInTheBlanksDifficulty,
+    openEndedDifficulty,
+    trueFalseDifficulty,
   } = parsedData;
-  const taxonomyMap: any = {};
-  if (orderingTaxonomyMap) {
-    taxonomyMap["orderingTaxonomyMap"] = JSON.parse(orderingTaxonomyMap);
+  const difficultyMap: any = {};
+  if (orderingDifficulty) {
+    difficultyMap["orderingDifficulty"] = JSON.parse(orderingDifficulty);
   }
-  if (dropdownTaxonomyMap) {
-    taxonomyMap["dropdownTaxonomyMap"] = JSON.parse(dropdownTaxonomyMap);
+  if (dropdownDifficulty) {
+    difficultyMap["dropdownDifficulty"] = JSON.parse(dropdownDifficulty);
   }
-  if (MCSATaxonomyMap) {
-    taxonomyMap["MCSATaxonomyMap"] = JSON.parse(MCSATaxonomyMap);
+  if (MCSADifficulty) {
+    difficultyMap["MCSADifficulty"] = JSON.parse(MCSADifficulty);
   }
-  if (MCMATaxonomyMap) {
-    taxonomyMap["MCMATaxonomyMap"] = JSON.parse(MCMATaxonomyMap);
+  if (MCMADifficulty) {
+    difficultyMap["MCMADifficulty"] = JSON.parse(MCMADifficulty);
   }
-  if (matchingTaxonomyMap) {
-    taxonomyMap["matchingTaxonomyMap"] = JSON.parse(matchingTaxonomyMap);
+  if (matchingDifficulty) {
+    difficultyMap["matchingDifficulty"] = JSON.parse(matchingDifficulty);
   }
-  if (groupingTaxonomyMap) {
-    taxonomyMap["groupingTaxonomyMap"] = JSON.parse(groupingTaxonomyMap);
+  if (groupingDifficulty) {
+    difficultyMap["groupingDifficulty"] = JSON.parse(groupingDifficulty);
   }
-  if (fillInTheBlanksTaxonomyMap) {
-    taxonomyMap["fillInTheBlanksTaxonomyMap"] = JSON.parse(
-      fillInTheBlanksTaxonomyMap
+  if (fillInTheBlanksDifficulty) {
+    difficultyMap["fillInTheBlanksDifficulty"] = JSON.parse(
+      fillInTheBlanksDifficulty
     );
   }
-  if (trueFalseTaxonomyMap) {
-    taxonomyMap["trueFalseTaxonomyMap"] = JSON.parse(trueFalseTaxonomyMap);
+  if (trueFalseDifficulty) {
+    difficultyMap["trueFalseDifficulty"] = JSON.parse(trueFalseDifficulty);
   }
-  if (openEndedTaxonomyMap) {
-    taxonomyMap["openEndedTaxonomyMap"] = JSON.parse(openEndedTaxonomyMap);
+  if (openEndedDifficulty) {
+    difficultyMap["openEndedDifficulty"] = JSON.parse(openEndedDifficulty);
   }
   let coterieField = "VERBAL";
   if (
@@ -1550,40 +1463,28 @@ export const findBestFitActivity = (
   const activityTemplateValueMap: any = {};
   for (const activityTemplateDTO of activityTemplateDTOList) {
     const { type } = activityTemplateDTO;
-    let currentTaxonomyMap;
+    let currentDifficulty: string = "";
     if (type === "ORDERING") {
-      currentTaxonomyMap = taxonomyMap["orderingTaxonomyMap"];
+      currentDifficulty = difficultyMap["orderingDifficulty"];
     } else if (type === "DROPDOWN") {
-      currentTaxonomyMap = taxonomyMap["dropdownTaxonomyMap"];
+      currentDifficulty = difficultyMap["dropdownDifficulty"];
     } else if (type === "MCSA") {
-      currentTaxonomyMap = taxonomyMap["MCSATaxonomyMap"];
+      currentDifficulty = difficultyMap["MCSADifficulty"];
     } else if (type === "MCMA") {
-      currentTaxonomyMap = taxonomyMap["MCMATaxonomyMap"];
+      currentDifficulty = difficultyMap["MCMADifficulty"];
     } else if (type === "MATCHING") {
-      currentTaxonomyMap = taxonomyMap["matchingTaxonomyMap"];
+      currentDifficulty = difficultyMap["matchingDifficulty"];
     } else if (type === "GROUPING") {
-      currentTaxonomyMap = taxonomyMap["groupingTaxonomyMap"];
+      currentDifficulty = difficultyMap["groupingDifficulty"];
     } else if (type === "FILL_IN_THE_BLANKS") {
-      currentTaxonomyMap = taxonomyMap["fillInTheBlanksTaxonomyMap"];
+      currentDifficulty = difficultyMap["fillInTheBlanksDifficulty"];
     } else if (type === "OPEN_ENDED") {
-      currentTaxonomyMap = taxonomyMap["openEndedTaxonomyMap"];
+      currentDifficulty = difficultyMap["openEndedDifficulty"];
     } else if (type === "TRUE_FALSE") {
-      currentTaxonomyMap = taxonomyMap["trueFalseTaxonomyMap"];
+      currentDifficulty = difficultyMap["trueFalseDifficulty"];
     }
 
-    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 currentDifficultyScore = foundModel[currentDifficulty];
     const splittedTypeList = type.split("_");
     let activityTemplateString = "";
     for (let i = 0; i < splittedTypeList.length; i++) {
@@ -1596,7 +1497,7 @@ export const findBestFitActivity = (
       }
     }
     const currentActivityTemplateScore = foundModel[activityTemplateString];
-    const currentScore = currentTaxonomyScore * currentActivityTemplateScore;
+    const currentScore = currentDifficultyScore * currentActivityTemplateScore;
     activityTemplateValueMap[type] = currentScore;
     if (currentScore < bestScore) {
       bestScore = currentScore;
@@ -2389,3 +2290,30 @@ export const constructActivityItemListSolutionOnly = (solutionMap: any) => {
   });
   return itemList;
 };
+
+export const retrieveDifficultyByActivityTypeFromData = (
+  type: string,
+  data: any
+) => {
+  let difficulty = "";
+  if (type === "ORDERING") {
+    difficulty = data["orderingDifficulty"];
+  } else if (type === "DROPDOWN") {
+    difficulty = data["dropdownDifficulty"];
+  } else if (type === "MCSA") {
+    difficulty = data["MCSADifficulty"];
+  } else if (type === "MCMA") {
+    difficulty = data["MCMADifficulty"];
+  } else if (type === "MATCHING") {
+    difficulty = data["matchingDifficulty"];
+  } else if (type === "GROUPING") {
+    difficulty = data["groupingDifficulty"];
+  } else if (type === "FILL_IN_THE_BLANKS") {
+    difficulty = data["fillInTheBlanksDifficulty"];
+  } else if (type === "OPEN_ENDED") {
+    difficulty = data["openEndedDifficulty"];
+  } else if (type === "TRUE_FALSE") {
+    difficulty = data["trueFalseDifficulty"];
+  }
+  return difficulty;
+};

package/src/utilization/CategoryUtilization.ts

@@ -7,25 +7,25 @@ export const retrieveCategoryVersionCodeOptionList = () => {
       value: "MEB-IO-MAT-2024",
       text: i18n.t("MEB-IO-MAT-2024"),
       type: "MATHEMATICS",
-      availableLevelList: [5],
+      availableLevelList: [5, 6],
     },
     {
       value: "MEB-IO-MAT-2018",
       text: i18n.t("MEB-IO-MAT-2018"),
       type: "MATHEMATICS",
-      availableLevelList: [4, 6, 7, 8],
+      availableLevelList: [4, 7, 8],
     },
     {
       value: "MEB-IO-TUR-2024",
       text: i18n.t("MEB-IO-TUR-2024"),
       type: "TURKISH",
-      availableLevelList: [5],
+      availableLevelList: [5, 6],
     },
     {
       value: "MEB-IO-TUR-2019",
       text: i18n.t("MEB-IO-TUR-2019"),
       type: "TURKISH",
-      availableLevelList: [4, 6, 7, 8],
+      availableLevelList: [4, 7, 8],
     },
     {
       value: "MEB-IO-HAY-2018",
@@ -43,25 +43,25 @@ export const retrieveCategoryVersionCodeOptionList = () => {
       value: "MEB-IO-FEN-2024",
       text: i18n.t("MEB-IO-FEN-2024"),
       type: "SCIENCE",
-      availableLevelList: [5],
+      availableLevelList: [5, 6],
     },
     {
       value: "MEB-IO-SCI-2018",
       text: i18n.t("MEB-IO-SCI-2018"),
       type: "SCIENCE",
-      availableLevelList: [4, 6, 7, 8],
+      availableLevelList: [4, 7, 8],
     },
     {
       value: "MEB-IO-SOS-2024",
       text: i18n.t("MEB-IO-SOS-2024"),
       type: "SOCIAL_STUDIES",
-      availableLevelList: [5],
+      availableLevelList: [5, 6],
     },
     {
       value: "MEB-IO-SOS-2018",
       text: i18n.t("MEB-IO-SOS-2018"),
       type: "SOCIAL_STUDIES",
-      availableLevelList: [4, 6, 7],
+      availableLevelList: [4, 7],
     },
     {
       value: "MEB-IO-ITA-2018",
@@ -79,61 +79,61 @@ export const retrieveCategoryVersionCodeOptionList = () => {
       value: "MEB-AL-MAT-2024",
       text: i18n.t("MEB-AL-MAT-2024"),
       type: "MATHEMATICS",
-      availableLevelList: [9],
+      availableLevelList: [9, 10],
     },
     {
       value: "MEB-AL-MAT-2018",
       text: i18n.t("MEB-AL-MAT-2018"),
       type: "MATHEMATICS",
-      availableLevelList: [10, 11, 12],
+      availableLevelList: [11, 12],
     },
     {
       value: "MEB-AL-FİZ-2024",
       text: i18n.t("MEB-AL-FİZ-2024"),
       type: "PHYSICS",
-      availableLevelList: [9],
+      availableLevelList: [9, 10],
     },
     {
       value: "MEB-AL-FIZ-2018",
       text: i18n.t("MEB-AL-FIZ-2018"),
       type: "PHYSICS",
-      availableLevelList: [10, 11, 12],
+      availableLevelList: [11, 12],
     },
     {
       value: "MEB-AL-BİY-2024",
       text: i18n.t("MEB-AL-BİY-2024"),
       type: "BIOLOGY",
-      availableLevelList: [9],
+      availableLevelList: [9, 10],
     },
     {
       value: "MEB-AL-BIO-2018",
       text: i18n.t("MEB-AL-BIO-2018"),
       type: "BIOLOGY",
-      availableLevelList: [10, 11, 12],
+      availableLevelList: [11, 12],
     },
     {
       value: "MEB-AL-KİM-2024",
       text: i18n.t("MEB-AL-KİM-2024"),
       type: "CHEMISTRY",
-      availableLevelList: [9],
+      availableLevelList: [9, 10],
     },
     {
       value: "MEB-AL-KIM-2018",
       text: i18n.t("MEB-AL-KIM-2018"),
       type: "CHEMISTRY",
-      availableLevelList: [10, 11, 12],
+      availableLevelList: [11, 12],
     },
     {
       value: "MEB-AL-TAR-2024",
       text: i18n.t("MEB-AL-TAR-2024"),
       type: "HISTORY",
-      availableLevelList: [9],
+      availableLevelList: [9, 10],
     },
     {
       value: "MEB-AL-TAR-2018",
       text: i18n.t("MEB-AL-TAR-2018"),
       type: "HISTORY",
-      availableLevelList: [10, 11],
+      availableLevelList: [11],
     },
     {
       value: "MEB-AL-ITA-2018",
@@ -145,13 +145,13 @@ export const retrieveCategoryVersionCodeOptionList = () => {
       value: "MEB-AL-COĞ-2024",
       text: i18n.t("MEB-AL-COĞ-2024"),
       type: "GEOGRAPHY",
-      availableLevelList: [9],
+      availableLevelList: [9, 10],
     },
     {
       value: "MEB-AL-COĞ-2018",
       text: i18n.t("MEB-AL-COĞ-2018"),
       type: "GEOGRAPHY",
-      availableLevelList: [10, 11, 12],
+      availableLevelList: [11, 12],
     },
     {
       value: "MEB-IO-DKAB-2018",
@@ -169,25 +169,25 @@ export const retrieveCategoryVersionCodeOptionList = () => {
       value: "MEB-AL-FEL-2024",
       text: i18n.t("MEB-AL-FEL-2024"),
       type: "PHILOSOPHY",
-      availableLevelList: [9],
+      availableLevelList: [9, 10],
     },
     {
       value: "MEB-AL-FEL-2018",
       text: i18n.t("MEB-AL-FEL-2018"),
       type: "PHILOSOPHY",
-      availableLevelList: [10, 11],
+      availableLevelList: [11],
     },
     {
       value: "MEB-AL-TDE-2024",
       text: i18n.t("MEB-AL-TDE-2024"),
       type: "LITERATURE",
-      availableLevelList: [9],
+      availableLevelList: [9, 10],
     },
     {
       value: "MEB-AL-LIT-2018",
       text: i18n.t("MEB-AL-LIT-2018"),
       type: "LITERATURE",
-      availableLevelList: [10, 11, 12],
+      availableLevelList: [11, 12],
     },
     // {
     //   value: "CEFR-STANDARDS-A1",

package/src/utilization/IndividualModelUtilization.ts

@@ -1,16 +1,13 @@
 const NUMBER_OF_ACTIVITY_TEMPLATE = 9;
-const NUMBER_OF_TAXONOMY = 6;
-const INITIAL_TAXONOMY_VALUE = 1 / NUMBER_OF_TAXONOMY;
+const NUMBER_OF_DIFFICULTY = 3;
+const INITIAL_DIFFICULTY_VALUE = 1 / NUMBER_OF_DIFFICULTY;
 const INITIAL_TEMPLATE_VALUE = 1 / NUMBER_OF_ACTIVITY_TEMPLATE;
 
 export const constructBaseVerbalIndvidualModel = (userId: any) => {
   return {
-    bloomBloomAnalyze: INITIAL_TAXONOMY_VALUE,
-    bloomBloomApply: INITIAL_TAXONOMY_VALUE,
-    bloomBloomCreate: INITIAL_TAXONOMY_VALUE,
-    bloomBloomEvaluate: INITIAL_TAXONOMY_VALUE,
-    bloomBloomRemember: INITIAL_TAXONOMY_VALUE,
-    bloomBloomUnderstand: INITIAL_TAXONOMY_VALUE,
+    easy: INITIAL_DIFFICULTY_VALUE,
+    medium: INITIAL_DIFFICULTY_VALUE,
+    hard: INITIAL_DIFFICULTY_VALUE,
     dropdown: INITIAL_TEMPLATE_VALUE,
     coterieField: "VERBAL",
     fillInTheBlanks: INITIAL_TEMPLATE_VALUE,
@@ -27,12 +24,9 @@ export const constructBaseVerbalIndvidualModel = (userId: any) => {
 
 export const constructBaseNumericIndividualModel = (userId: any) => {
   return {
-    bloomBloomAnalyze: INITIAL_TAXONOMY_VALUE,
-    bloomBloomApply: INITIAL_TAXONOMY_VALUE,
-    bloomBloomCreate: INITIAL_TAXONOMY_VALUE,
-    bloomBloomEvaluate: INITIAL_TAXONOMY_VALUE,
-    bloomBloomRemember: INITIAL_TAXONOMY_VALUE,
-    bloomBloomUnderstand: INITIAL_TAXONOMY_VALUE,
+    easy: INITIAL_DIFFICULTY_VALUE,
+    medium: INITIAL_DIFFICULTY_VALUE,
+    hard: INITIAL_DIFFICULTY_VALUE,
     dropdown: INITIAL_TEMPLATE_VALUE,
     coterieField: "NUMERIC",
     fillInTheBlanks: INITIAL_TEMPLATE_VALUE,