Commit @2e4c67925025da0cd562ca5f695fb6f0562fc9f6

guntaek 09-19

240919 김건택 aidashboard 문제 수정

@2e4c67925025da0cd562ca5f695fb6f0562fc9f6

c4227a5

2e4c679

client/views/pages/AppStore.js

--- client/views/pages/AppStore.js

+++ client/views/pages/AppStore.js


 
         // 순서
         seqNum: null,
+
+        // 현재 대시보드
+        currentDashboard: null,
     };
 }
 

             return state.wdBookIdList;
         },
         getCurrentWdBkIndex: (state) => state.currentWdBkIndex,
+
+        // 대시보드 위치
+        getCurrentDashboard(state) {
+            return state.currentDashboard;
+        }
     },
     mutations: {
 

             state.wdBookIdList = [],
                 state.currentWdBkIndex = 0;
             state.seqNum = null;
+
+            // 대시보드 위치
+            state.currentDashboard = null;
+
             saveStateToLocalStorage(state);
         },
 

             state.prblmTypeId = payload.prblmTypeId;
             // 순서
             state.seqNum = payload.seqNum;
+            saveStateToLocalStorage(state);
+        },
+        // 대시보드 위치
+        setCurrentDashboard(state, currentDashboard) {
+            state.currentDashboard = currentDashboard;
             saveStateToLocalStorage(state);
         },
         incrementProblemIndex(state) {

         // updateSeqNum({ commit }) {
         //   commit("setSeqNum", seqNum);
         // },
+        
+        updateCurrentDashboard({ commit }, dashboard) {
+            commit("setCurrentDashboard", dashboard);
+        },
     },
 });

c4227a5

2e4c679

client/views/pages/main/Chapter/Chapter2_10.vue

--- client/views/pages/main/Chapter/Chapter2_10.vue

+++ client/views/pages/main/Chapter/Chapter2_10.vue


   },
   methods: {
     complete() {
-      const { unit_id, book_id } = this.$route.query;
-      this.$router.push({
-        name: "Dashboard",
-        query: { value: this.seq, unit_id, book_id },
-      });
+      // 로컬 스토리지에서 currentDashboard 값을 가져옴
+      const savedState = localStorage.getItem("vuexState");
+      if (savedState) {
+        const parsedState = JSON.parse(savedState);
+        const currentDashboard = parsedState.currentDashboard;
+
+        const { unit_id, book_id } = this.$route.query;
+        if (currentDashboard === "Learning") {
+          // Learning 모드일 때 Dashboard로 이동
+          this.$router.push({
+            name: "Dashboard",
+            query: { value: this.seq, unit_id, book_id },
+          });
+        } else if (currentDashboard === "AI") {
+          // AI 모드일 때 AIDashboard로 이동
+          this.$router.push({
+            name: "AIDashboard",
+            query: { value: this.seq, unit_id, book_id },
+          });
+        }
+      } else {
+        console.error("currentDashboard 값이 없습니다.");
+      }
     },
     goToPage(page) {
       this.$router.push({ name: page });

       }
     },
 
-    fetchProblemData() {
-      axios({
-        url: "/problem/problemInfo.json",
-        method: "post",
-        headers: {
-          "Content-Type": "application/json; charset=UTF-8",
-        },
-        data: {
-          prblmId: this.prblm_id.prblm_id,
-        },
-      })
-        .then((response) => {
-          this.problemData = response.data;
-          console.log("problemData", this.problemData);
+    // fetchProblemData() {
+    //   axios({
+    //     url: "/problem/problemInfo.json",
+    //     method: "post",
+    //     headers: {
+    //       "Content-Type": "application/json; charset=UTF-8",
+    //     },
+    //     data: {
+    //       prblmId: this.prblm_id.prblm_id,
+    //     },
+    //   })
+    //     .then((response) => {
+    //       this.problemData = response.data;
+    //       console.log("problemData", this.problemData);
 
-          this.sortingProblem();
-        })
-        .catch((error) => {
-          this.state = "noProblem";
-          console.error("Error fetching problemData:", error);
-        });
+    //       this.sortingProblem();
+    //     })
+    //     .catch((error) => {
+    //       this.state = "noProblem";
+    //       console.error("Error fetching problemData:", error);
+    //     });
+    // },
+
+    fetchProblemData() {
+      // 로컬 스토리지에서 currentDashboard를 확인
+      const savedState = localStorage.getItem("vuexState");
+      if (savedState) {
+        const parsedState = JSON.parse(savedState);
+        const currentDashboard = parsedState.currentDashboard;
+
+        if (currentDashboard === "AI") {
+          // AI 모드일 경우 로컬 스토리지에서 currentLearningId를 가져와 사용
+          const currentLearningId = parsedState.currentLearningIds;
+          console.log("AI 모드에서 currentLearningId 사용:", currentLearningId);
+
+          // currentLearningId로 문제 데이터 가져오기
+          axios({
+            url: "/problem/problemInfo.json",
+            method: "post",
+            headers: {
+              "Content-Type": "application/json; charset=UTF-8",
+            },
+            data: {
+              prblmId: currentLearningId, // 로컬스토리지에서 가져온 currentLearningId 사용
+            },
+          })
+            .then((response) => {
+              this.problemData = response.data;
+              console.log("AI 모드 problemData", this.problemData);
+              this.sortingProblem();
+            })
+            .catch((error) => {
+              this.state = "noProblem";
+              console.error("Error fetching AI problemData:", error);
+            });
+
+        } else {
+          // Learning 모드일 경우 기존 로직 사용
+          console.log("Learning 모드에서 prblm_id 사용:", this.prblm_id);
+
+          axios({
+            url: "/problem/problemInfo.json",
+            method: "post",
+            headers: {
+              "Content-Type": "application/json; charset=UTF-8",
+            },
+            data: {
+              prblmId: this.prblm_id.prblm_id, // 기존 방식 사용
+            },
+          })
+            .then((response) => {
+              this.problemData = response.data;
+              console.log("Learning 모드 problemData", this.problemData);
+              this.sortingProblem();
+            })
+            .catch((error) => {
+              this.state = "noProblem";
+              console.error("Error fetching problemData:", error);
+            });
+        }
+      } else {
+        console.error("vuexState가 로컬스토리지에 없습니다.");
+      }
     },
 
     sortingProblem() {

c4227a5

2e4c679

client/views/pages/main/Chapter/Chapter2_11.vue

--- client/views/pages/main/Chapter/Chapter2_11.vue

+++ client/views/pages/main/Chapter/Chapter2_11.vue


   },
   methods: {
     complete() {
-      const { unit_id, book_id } = this.$route.query;
-      this.$router.push({
-        name: "Dashboard",
-        query: { value: this.seq, unit_id, book_id },
-      });
+      // 로컬 스토리지에서 currentDashboard 값을 가져옴
+      const savedState = localStorage.getItem("vuexState");
+      if (savedState) {
+        const parsedState = JSON.parse(savedState);
+        const currentDashboard = parsedState.currentDashboard;
+
+        const { unit_id, book_id } = this.$route.query;
+        if (currentDashboard === "Learning") {
+          // Learning 모드일 때 Dashboard로 이동
+          this.$router.push({
+            name: "Dashboard",
+            query: { value: this.seq, unit_id, book_id },
+          });
+        } else if (currentDashboard === "AI") {
+          // AI 모드일 때 AIDashboard로 이동
+          this.$router.push({
+            name: "AIDashboard",
+            query: { value: this.seq, unit_id, book_id },
+          });
+        }
+      } else {
+        console.error("currentDashboard 값이 없습니다.");
+      }
     },
     goToPage(page) {
       this.$router.push({ name: page });

         this.afterQuestion = parts[1];
       }
     },
+    // getProblem() {
+    //   const vm = this;
+    //   const prblmId = this.prblm_id.prblm_id;
+    //   // const prblmId = "PROBLEM_000000000000076";
+
+    //   axios({
+    //     url: "problem/problemInfo.json",
+    //     method: "post",
+    //     headers: {
+    //       "Content-Type": "application/json; charset=UTF-8",
+    //     },
+    //     data: {
+    //       prblmId: prblmId,
+    //     },
+    //   })
+    //     .then(function (res) {
+    //       console.log("problem - response : ", res.data);
+    //       vm.dataList = res.data.problem;
+    //       vm.problemDetail = res.data.problemDetail;
+    //       vm.example = vm.dataList.prblmExpln;
+    //       vm.problemDetail.forEach((detail, index) => {
+    //         vm.choice.push(detail.prblmDtlExpln);
+    //         if (detail.prblmYn === "Y") {
+    //           vm.answer = index + 1;
+    //         }
+    //       });
+
+    //       console.log(vm.example);
+    //       console.log(vm.choice);
+    //       console.log(vm.answer);
+    //       vm.splitExample();
+    //     })
+    //     .catch(function (error) {
+    //       console.log("problem - error : ", error);
+    //     });
+    // },
+
     getProblem() {
       const vm = this;
-      const prblmId = this.prblm_id.prblm_id;
-      // const prblmId = "PROBLEM_000000000000076";
+      let prblmId = null;
+
+      // 로컬 스토리지에서 currentDashboard를 확인
+      const savedState = localStorage.getItem("vuexState");
+      if (savedState) {
+        const parsedState = JSON.parse(savedState);
+        const currentDashboard = parsedState.currentDashboard;
+
+        if (currentDashboard === "AI") {
+          // AI 모드일 때 로컬스토리지에서 currentLearningIds를 사용
+          prblmId = parsedState.currentLearningIds; // currentLearningIds를 사용
+          console.log("AI 모드에서 currentLearningIds 사용:", prblmId);
+        } else {
+          // Learning 모드일 때 기존 방식 사용
+          prblmId = this.prblm_id.prblm_id; // 기존 방식
+          console.log("Learning 모드에서 currentLearningId 사용:", prblmId);
+        }
+      }
 
       axios({
         url: "problem/problemInfo.json",

           console.log("problem - error : ", error);
         });
     },
+
     nextProblem() {
       if (
         this.currentProblemIndex <

c4227a5

2e4c679

client/views/pages/main/Chapter/Chapter2_13.vue

--- client/views/pages/main/Chapter/Chapter2_13.vue

+++ client/views/pages/main/Chapter/Chapter2_13.vue


   },
   methods: {
     complete() {
-      const { unit_id, book_id } = this.$route.query;
-      this.$router.push({
-        name: "Dashboard",
-        query: { value: this.seq, unit_id, book_id },
-      });
+      // 로컬 스토리지에서 currentDashboard 값을 가져옴
+      const savedState = localStorage.getItem("vuexState");
+      if (savedState) {
+        const parsedState = JSON.parse(savedState);
+        const currentDashboard = parsedState.currentDashboard;
+
+        const { unit_id, book_id } = this.$route.query;
+        if (currentDashboard === "Learning") {
+          // Learning 모드일 때 Dashboard로 이동
+          this.$router.push({
+            name: "Dashboard",
+            query: { value: this.seq, unit_id, book_id },
+          });
+        } else if (currentDashboard === "AI") {
+          // AI 모드일 때 AIDashboard로 이동
+          this.$router.push({
+            name: "AIDashboard",
+            query: { value: this.seq, unit_id, book_id },
+          });
+        }
+      } else {
+        console.error("currentDashboard 값이 없습니다.");
+      }
     },
     goToPage(page) {
       this.$router.push({ name: page });

       }
     },
 
-    fetchProblemData() {
-      axios({
-        url: "/problem/problemInfo.json",
-        method: "post",
-        headers: {
-          "Content-Type": "application/json; charset=UTF-8",
-        },
-        data: {
-          prblmId: this.prblm_id.prblm_id,
-        },
-      })
-        .then((response) => {
-          this.problemData = response.data;
-          console.log("problemData", this.problemData);
+    // fetchProblemData() {
+    //   axios({
+    //     url: "/problem/problemInfo.json",
+    //     method: "post",
+    //     headers: {
+    //       "Content-Type": "application/json; charset=UTF-8",
+    //     },
+    //     data: {
+    //       prblmId: this.prblm_id.prblm_id,
+    //     },
+    //   })
+    //     .then((response) => {
+    //       this.problemData = response.data;
+    //       console.log("problemData", this.problemData);
 
-          this.sortingProblem();
-        })
-        .catch((error) => {
-          this.state = "noProblem";
-          console.error("Error fetching problemData:", error);
-        });
+    //       this.sortingProblem();
+    //     })
+    //     .catch((error) => {
+    //       this.state = "noProblem";
+    //       console.error("Error fetching problemData:", error);
+    //     });
+    // },
+
+    fetchProblemData() {
+      // 로컬 스토리지에서 currentDashboard를 확인
+      const savedState = localStorage.getItem("vuexState");
+      if (savedState) {
+        const parsedState = JSON.parse(savedState);
+        const currentDashboard = parsedState.currentDashboard;
+
+        if (currentDashboard === "AI") {
+          // AI 모드일 경우 로컬 스토리지에서 currentLearningId를 가져와 사용
+          const currentLearningId = parsedState.currentLearningIds;
+          console.log("AI 모드에서 currentLearningId 사용:", currentLearningId);
+
+          // currentLearningId로 문제 데이터 가져오기
+          axios({
+            url: "/problem/problemInfo.json",
+            method: "post",
+            headers: {
+              "Content-Type": "application/json; charset=UTF-8",
+            },
+            data: {
+              prblmId: currentLearningId, // 로컬스토리지에서 가져온 currentLearningId 사용
+            },
+          })
+            .then((response) => {
+              this.problemData = response.data;
+              console.log("AI 모드 problemData", this.problemData);
+              this.sortingProblem();
+            })
+            .catch((error) => {
+              this.state = "noProblem";
+              console.error("Error fetching AI problemData:", error);
+            });
+
+        } else {
+          // Learning 모드일 경우 기존 로직 사용
+          console.log("Learning 모드에서 prblm_id 사용:", this.prblm_id);
+
+          axios({
+            url: "/problem/problemInfo.json",
+            method: "post",
+            headers: {
+              "Content-Type": "application/json; charset=UTF-8",
+            },
+            data: {
+              prblmId: this.prblm_id.prblm_id, // 기존 방식 사용
+            },
+          })
+            .then((response) => {
+              this.problemData = response.data;
+              console.log("Learning 모드 problemData", this.problemData);
+              this.sortingProblem();
+            })
+            .catch((error) => {
+              this.state = "noProblem";
+              console.error("Error fetching problemData:", error);
+            });
+        }
+      } else {
+        console.error("vuexState가 로컬스토리지에 없습니다.");
+      }
     },
 
     sortingProblem() {

c4227a5

2e4c679

client/views/pages/main/Chapter/Chapter2_5.vue

--- client/views/pages/main/Chapter/Chapter2_5.vue

+++ client/views/pages/main/Chapter/Chapter2_5.vue


   computed: {},
   methods: {
     complete() {
-      const { unit_id, book_id } = this.$route.query;
-      this.$router.push({
-        name: "Dashboard",
-        query: { value: this.seq, unit_id, book_id },
-      });
+      // 로컬 스토리지에서 currentDashboard 값을 가져옴
+      const savedState = localStorage.getItem("vuexState");
+      if (savedState) {
+        const parsedState = JSON.parse(savedState);
+        const currentDashboard = parsedState.currentDashboard;
+
+        const { unit_id, book_id } = this.$route.query;
+        if (currentDashboard === "Learning") {
+          // Learning 모드일 때 Dashboard로 이동
+          this.$router.push({
+            name: "Dashboard",
+            query: { value: this.seq, unit_id, book_id },
+          });
+        } else if (currentDashboard === "AI") {
+          // AI 모드일 때 AIDashboard로 이동
+          this.$router.push({
+            name: "AIDashboard",
+            query: { value: this.seq, unit_id, book_id },
+          });
+        }
+      } else {
+        console.error("currentDashboard 값이 없습니다.");
+      }
     },
     goToPage(page) {
       this.$router.push({ name: page });

     returnPage() {
       window.location.reload();
     },
+    // async getProblem() {
+    //   const prblmId = this.currentLearningId.prblm_id;
+
+    //   try {
+    //     const res = await axios.post(
+    //       "problem/problemInfo.json",
+    //       {
+    //         prblmId: prblmId,
+    //       },
+    //       {
+    //         headers: {
+    //           "Content-Type": "application/json; charset=UTF-8",
+    //         },
+    //       }
+    //     );
+
+    //     console.log("problem - response : ", res.data);
+    //     this.dataList = res.data.problem;
+    //     this.problemDetail = res.data.problemDetail[0];
+    //     this.example = this.dataList.prblmExpln;
+    //     this.answer = this.problemDetail.prblmDtlExpln;
+    //     this.choice = this.answer ? this.shuffleString(this.answer) : "";
+    //     this.splitExample();
+    //     this.initializeUserAnswer();
+    //     this.choiceCharacters = this.choice.split("");
+
+    //     const fileInfo = await this.findFile(this.dataList.fileMngId);
+    //     if (fileInfo) {
+    //       this.imgUrl = "http://165.229.169.113:9080/" + fileInfo.fileRpath;
+    //       console.log(this.imgUrl);
+    //     } else {
+    //       console.warn("No file found for the given fileMngId.");
+    //     }
+    //   } catch (error) {
+    //     console.log("problem - error : ", error);
+    //   }
+    // },
+
     async getProblem() {
-      const prblmId = this.currentLearningId.prblm_id;
+      // 로컬 스토리지에서 currentDashboard를 확인
+      const savedState = localStorage.getItem("vuexState");
+      let prblmId = null;
+
+      if (savedState) {
+        const parsedState = JSON.parse(savedState);
+        const currentDashboard = parsedState.currentDashboard;
+
+        if (currentDashboard === "AI") {
+          // AI 모드일 경우 로컬 스토리지에서 currentLearningIds를 사용
+          prblmId = parsedState.currentLearningIds; // 로컬스토리지에서 가져온 currentLearningIds 사용
+          console.log("AI 모드에서 currentLearningIds 사용:", prblmId);
+        } else {
+          // Learning 모드일 경우 기존 방식 사용
+          prblmId = this.currentLearningId.prblm_id;
+          console.log("Learning 모드에서 currentLearningId 사용:", prblmId);
+        }
+      }
 
       try {
         const res = await axios.post(
           "problem/problemInfo.json",
           {
-            prblmId: prblmId,
+            prblmId: prblmId, // AI 모드 또는 Learning 모드에 따라 결정된 prblmId 사용
           },
           {
             headers: {
               "Content-Type": "application/json; charset=UTF-8",
-            },
+            }
           }
         );
 

         console.log("problem - error : ", error);
       }
     },
+
     shuffleString(string) {
       const array = string.split("");
       for (let i = array.length - 1; i > 0; i--) {

c4227a5

2e4c679

client/views/pages/main/Chapter/Chapter2_6.vue

--- client/views/pages/main/Chapter/Chapter2_6.vue

+++ client/views/pages/main/Chapter/Chapter2_6.vue


   },
   methods: {
     complete() {
-      const { unit_id, book_id } = this.$route.query;
-      this.$router.push({
-        name: "Dashboard",
-        query: { value: this.seq, unit_id, book_id },
-      });
+      // 로컬 스토리지에서 currentDashboard 값을 가져옴
+      const savedState = localStorage.getItem("vuexState");
+      if (savedState) {
+        const parsedState = JSON.parse(savedState);
+        const currentDashboard = parsedState.currentDashboard;
+
+        const { unit_id, book_id } = this.$route.query;
+        if (currentDashboard === "Learning") {
+          // Learning 모드일 때 Dashboard로 이동
+          this.$router.push({
+            name: "Dashboard",
+            query: { value: this.seq, unit_id, book_id },
+          });
+        } else if (currentDashboard === "AI") {
+          // AI 모드일 때 AIDashboard로 이동
+          this.$router.push({
+            name: "AIDashboard",
+            query: { value: this.seq, unit_id, book_id },
+          });
+        }
+      } else {
+        console.error("currentDashboard 값이 없습니다.");
+      }
     },
     goToPage(page) {
       this.$router.push({ name: page });

c4227a5

2e4c679

client/views/pages/main/Chapter/Chapter2_7.vue

--- client/views/pages/main/Chapter/Chapter2_7.vue

+++ client/views/pages/main/Chapter/Chapter2_7.vue


       problemData: [],
       problemArr: [],
       answerArr: [],
-
       seq: this.$store.getters.seqNum,
       hiddenState: false,
+      isAIMode: false, // AI 모드 여부를 확인할 변수
     };
   },
   methods: {
     complete() {
-      const { unit_id, book_id } = this.$route.query;
-      this.$router.push({
-        name: "Dashboard",
-        query: { value: this.seq, unit_id, book_id },
-      });
+      // 로컬 스토리지에서 currentDashboard 값을 가져옴
+      const savedState = localStorage.getItem("vuexState");
+      if (savedState) {
+        const parsedState = JSON.parse(savedState);
+        const currentDashboard = parsedState.currentDashboard;
+
+        const { unit_id, book_id } = this.$route.query;
+        if (currentDashboard === "Learning") {
+          // Learning 모드일 때 Dashboard로 이동
+          this.$router.push({
+            name: "Dashboard",
+            query: { value: this.seq, unit_id, book_id },
+          });
+        } else if (currentDashboard === "AI") {
+          // AI 모드일 때 AIDashboard로 이동
+          this.$router.push({
+            name: "AIDashboard",
+            query: { value: this.seq, unit_id, book_id },
+          });
+        }
+      } else {
+        console.error("currentDashboard 값이 없습니다.");
+      }
     },
     goToPage(page) {
       this.$router.push({ name: page });

       }
     },
 
+    // fetchProblemData() {
+    //   axios({
+    //     url: "/problem/problemInfo.json",
+    //     method: "post",
+    //     headers: {
+    //       "Content-Type": "application/json; charset=UTF-8",
+    //     },
+    //     data: {
+    //       prblmId: this.prblm_id.prblm_id,
+    //     },
+    //   })
+    //     .then((response) => {
+    //       this.problemData = response.data;
+    //       console.log("problemData", this.problemData);
+    //       this.sortingProblem();
+    //     })
+    //     .catch((error) => {
+    //       this.state = "noProblem";
+    //       console.error("Error fetching problemData:", error);
+    //     });
+    // },
+
     fetchProblemData() {
-      axios({
-        url: "/problem/problemInfo.json",
-        method: "post",
-        headers: {
-          "Content-Type": "application/json; charset=UTF-8",
-        },
-        data: {
-          prblmId: this.prblm_id.prblm_id,
-        },
-      })
-        .then((response) => {
-          this.problemData = response.data;
-          console.log("problemData", this.problemData);
-          this.sortingProblem();
-        })
-        .catch((error) => {
-          this.state = "noProblem";
-          console.error("Error fetching problemData:", error);
-        });
+      // 로컬 스토리지에서 currentDashboard를 확인
+      const savedState = localStorage.getItem("vuexState");
+      if (savedState) {
+        const parsedState = JSON.parse(savedState);
+        const currentDashboard = parsedState.currentDashboard;
+
+        if (currentDashboard === "AI") {
+          // AI 모드일 경우 로컬 스토리지에서 currentLearningId를 가져와 사용
+          const currentLearningId = parsedState.currentLearningIds;
+          console.log("AI 모드에서 currentLearningId 사용:", currentLearningId);
+
+          // currentLearningId로 문제 데이터 가져오기
+          axios({
+            url: "/problem/problemInfo.json",
+            method: "post",
+            headers: {
+              "Content-Type": "application/json; charset=UTF-8",
+            },
+            data: {
+              prblmId: currentLearningId, // 로컬스토리지에서 가져온 currentLearningId 사용
+            },
+          })
+            .then((response) => {
+              this.problemData = response.data;
+              console.log("AI 모드 problemData", this.problemData);
+              this.sortingProblem();
+            })
+            .catch((error) => {
+              this.state = "noProblem";
+              console.error("Error fetching AI problemData:", error);
+            });
+
+        } else {
+          // Learning 모드일 경우 기존 로직 사용
+          console.log("Learning 모드에서 prblm_id 사용:", this.prblm_id);
+
+          axios({
+            url: "/problem/problemInfo.json",
+            method: "post",
+            headers: {
+              "Content-Type": "application/json; charset=UTF-8",
+            },
+            data: {
+              prblmId: this.prblm_id.prblm_id, // 기존 방식 사용
+            },
+          })
+            .then((response) => {
+              this.problemData = response.data;
+              console.log("Learning 모드 problemData", this.problemData);
+              this.sortingProblem();
+            })
+            .catch((error) => {
+              this.state = "noProblem";
+              console.error("Error fetching problemData:", error);
+            });
+        }
+      } else {
+        console.error("vuexState가 로컬스토리지에 없습니다.");
+      }
     },
+
     sortingProblem() {
       let prblmExpln = this.problemData.problem.prblmExpln;
       let prblmArr = prblmExpln.split("/");

         this.handleProblemDetail(this.currentLearningId);
         this.goToPage(this.problemType);
       }
+    },
+
+    hideNavigationButtons() {
+      // pre-btn과 next-btn을 숨김
+      const preBtn = document.querySelector('.pre-btn');
+      const nextBtn = document.querySelector('.next-btn');
+      if (preBtn) preBtn.style.display = 'none';
+      if (nextBtn) nextBtn.style.display = 'none';
     },
 
     handleProblemDetail(item) {

         this.problemType = "Chapter2_13";
       }
     },
+    
   },
   computed: {
     currentLearningId() {

   },
   mounted() {
     this.fetchProblemData();
+    
+    // 로컬 스토리지에서 currentDashboard 값을 확인
+    const savedState = localStorage.getItem("vuexState");
+    if (savedState) {
+      const parsedState = JSON.parse(savedState);
+      const currentDashboard = parsedState.currentDashboard;
+
+      // AI 모드일 경우 pre-btn과 next-btn 숨기기
+      if (currentDashboard === "AI") {
+        this.isAIMode = true;
+        this.hideNavigationButtons();
+      }
+    }
+
     if (this.currentProblemIndex == 0) {
       this.hiddenState = true;
     }

c4227a5

2e4c679

client/views/pages/main/Chapter/Chapter2_8.vue

--- client/views/pages/main/Chapter/Chapter2_8.vue

+++ client/views/pages/main/Chapter/Chapter2_8.vue


   },
   methods: {
     complete() {
-      const { unit_id, book_id } = this.$route.query;
-      this.$router.push({
-        name: "Dashboard",
-        query: { value: this.seq, unit_id, book_id },
-      });
+      // 로컬 스토리지에서 currentDashboard 값을 가져옴
+      const savedState = localStorage.getItem("vuexState");
+      if (savedState) {
+        const parsedState = JSON.parse(savedState);
+        const currentDashboard = parsedState.currentDashboard;
+
+        const { unit_id, book_id } = this.$route.query;
+        if (currentDashboard === "Learning") {
+          // Learning 모드일 때 Dashboard로 이동
+          this.$router.push({
+            name: "Dashboard",
+            query: { value: this.seq, unit_id, book_id },
+          });
+        } else if (currentDashboard === "AI") {
+          // AI 모드일 때 AIDashboard로 이동
+          this.$router.push({
+            name: "AIDashboard",
+            query: { value: this.seq, unit_id, book_id },
+          });
+        }
+      } else {
+        console.error("currentDashboard 값이 없습니다.");
+      }
     },
     goToPage(page) {
       this.$router.push({ name: page });

       }
     },
 
+    // fetchProblemData() {
+    //   axios({
+    //     url: "/problem/problemInfo.json",
+    //     method: "post",
+    //     headers: {
+    //       "Content-Type": "application/json; charset=UTF-8",
+    //     },
+    //     data: {
+    //       prblmId: this.prblm_id.prblm_id,
+    //     },
+    //   })
+    //     .then((response) => {
+    //       this.problemData = response.data;
+    //       console.log("problemData", this.problemData);
+    //       this.sortingProblem();
+    //     })
+    //     .catch((error) => {
+    //       this.state = "noProblem";
+    //       console.error("Error fetching problemData:", error);
+    //     });
+    // },
+
     fetchProblemData() {
-      axios({
-        url: "/problem/problemInfo.json",
-        method: "post",
-        headers: {
-          "Content-Type": "application/json; charset=UTF-8",
-        },
-        data: {
-          prblmId: this.prblm_id.prblm_id,
-        },
-      })
-        .then((response) => {
-          this.problemData = response.data;
-          console.log("problemData", this.problemData);
-          this.sortingProblem();
-        })
-        .catch((error) => {
-          this.state = "noProblem";
-          console.error("Error fetching problemData:", error);
-        });
+      // 로컬 스토리지에서 currentDashboard를 확인
+      const savedState = localStorage.getItem("vuexState");
+      if (savedState) {
+        const parsedState = JSON.parse(savedState);
+        const currentDashboard = parsedState.currentDashboard;
+
+        if (currentDashboard === "AI") {
+          // AI 모드일 경우 로컬 스토리지에서 currentLearningId를 가져와 사용
+          const currentLearningId = parsedState.currentLearningIds;
+          console.log("AI 모드에서 currentLearningId 사용:", currentLearningId);
+
+          // currentLearningId로 문제 데이터 가져오기
+          axios({
+            url: "/problem/problemInfo.json",
+            method: "post",
+            headers: {
+              "Content-Type": "application/json; charset=UTF-8",
+            },
+            data: {
+              prblmId: currentLearningId, // 로컬스토리지에서 가져온 currentLearningId 사용
+            },
+          })
+            .then((response) => {
+              this.problemData = response.data;
+              console.log("AI 모드 problemData", this.problemData);
+              this.sortingProblem();
+            })
+            .catch((error) => {
+              this.state = "noProblem";
+              console.error("Error fetching AI problemData:", error);
+            });
+
+        } else {
+          // Learning 모드일 경우 기존 로직 사용
+          console.log("Learning 모드에서 prblm_id 사용:", this.prblm_id);
+
+          axios({
+            url: "/problem/problemInfo.json",
+            method: "post",
+            headers: {
+              "Content-Type": "application/json; charset=UTF-8",
+            },
+            data: {
+              prblmId: this.prblm_id.prblm_id, // 기존 방식 사용
+            },
+          })
+            .then((response) => {
+              this.problemData = response.data;
+              console.log("Learning 모드 problemData", this.problemData);
+              this.sortingProblem();
+            })
+            .catch((error) => {
+              this.state = "noProblem";
+              console.error("Error fetching problemData:", error);
+            });
+        }
+      } else {
+        console.error("vuexState가 로컬스토리지에 없습니다.");
+      }
     },
 
     sortingProblem() {

c4227a5

2e4c679

client/views/pages/main/Dashboard.vue

--- client/views/pages/main/Dashboard.vue

+++ client/views/pages/main/Dashboard.vue


     console.log("main mounted");
     this.checkAndFetchData();
     // const { book_id, unit_id } = this.$route.query;
+    console.log(">>>>>>>>>>>>>>>>>>>",this.$store.getters.currentDashboard);
   },
   watch: {
     getBookId(newBookId) {

c4227a5

2e4c679

client/views/pages/main/MyPlan.vue

--- client/views/pages/main/MyPlan.vue

+++ client/views/pages/main/MyPlan.vue


             Promise.all(updates)
                 .then(() => {
                     const schedule = this.schedules[startScheduleIndex];
+
+                    // 대시보드 위치 저장
+                    this.$store.dispatch('updateCurrentDashboard', 'Learning');
+                    
                     // this.$router.push({
                     //     name: page,
                     //     query: {

                     alert("학습 계획을 업데이트하는 중 오류가 발생했습니다.");
                 });
         },
+
         goToPage2(page, unit_id) {
+            this.$store.dispatch('updateCurrentDashboard', 'AI');
             this.$router.push({
                 name: page, query: {
                     unit_id: unit_id,

Add a comment

Open 0
Closed 0

List

...	...	@@ -37,6 +37,9 @@
37	37
38	38	// 순서
39	39	seqNum: null,
	40	+
	41	+ // 현재 대시보드
	42	+ currentDashboard: null,
40	43	};
41	44	}
42	45
...	...	@@ -87,6 +90,11 @@
87	90	return state.wdBookIdList;
88	91	},
89	92	getCurrentWdBkIndex: (state) => state.currentWdBkIndex,
	93	+
	94	+ // 대시보드 위치
	95	+ getCurrentDashboard(state) {
	96	+ return state.currentDashboard;
	97	+ }
90	98	},
91	99	mutations: {
92	100
...	...	@@ -114,6 +122,10 @@
114	122	state.wdBookIdList = [],
115	123	state.currentWdBkIndex = 0;
116	124	state.seqNum = null;
	125	+
	126	+ // 대시보드 위치
	127	+ state.currentDashboard = null;
	128	+
117	129	saveStateToLocalStorage(state);
118	130	},
119	131
...	...	@@ -168,6 +180,11 @@
168	180	state.prblmTypeId = payload.prblmTypeId;
169	181	// 순서
170	182	state.seqNum = payload.seqNum;
	183	+ saveStateToLocalStorage(state);
	184	+ },
	185	+ // 대시보드 위치
	186	+ setCurrentDashboard(state, currentDashboard) {
	187	+ state.currentDashboard = currentDashboard;
171	188	saveStateToLocalStorage(state);
172	189	},
173	190	incrementProblemIndex(state) {
...	...	@@ -293,5 +310,9 @@
293	310	// updateSeqNum({ commit }) {
294	311	// commit("setSeqNum", seqNum);
295	312	// },
	313	+
	314	+ updateCurrentDashboard({ commit }, dashboard) {
	315	+ commit("setCurrentDashboard", dashboard);
	316	+ },
296	317	},
297	318	});

...	...	@@ -138,11 +138,29 @@
138	138	},
139	139	methods: {
140	140	complete() {
141		- const { unit_id, book_id } = this.$route.query;
142		- this.$router.push({
143		- name: "Dashboard",
144		- query: { value: this.seq, unit_id, book_id },
145		- });
	141	+ // 로컬 스토리지에서 currentDashboard 값을 가져옴
	142	+ const savedState = localStorage.getItem("vuexState");
	143	+ if (savedState) {
	144	+ const parsedState = JSON.parse(savedState);
	145	+ const currentDashboard = parsedState.currentDashboard;
	146	+
	147	+ const { unit_id, book_id } = this.$route.query;
	148	+ if (currentDashboard === "Learning") {
	149	+ // Learning 모드일 때 Dashboard로 이동
	150	+ this.$router.push({
	151	+ name: "Dashboard",
	152	+ query: { value: this.seq, unit_id, book_id },
	153	+ });
	154	+ } else if (currentDashboard === "AI") {
	155	+ // AI 모드일 때 AIDashboard로 이동
	156	+ this.$router.push({
	157	+ name: "AIDashboard",
	158	+ query: { value: this.seq, unit_id, book_id },
	159	+ });
	160	+ }
	161	+ } else {
	162	+ console.error("currentDashboard 값이 없습니다.");
	163	+ }
146	164	},
147	165	goToPage(page) {
148	166	this.$router.push({ name: page });
...	...	@@ -244,27 +262,89 @@
244	262	}
245	263	},
246	264
247		- fetchProblemData() {
248		- axios({
249		- url: "/problem/problemInfo.json",
250		- method: "post",
251		- headers: {
252		- "Content-Type": "application/json; charset=UTF-8",
253		- },
254		- data: {
255		- prblmId: this.prblm_id.prblm_id,
256		- },
257		- })
258		- .then((response) => {
259		- this.problemData = response.data;
260		- console.log("problemData", this.problemData);
	265	+ // fetchProblemData() {
	266	+ // axios({
	267	+ // url: "/problem/problemInfo.json",
	268	+ // method: "post",
	269	+ // headers: {
	270	+ // "Content-Type": "application/json; charset=UTF-8",
	271	+ // },
	272	+ // data: {
	273	+ // prblmId: this.prblm_id.prblm_id,
	274	+ // },
	275	+ // })
	276	+ // .then((response) => {
	277	+ // this.problemData = response.data;
	278	+ // console.log("problemData", this.problemData);
261	279
262		- this.sortingProblem();
263		- })
264		- .catch((error) => {
265		- this.state = "noProblem";
266		- console.error("Error fetching problemData:", error);
267		- });
	280	+ // this.sortingProblem();
	281	+ // })
	282	+ // .catch((error) => {
	283	+ // this.state = "noProblem";
	284	+ // console.error("Error fetching problemData:", error);
	285	+ // });
	286	+ // },
	287	+
	288	+ fetchProblemData() {
	289	+ // 로컬 스토리지에서 currentDashboard를 확인
	290	+ const savedState = localStorage.getItem("vuexState");
	291	+ if (savedState) {
	292	+ const parsedState = JSON.parse(savedState);
	293	+ const currentDashboard = parsedState.currentDashboard;
	294	+
	295	+ if (currentDashboard === "AI") {
	296	+ // AI 모드일 경우 로컬 스토리지에서 currentLearningId를 가져와 사용
	297	+ const currentLearningId = parsedState.currentLearningIds;
	298	+ console.log("AI 모드에서 currentLearningId 사용:", currentLearningId);
	299	+
	300	+ // currentLearningId로 문제 데이터 가져오기
	301	+ axios({
	302	+ url: "/problem/problemInfo.json",
	303	+ method: "post",
	304	+ headers: {
	305	+ "Content-Type": "application/json; charset=UTF-8",
	306	+ },
	307	+ data: {
	308	+ prblmId: currentLearningId, // 로컬스토리지에서 가져온 currentLearningId 사용
	309	+ },
	310	+ })
	311	+ .then((response) => {
	312	+ this.problemData = response.data;
	313	+ console.log("AI 모드 problemData", this.problemData);
	314	+ this.sortingProblem();
	315	+ })
	316	+ .catch((error) => {
	317	+ this.state = "noProblem";
	318	+ console.error("Error fetching AI problemData:", error);
	319	+ });
	320	+
	321	+ } else {
	322	+ // Learning 모드일 경우 기존 로직 사용
	323	+ console.log("Learning 모드에서 prblm_id 사용:", this.prblm_id);
	324	+
	325	+ axios({
	326	+ url: "/problem/problemInfo.json",
	327	+ method: "post",
	328	+ headers: {
	329	+ "Content-Type": "application/json; charset=UTF-8",
	330	+ },
	331	+ data: {
	332	+ prblmId: this.prblm_id.prblm_id, // 기존 방식 사용
	333	+ },
	334	+ })
	335	+ .then((response) => {
	336	+ this.problemData = response.data;
	337	+ console.log("Learning 모드 problemData", this.problemData);
	338	+ this.sortingProblem();
	339	+ })
	340	+ .catch((error) => {
	341	+ this.state = "noProblem";
	342	+ console.error("Error fetching problemData:", error);
	343	+ });
	344	+ }
	345	+ } else {
	346	+ console.error("vuexState가 로컬스토리지에 없습니다.");
	347	+ }
268	348	},
269	349
270	350	sortingProblem() {

...	...	@@ -114,11 +114,29 @@
114	114	},
115	115	methods: {
116	116	complete() {
117		- const { unit_id, book_id } = this.$route.query;
118		- this.$router.push({
119		- name: "Dashboard",
120		- query: { value: this.seq, unit_id, book_id },
121		- });
	117	+ // 로컬 스토리지에서 currentDashboard 값을 가져옴
	118	+ const savedState = localStorage.getItem("vuexState");
	119	+ if (savedState) {
	120	+ const parsedState = JSON.parse(savedState);
	121	+ const currentDashboard = parsedState.currentDashboard;
	122	+
	123	+ const { unit_id, book_id } = this.$route.query;
	124	+ if (currentDashboard === "Learning") {
	125	+ // Learning 모드일 때 Dashboard로 이동
	126	+ this.$router.push({
	127	+ name: "Dashboard",
	128	+ query: { value: this.seq, unit_id, book_id },
	129	+ });
	130	+ } else if (currentDashboard === "AI") {
	131	+ // AI 모드일 때 AIDashboard로 이동
	132	+ this.$router.push({
	133	+ name: "AIDashboard",
	134	+ query: { value: this.seq, unit_id, book_id },
	135	+ });
	136	+ }
	137	+ } else {
	138	+ console.error("currentDashboard 값이 없습니다.");
	139	+ }
122	140	},
123	141	goToPage(page) {
124	142	this.$router.push({ name: page });
...	...	@@ -152,10 +170,63 @@
152	170	this.afterQuestion = parts[1];
153	171	}
154	172	},
	173	+ // getProblem() {
	174	+ // const vm = this;
	175	+ // const prblmId = this.prblm_id.prblm_id;
	176	+ // // const prblmId = "PROBLEM_000000000000076";
	177	+
	178	+ // axios({
	179	+ // url: "problem/problemInfo.json",
	180	+ // method: "post",
	181	+ // headers: {
	182	+ // "Content-Type": "application/json; charset=UTF-8",
	183	+ // },
	184	+ // data: {
	185	+ // prblmId: prblmId,
	186	+ // },
	187	+ // })
	188	+ // .then(function (res) {
	189	+ // console.log("problem - response : ", res.data);
	190	+ // vm.dataList = res.data.problem;
	191	+ // vm.problemDetail = res.data.problemDetail;
	192	+ // vm.example = vm.dataList.prblmExpln;
	193	+ // vm.problemDetail.forEach((detail, index) => {
	194	+ // vm.choice.push(detail.prblmDtlExpln);
	195	+ // if (detail.prblmYn === "Y") {
	196	+ // vm.answer = index + 1;
	197	+ // }
	198	+ // });
	199	+
	200	+ // console.log(vm.example);
	201	+ // console.log(vm.choice);
	202	+ // console.log(vm.answer);
	203	+ // vm.splitExample();
	204	+ // })
	205	+ // .catch(function (error) {
	206	+ // console.log("problem - error : ", error);
	207	+ // });
	208	+ // },
	209	+
155	210	getProblem() {
156	211	const vm = this;
157		- const prblmId = this.prblm_id.prblm_id;
158		- // const prblmId = "PROBLEM_000000000000076";
	212	+ let prblmId = null;
	213	+
	214	+ // 로컬 스토리지에서 currentDashboard를 확인
	215	+ const savedState = localStorage.getItem("vuexState");
	216	+ if (savedState) {
	217	+ const parsedState = JSON.parse(savedState);
	218	+ const currentDashboard = parsedState.currentDashboard;
	219	+
	220	+ if (currentDashboard === "AI") {
	221	+ // AI 모드일 때 로컬스토리지에서 currentLearningIds를 사용
	222	+ prblmId = parsedState.currentLearningIds; // currentLearningIds를 사용
	223	+ console.log("AI 모드에서 currentLearningIds 사용:", prblmId);
	224	+ } else {
	225	+ // Learning 모드일 때 기존 방식 사용
	226	+ prblmId = this.prblm_id.prblm_id; // 기존 방식
	227	+ console.log("Learning 모드에서 currentLearningId 사용:", prblmId);
	228	+ }
	229	+ }
159	230
160	231	axios({
161	232	url: "problem/problemInfo.json",
...	...	@@ -188,6 +259,7 @@
188	259	console.log("problem - error : ", error);
189	260	});
190	261	},
	262	+
191	263	nextProblem() {
192	264	if (
193	265	this.currentProblemIndex <

...	...	@@ -156,11 +156,29 @@
156	156	},
157	157	methods: {
158	158	complete() {
159		- const { unit_id, book_id } = this.$route.query;
160		- this.$router.push({
161		- name: "Dashboard",
162		- query: { value: this.seq, unit_id, book_id },
163		- });
	159	+ // 로컬 스토리지에서 currentDashboard 값을 가져옴
	160	+ const savedState = localStorage.getItem("vuexState");
	161	+ if (savedState) {
	162	+ const parsedState = JSON.parse(savedState);
	163	+ const currentDashboard = parsedState.currentDashboard;
	164	+
	165	+ const { unit_id, book_id } = this.$route.query;
	166	+ if (currentDashboard === "Learning") {
	167	+ // Learning 모드일 때 Dashboard로 이동
	168	+ this.$router.push({
	169	+ name: "Dashboard",
	170	+ query: { value: this.seq, unit_id, book_id },
	171	+ });
	172	+ } else if (currentDashboard === "AI") {
	173	+ // AI 모드일 때 AIDashboard로 이동
	174	+ this.$router.push({
	175	+ name: "AIDashboard",
	176	+ query: { value: this.seq, unit_id, book_id },
	177	+ });
	178	+ }
	179	+ } else {
	180	+ console.error("currentDashboard 값이 없습니다.");
	181	+ }
164	182	},
165	183	goToPage(page) {
166	184	this.$router.push({ name: page });
...	...	@@ -273,27 +291,89 @@
273	291	}
274	292	},
275	293
276		- fetchProblemData() {
277		- axios({
278		- url: "/problem/problemInfo.json",
279		- method: "post",
280		- headers: {
281		- "Content-Type": "application/json; charset=UTF-8",
282		- },
283		- data: {
284		- prblmId: this.prblm_id.prblm_id,
285		- },
286		- })
287		- .then((response) => {
288		- this.problemData = response.data;
289		- console.log("problemData", this.problemData);
	294	+ // fetchProblemData() {
	295	+ // axios({
	296	+ // url: "/problem/problemInfo.json",
	297	+ // method: "post",
	298	+ // headers: {
	299	+ // "Content-Type": "application/json; charset=UTF-8",
	300	+ // },
	301	+ // data: {
	302	+ // prblmId: this.prblm_id.prblm_id,
	303	+ // },
	304	+ // })
	305	+ // .then((response) => {
	306	+ // this.problemData = response.data;
	307	+ // console.log("problemData", this.problemData);
290	308
291		- this.sortingProblem();
292		- })
293		- .catch((error) => {
294		- this.state = "noProblem";
295		- console.error("Error fetching problemData:", error);
296		- });
	309	+ // this.sortingProblem();
	310	+ // })
	311	+ // .catch((error) => {
	312	+ // this.state = "noProblem";
	313	+ // console.error("Error fetching problemData:", error);
	314	+ // });
	315	+ // },
	316	+
	317	+ fetchProblemData() {
	318	+ // 로컬 스토리지에서 currentDashboard를 확인
	319	+ const savedState = localStorage.getItem("vuexState");
	320	+ if (savedState) {
	321	+ const parsedState = JSON.parse(savedState);
	322	+ const currentDashboard = parsedState.currentDashboard;
	323	+
	324	+ if (currentDashboard === "AI") {
	325	+ // AI 모드일 경우 로컬 스토리지에서 currentLearningId를 가져와 사용
	326	+ const currentLearningId = parsedState.currentLearningIds;
	327	+ console.log("AI 모드에서 currentLearningId 사용:", currentLearningId);
	328	+
	329	+ // currentLearningId로 문제 데이터 가져오기
	330	+ axios({
	331	+ url: "/problem/problemInfo.json",
	332	+ method: "post",
	333	+ headers: {
	334	+ "Content-Type": "application/json; charset=UTF-8",
	335	+ },
	336	+ data: {
	337	+ prblmId: currentLearningId, // 로컬스토리지에서 가져온 currentLearningId 사용
	338	+ },
	339	+ })
	340	+ .then((response) => {
	341	+ this.problemData = response.data;
	342	+ console.log("AI 모드 problemData", this.problemData);
	343	+ this.sortingProblem();
	344	+ })
	345	+ .catch((error) => {
	346	+ this.state = "noProblem";
	347	+ console.error("Error fetching AI problemData:", error);
	348	+ });
	349	+
	350	+ } else {
	351	+ // Learning 모드일 경우 기존 로직 사용
	352	+ console.log("Learning 모드에서 prblm_id 사용:", this.prblm_id);
	353	+
	354	+ axios({
	355	+ url: "/problem/problemInfo.json",
	356	+ method: "post",
	357	+ headers: {
	358	+ "Content-Type": "application/json; charset=UTF-8",
	359	+ },
	360	+ data: {
	361	+ prblmId: this.prblm_id.prblm_id, // 기존 방식 사용
	362	+ },
	363	+ })
	364	+ .then((response) => {
	365	+ this.problemData = response.data;
	366	+ console.log("Learning 모드 problemData", this.problemData);
	367	+ this.sortingProblem();
	368	+ })
	369	+ .catch((error) => {
	370	+ this.state = "noProblem";
	371	+ console.error("Error fetching problemData:", error);
	372	+ });
	373	+ }
	374	+ } else {
	375	+ console.error("vuexState가 로컬스토리지에 없습니다.");
	376	+ }
297	377	},
298	378
299	379	sortingProblem() {

...	...	@@ -135,11 +135,29 @@
135	135	computed: {},
136	136	methods: {
137	137	complete() {
138		- const { unit_id, book_id } = this.$route.query;
139		- this.$router.push({
140		- name: "Dashboard",
141		- query: { value: this.seq, unit_id, book_id },
142		- });
	138	+ // 로컬 스토리지에서 currentDashboard 값을 가져옴
	139	+ const savedState = localStorage.getItem("vuexState");
	140	+ if (savedState) {
	141	+ const parsedState = JSON.parse(savedState);
	142	+ const currentDashboard = parsedState.currentDashboard;
	143	+
	144	+ const { unit_id, book_id } = this.$route.query;
	145	+ if (currentDashboard === "Learning") {
	146	+ // Learning 모드일 때 Dashboard로 이동
	147	+ this.$router.push({
	148	+ name: "Dashboard",
	149	+ query: { value: this.seq, unit_id, book_id },
	150	+ });
	151	+ } else if (currentDashboard === "AI") {
	152	+ // AI 모드일 때 AIDashboard로 이동
	153	+ this.$router.push({
	154	+ name: "AIDashboard",
	155	+ query: { value: this.seq, unit_id, book_id },
	156	+ });
	157	+ }
	158	+ } else {
	159	+ console.error("currentDashboard 값이 없습니다.");
	160	+ }
143	161	},
144	162	goToPage(page) {
145	163	this.$router.push({ name: page });
...	...	@@ -188,19 +206,74 @@
188	206	returnPage() {
189	207	window.location.reload();
190	208	},
	209	+ // async getProblem() {
	210	+ // const prblmId = this.currentLearningId.prblm_id;
	211	+
	212	+ // try {
	213	+ // const res = await axios.post(
	214	+ // "problem/problemInfo.json",
	215	+ // {
	216	+ // prblmId: prblmId,
	217	+ // },
	218	+ // {
	219	+ // headers: {
	220	+ // "Content-Type": "application/json; charset=UTF-8",
	221	+ // },
	222	+ // }
	223	+ // );
	224	+
	225	+ // console.log("problem - response : ", res.data);
	226	+ // this.dataList = res.data.problem;
	227	+ // this.problemDetail = res.data.problemDetail[0];
	228	+ // this.example = this.dataList.prblmExpln;
	229	+ // this.answer = this.problemDetail.prblmDtlExpln;
	230	+ // this.choice = this.answer ? this.shuffleString(this.answer) : "";
	231	+ // this.splitExample();
	232	+ // this.initializeUserAnswer();
	233	+ // this.choiceCharacters = this.choice.split("");
	234	+
	235	+ // const fileInfo = await this.findFile(this.dataList.fileMngId);
	236	+ // if (fileInfo) {
	237	+ // this.imgUrl = "http://165.229.169.113:9080/" + fileInfo.fileRpath;
	238	+ // console.log(this.imgUrl);
	239	+ // } else {
	240	+ // console.warn("No file found for the given fileMngId.");
	241	+ // }
	242	+ // } catch (error) {
	243	+ // console.log("problem - error : ", error);
	244	+ // }
	245	+ // },
	246	+
191	247	async getProblem() {
192		- const prblmId = this.currentLearningId.prblm_id;
	248	+ // 로컬 스토리지에서 currentDashboard를 확인
	249	+ const savedState = localStorage.getItem("vuexState");
	250	+ let prblmId = null;
	251	+
	252	+ if (savedState) {
	253	+ const parsedState = JSON.parse(savedState);
	254	+ const currentDashboard = parsedState.currentDashboard;
	255	+
	256	+ if (currentDashboard === "AI") {
	257	+ // AI 모드일 경우 로컬 스토리지에서 currentLearningIds를 사용
	258	+ prblmId = parsedState.currentLearningIds; // 로컬스토리지에서 가져온 currentLearningIds 사용
	259	+ console.log("AI 모드에서 currentLearningIds 사용:", prblmId);
	260	+ } else {
	261	+ // Learning 모드일 경우 기존 방식 사용
	262	+ prblmId = this.currentLearningId.prblm_id;
	263	+ console.log("Learning 모드에서 currentLearningId 사용:", prblmId);
	264	+ }
	265	+ }
193	266
194	267	try {
195	268	const res = await axios.post(
196	269	"problem/problemInfo.json",
197	270	{
198		- prblmId: prblmId,
	271	+ prblmId: prblmId, // AI 모드 또는 Learning 모드에 따라 결정된 prblmId 사용
199	272	},
200	273	{
201	274	headers: {
202	275	"Content-Type": "application/json; charset=UTF-8",
203		- },
	276	+ }
204	277	}
205	278	);
206	279
...	...	@@ -225,6 +298,7 @@
225	298	console.log("problem - error : ", error);
226	299	}
227	300	},
	301	+
228	302	shuffleString(string) {
229	303	const array = string.split("");
230	304	for (let i = array.length - 1; i > 0; i--) {

...	...	@@ -153,11 +153,29 @@
153	153	},
154	154	methods: {
155	155	complete() {
156		- const { unit_id, book_id } = this.$route.query;
157		- this.$router.push({
158		- name: "Dashboard",
159		- query: { value: this.seq, unit_id, book_id },
160		- });
	156	+ // 로컬 스토리지에서 currentDashboard 값을 가져옴
	157	+ const savedState = localStorage.getItem("vuexState");
	158	+ if (savedState) {
	159	+ const parsedState = JSON.parse(savedState);
	160	+ const currentDashboard = parsedState.currentDashboard;
	161	+
	162	+ const { unit_id, book_id } = this.$route.query;
	163	+ if (currentDashboard === "Learning") {
	164	+ // Learning 모드일 때 Dashboard로 이동
	165	+ this.$router.push({
	166	+ name: "Dashboard",
	167	+ query: { value: this.seq, unit_id, book_id },
	168	+ });
	169	+ } else if (currentDashboard === "AI") {
	170	+ // AI 모드일 때 AIDashboard로 이동
	171	+ this.$router.push({
	172	+ name: "AIDashboard",
	173	+ query: { value: this.seq, unit_id, book_id },
	174	+ });
	175	+ }
	176	+ } else {
	177	+ console.error("currentDashboard 값이 없습니다.");
	178	+ }
161	179	},
162	180	goToPage(page) {
163	181	this.$router.push({ name: page });

...	...	@@ -120,18 +120,36 @@
120	120	problemData: [],
121	121	problemArr: [],
122	122	answerArr: [],
123		-
124	123	seq: this.$store.getters.seqNum,
125	124	hiddenState: false,
	125	+ isAIMode: false, // AI 모드 여부를 확인할 변수
126	126	};
127	127	},
128	128	methods: {
129	129	complete() {
130		- const { unit_id, book_id } = this.$route.query;
131		- this.$router.push({
132		- name: "Dashboard",
133		- query: { value: this.seq, unit_id, book_id },
134		- });
	130	+ // 로컬 스토리지에서 currentDashboard 값을 가져옴
	131	+ const savedState = localStorage.getItem("vuexState");
	132	+ if (savedState) {
	133	+ const parsedState = JSON.parse(savedState);
	134	+ const currentDashboard = parsedState.currentDashboard;
	135	+
	136	+ const { unit_id, book_id } = this.$route.query;
	137	+ if (currentDashboard === "Learning") {
	138	+ // Learning 모드일 때 Dashboard로 이동
	139	+ this.$router.push({
	140	+ name: "Dashboard",
	141	+ query: { value: this.seq, unit_id, book_id },
	142	+ });
	143	+ } else if (currentDashboard === "AI") {
	144	+ // AI 모드일 때 AIDashboard로 이동
	145	+ this.$router.push({
	146	+ name: "AIDashboard",
	147	+ query: { value: this.seq, unit_id, book_id },
	148	+ });
	149	+ }
	150	+ } else {
	151	+ console.error("currentDashboard 값이 없습니다.");
	152	+ }
135	153	},
136	154	goToPage(page) {
137	155	this.$router.push({ name: page });
...	...	@@ -174,27 +192,90 @@
174	192	}
175	193	},
176	194
	195	+ // fetchProblemData() {
	196	+ // axios({
	197	+ // url: "/problem/problemInfo.json",
	198	+ // method: "post",
	199	+ // headers: {
	200	+ // "Content-Type": "application/json; charset=UTF-8",
	201	+ // },
	202	+ // data: {
	203	+ // prblmId: this.prblm_id.prblm_id,
	204	+ // },
	205	+ // })
	206	+ // .then((response) => {
	207	+ // this.problemData = response.data;
	208	+ // console.log("problemData", this.problemData);
	209	+ // this.sortingProblem();
	210	+ // })
	211	+ // .catch((error) => {
	212	+ // this.state = "noProblem";
	213	+ // console.error("Error fetching problemData:", error);
	214	+ // });
	215	+ // },
	216	+
177	217	fetchProblemData() {
178		- axios({
179		- url: "/problem/problemInfo.json",
180		- method: "post",
181		- headers: {
182		- "Content-Type": "application/json; charset=UTF-8",
183		- },
184		- data: {
185		- prblmId: this.prblm_id.prblm_id,
186		- },
187		- })
188		- .then((response) => {
189		- this.problemData = response.data;
190		- console.log("problemData", this.problemData);
191		- this.sortingProblem();
192		- })
193		- .catch((error) => {
194		- this.state = "noProblem";
195		- console.error("Error fetching problemData:", error);
196		- });
	218	+ // 로컬 스토리지에서 currentDashboard를 확인
	219	+ const savedState = localStorage.getItem("vuexState");
	220	+ if (savedState) {
	221	+ const parsedState = JSON.parse(savedState);
	222	+ const currentDashboard = parsedState.currentDashboard;
	223	+
	224	+ if (currentDashboard === "AI") {
	225	+ // AI 모드일 경우 로컬 스토리지에서 currentLearningId를 가져와 사용
	226	+ const currentLearningId = parsedState.currentLearningIds;
	227	+ console.log("AI 모드에서 currentLearningId 사용:", currentLearningId);
	228	+
	229	+ // currentLearningId로 문제 데이터 가져오기
	230	+ axios({
	231	+ url: "/problem/problemInfo.json",
	232	+ method: "post",
	233	+ headers: {
	234	+ "Content-Type": "application/json; charset=UTF-8",
	235	+ },
	236	+ data: {
	237	+ prblmId: currentLearningId, // 로컬스토리지에서 가져온 currentLearningId 사용
	238	+ },
	239	+ })
	240	+ .then((response) => {
	241	+ this.problemData = response.data;
	242	+ console.log("AI 모드 problemData", this.problemData);
	243	+ this.sortingProblem();
	244	+ })
	245	+ .catch((error) => {
	246	+ this.state = "noProblem";
	247	+ console.error("Error fetching AI problemData:", error);
	248	+ });
	249	+
	250	+ } else {
	251	+ // Learning 모드일 경우 기존 로직 사용
	252	+ console.log("Learning 모드에서 prblm_id 사용:", this.prblm_id);
	253	+
	254	+ axios({
	255	+ url: "/problem/problemInfo.json",
	256	+ method: "post",
	257	+ headers: {
	258	+ "Content-Type": "application/json; charset=UTF-8",
	259	+ },
	260	+ data: {
	261	+ prblmId: this.prblm_id.prblm_id, // 기존 방식 사용
	262	+ },
	263	+ })
	264	+ .then((response) => {
	265	+ this.problemData = response.data;
	266	+ console.log("Learning 모드 problemData", this.problemData);
	267	+ this.sortingProblem();
	268	+ })
	269	+ .catch((error) => {
	270	+ this.state = "noProblem";
	271	+ console.error("Error fetching problemData:", error);
	272	+ });
	273	+ }
	274	+ } else {
	275	+ console.error("vuexState가 로컬스토리지에 없습니다.");
	276	+ }
197	277	},
	278	+
198	279	sortingProblem() {
199	280	let prblmExpln = this.problemData.problem.prblmExpln;
200	281	let prblmArr = prblmExpln.split("/");
...	...	@@ -245,6 +326,14 @@
245	326	this.handleProblemDetail(this.currentLearningId);
246	327	this.goToPage(this.problemType);
247	328	}
	329	+ },
	330	+
	331	+ hideNavigationButtons() {
	332	+ // pre-btn과 next-btn을 숨김
	333	+ const preBtn = document.querySelector('.pre-btn');
	334	+ const nextBtn = document.querySelector('.next-btn');
	335	+ if (preBtn) preBtn.style.display = 'none';
	336	+ if (nextBtn) nextBtn.style.display = 'none';
248	337	},
249	338
250	339	handleProblemDetail(item) {
...	...	@@ -298,6 +387,7 @@
298	387	this.problemType = "Chapter2_13";
299	388	}
300	389	},
	390	+
301	391	},
302	392	computed: {
303	393	currentLearningId() {
...	...	@@ -323,6 +413,20 @@
323	413	},
324	414	mounted() {
325	415	this.fetchProblemData();
	416	+
	417	+ // 로컬 스토리지에서 currentDashboard 값을 확인
	418	+ const savedState = localStorage.getItem("vuexState");
	419	+ if (savedState) {
	420	+ const parsedState = JSON.parse(savedState);
	421	+ const currentDashboard = parsedState.currentDashboard;
	422	+
	423	+ // AI 모드일 경우 pre-btn과 next-btn 숨기기
	424	+ if (currentDashboard === "AI") {
	425	+ this.isAIMode = true;
	426	+ this.hideNavigationButtons();
	427	+ }
	428	+ }
	429	+
326	430	if (this.currentProblemIndex == 0) {
327	431	this.hiddenState = true;
328	432	}

...	...	@@ -129,11 +129,29 @@
129	129	},
130	130	methods: {
131	131	complete() {
132		- const { unit_id, book_id } = this.$route.query;
133		- this.$router.push({
134		- name: "Dashboard",
135		- query: { value: this.seq, unit_id, book_id },
136		- });
	132	+ // 로컬 스토리지에서 currentDashboard 값을 가져옴
	133	+ const savedState = localStorage.getItem("vuexState");
	134	+ if (savedState) {
	135	+ const parsedState = JSON.parse(savedState);
	136	+ const currentDashboard = parsedState.currentDashboard;
	137	+
	138	+ const { unit_id, book_id } = this.$route.query;
	139	+ if (currentDashboard === "Learning") {
	140	+ // Learning 모드일 때 Dashboard로 이동
	141	+ this.$router.push({
	142	+ name: "Dashboard",
	143	+ query: { value: this.seq, unit_id, book_id },
	144	+ });
	145	+ } else if (currentDashboard === "AI") {
	146	+ // AI 모드일 때 AIDashboard로 이동
	147	+ this.$router.push({
	148	+ name: "AIDashboard",
	149	+ query: { value: this.seq, unit_id, book_id },
	150	+ });
	151	+ }
	152	+ } else {
	153	+ console.error("currentDashboard 값이 없습니다.");
	154	+ }
137	155	},
138	156	goToPage(page) {
139	157	this.$router.push({ name: page });
...	...	@@ -280,26 +298,88 @@
280	298	}
281	299	},
282	300
	301	+ // fetchProblemData() {
	302	+ // axios({
	303	+ // url: "/problem/problemInfo.json",
	304	+ // method: "post",
	305	+ // headers: {
	306	+ // "Content-Type": "application/json; charset=UTF-8",
	307	+ // },
	308	+ // data: {
	309	+ // prblmId: this.prblm_id.prblm_id,
	310	+ // },
	311	+ // })
	312	+ // .then((response) => {
	313	+ // this.problemData = response.data;
	314	+ // console.log("problemData", this.problemData);
	315	+ // this.sortingProblem();
	316	+ // })
	317	+ // .catch((error) => {
	318	+ // this.state = "noProblem";
	319	+ // console.error("Error fetching problemData:", error);
	320	+ // });
	321	+ // },
	322	+
283	323	fetchProblemData() {
284		- axios({
285		- url: "/problem/problemInfo.json",
286		- method: "post",
287		- headers: {
288		- "Content-Type": "application/json; charset=UTF-8",
289		- },
290		- data: {
291		- prblmId: this.prblm_id.prblm_id,
292		- },
293		- })
294		- .then((response) => {
295		- this.problemData = response.data;
296		- console.log("problemData", this.problemData);
297		- this.sortingProblem();
298		- })
299		- .catch((error) => {
300		- this.state = "noProblem";
301		- console.error("Error fetching problemData:", error);
302		- });
	324	+ // 로컬 스토리지에서 currentDashboard를 확인
	325	+ const savedState = localStorage.getItem("vuexState");
	326	+ if (savedState) {
	327	+ const parsedState = JSON.parse(savedState);
	328	+ const currentDashboard = parsedState.currentDashboard;
	329	+
	330	+ if (currentDashboard === "AI") {
	331	+ // AI 모드일 경우 로컬 스토리지에서 currentLearningId를 가져와 사용
	332	+ const currentLearningId = parsedState.currentLearningIds;
	333	+ console.log("AI 모드에서 currentLearningId 사용:", currentLearningId);
	334	+
	335	+ // currentLearningId로 문제 데이터 가져오기
	336	+ axios({
	337	+ url: "/problem/problemInfo.json",
	338	+ method: "post",
	339	+ headers: {
	340	+ "Content-Type": "application/json; charset=UTF-8",
	341	+ },
	342	+ data: {
	343	+ prblmId: currentLearningId, // 로컬스토리지에서 가져온 currentLearningId 사용
	344	+ },
	345	+ })
	346	+ .then((response) => {
	347	+ this.problemData = response.data;
	348	+ console.log("AI 모드 problemData", this.problemData);
	349	+ this.sortingProblem();
	350	+ })
	351	+ .catch((error) => {
	352	+ this.state = "noProblem";
	353	+ console.error("Error fetching AI problemData:", error);
	354	+ });
	355	+
	356	+ } else {
	357	+ // Learning 모드일 경우 기존 로직 사용
	358	+ console.log("Learning 모드에서 prblm_id 사용:", this.prblm_id);
	359	+
	360	+ axios({
	361	+ url: "/problem/problemInfo.json",
	362	+ method: "post",
	363	+ headers: {
	364	+ "Content-Type": "application/json; charset=UTF-8",
	365	+ },
	366	+ data: {
	367	+ prblmId: this.prblm_id.prblm_id, // 기존 방식 사용
	368	+ },
	369	+ })
	370	+ .then((response) => {
	371	+ this.problemData = response.data;
	372	+ console.log("Learning 모드 problemData", this.problemData);
	373	+ this.sortingProblem();
	374	+ })
	375	+ .catch((error) => {
	376	+ this.state = "noProblem";
	377	+ console.error("Error fetching problemData:", error);
	378	+ });
	379	+ }
	380	+ } else {
	381	+ console.error("vuexState가 로컬스토리지에 없습니다.");
	382	+ }
303	383	},
304	384
305	385	sortingProblem() {

...	...	@@ -1025,6 +1025,7 @@
1025	1025	console.log("main mounted");
1026	1026	this.checkAndFetchData();
1027	1027	// const { book_id, unit_id } = this.$route.query;
	1028	+ console.log(">>>>>>>>>>>>>>>>>>>",this.$store.getters.currentDashboard);
1028	1029	},
1029	1030	watch: {
1030	1031	getBookId(newBookId) {

...	...	@@ -249,6 +249,10 @@
249	249	Promise.all(updates)
250	250	.then(() => {
251	251	const schedule = this.schedules[startScheduleIndex];
	252	+
	253	+ // 대시보드 위치 저장
	254	+ this.$store.dispatch('updateCurrentDashboard', 'Learning');
	255	+
252	256	// this.$router.push({
253	257	// name: page,
254	258	// query: {
...	...	@@ -274,7 +278,9 @@
274	278	alert("학습 계획을 업데이트하는 중 오류가 발생했습니다.");
275	279	});
276	280	},
	281	+
277	282	goToPage2(page, unit_id) {
	283	+ this.$store.dispatch('updateCurrentDashboard', 'AI');
278	284	this.$router.push({
279	285	name: page, query: {
280	286	unit_id: unit_id,

Delete comment