fix: update

desc : update project

Project/Backend/Server_Node/controllers/curriculum.controller.js

@@ -71,7 +71,7 @@ export const deleteCurriculum = async (req, res) => {
     const { id } = req.params;
     try {
         await Curriculum.findByIdAndDelete(id);
-        res.status(200).json({ message: 'Curriculum deleted successfully' });
+        res.status(200).json({ _id: id, message: 'Curriculum deleted successfully' });
     } catch (error) {
         res.status(404).json({ message: 'Curriculum not found' });
     }

Project/Backend/Server_Node/controllers/tutorial.controller.js

@@ -21,42 +21,57 @@ export const getTutorialById = async (req, res) => {
 
 export const createTutorial = async (req, res) => {
     const tutorialData = req.body;
-    
+
     // Calculate total tutorial marks based on task item marks
     const totalTaskMarks = tutorialData.taskItems.reduce((total, task) => total + (task.taskItemMark || 0), 0);
     tutorialData.tutorialMarks = totalTaskMarks;
-    
+
     try {
         const newTutorial = new Tutorial(tutorialData);
         await newTutorial.save();
         res.status(201).json(newTutorial);
     } catch (error) {
-        res.status(400).json({ message: error.message });
+        res.status(500).json({ message: 'Failed to create tutorial', error: error.message });
     }
-}
+};
 
 export const updateTutorial = async (req, res) => {
     const { id } = req.params;
     const updatedTutorialData = req.body;
-    
+
     // Calculate total tutorial marks based on updated task item marks
     const totalTaskMarks = updatedTutorialData.taskItems.reduce((total, task) => total + (task.taskItemMark || 0), 0);
     updatedTutorialData.tutorialMarks = totalTaskMarks;
-    
+
     try {
-        const result = await Tutorial.findByIdAndUpdate(id, updatedTutorialData, { new: true });
-        res.status(200).json(result);
+        const tutorial = await Tutorial.findById(id);
+
+        if (!tutorial) {
+            return res.status(404).json({ message: 'Tutorial not found' });
+        }
+
+        // Update the tutorial with the new data
+        const updatedTutorial = await Tutorial.findByIdAndUpdate(id, updatedTutorialData, { new: true });
+
+        res.status(200).json(updatedTutorial);
     } catch (error) {
-        res.status(404).json({ message: 'Tutorial not found' });
+        res.status(500).json({ message: error.message });
     }
-}
+};
+
 
 export const deleteTutorial = async (req, res) => {
     const { id } = req.params;
     try {
+        const tutorial = await Tutorial.findById(id);
+        if (!tutorial) {
+            return res.status(404).json({ message: 'Tutorial not found' });
+        }
+
         await Tutorial.findByIdAndDelete(id);
-        res.status(200).json({ message: 'Tutorial deleted successfully' });
+        res.status(200).json({ _id: id, message: 'Tutorial deleted successfully' });
     } catch (error) {
-        res.status(404).json({ message: 'Tutorial not found' });
+        res.status(500).json({ message: error.message });
     }
-}
+};
+

Project/Frontend/SignConnectPlus/src/store/reducers/curriculum.ts

+// third-party
+import { createSlice } from '@reduxjs/toolkit';
+
+// project imports
+import { axiosServices } from 'utils/axios';
+import { dispatch } from '../index';
+
+// types
+import { Curriculum, DefaultRootStateProps } from 'types/curriculum';
+
+// ----------------------------------------------------------------------
+
+const initialState: DefaultRootStateProps['curriculum'] = {
+    error: null,
+    success: null,
+    curriculums: [],
+    curriculum: null,
+    isLoading: false
+};
+
+const slice = createSlice({
+    name: 'curriculum',
+    initialState,
+    reducers: {
+        // TO INITIAL STATE
+        hasInitialState(state) {
+            state.error = null;
+            state.success = null;
+            state.isLoading = false;
+        },
+
+        // HAS ERROR
+        hasError(state, action) {
+            state.error = action.payload;
+        },
+
+        startLoading(state) {
+            state.isLoading = true;
+        },
+
+        finishLoading(state) {
+            state.isLoading = false;
+        },
+
+        // POST CURRICULUM
+        addCurriculumSuccess(state, action) {
+            state.curriculums.push(action.payload);
+            state.success = "Curriculum created successfully."
+        },
+
+        // GET CURRICULUM
+        fetchCurriculumSuccess(state, action) {
+            state.curriculum = action.payload;
+            state.success = null
+        },
+
+        // GET ALL CURRICULUM
+        fetchCurriculumsSuccess(state, action) {
+            state.curriculums = action.payload;
+            state.success = null
+        },
+
+        // UPDATE CURRICULUM
+        updateCurriculumSuccess(state, action) {
+            const updatedCurriculumIndex = state.curriculums.findIndex(curriculum => curriculum._id === action.payload._id);
+            if (updatedCurriculumIndex !== -1) {
+                state.curriculums[updatedCurriculumIndex] = action.payload;
+            }
+            state.success = "Curriculum updated successfully."
+        },
+
+        // DELETE CURRICULUM
+        deleteCurriculumSuccess(state, action) {
+            state.curriculums = state.curriculums.filter(curriculum => curriculum._id !== action.payload._id);
+            state.success = "Curriculum deleted successfully."
+        },
+
+    }
+});
+
+// Reducer
+export default slice.reducer;
+
+// ----------------------------------------------------------------------
+
+/**
+ * TO INITIAL STATE
+ * @returns 
+ */
+export function toInitialState() {
+    return async () => {
+        dispatch(slice.actions.hasInitialState())
+    }
+}
+
+/**
+ * POST CURRICULUM
+ * @param newCurriculum 
+ * @returns 
+ */
+export function addCurriculum(newCurriculum: Curriculum) {
+    return async () => {
+        dispatch(slice.actions.startLoading());
+
+        try {
+            const response = await axiosServices.post('/rest_node/curriculum', newCurriculum);
+            dispatch(slice.actions.addCurriculumSuccess(response.data));
+        } catch (error) {
+            dispatch(slice.actions.hasError(error));
+        } finally {
+            dispatch(slice.actions.finishLoading());
+        }
+    };
+}
+
+/**
+ * GET CURRICULUM
+ * @param id 
+ * @returns 
+ */
+export function fetchCurriculum(id: number) {
+    return async () => {
+        dispatch(slice.actions.startLoading());
+
+        try {
+            const response = await axiosServices.get(`/rest_node/curriculum/${id}`);
+            dispatch(slice.actions.fetchCurriculumSuccess(response.data));
+        } catch (error) {
+            dispatch(slice.actions.hasError(error));
+        } finally {
+            dispatch(slice.actions.finishLoading());
+        }
+    };
+}
+
+/**
+ * GET ALL CURRICULUMS 
+ * @returns 
+ */
+export function fetchCurriculums() {
+    return async () => {
+        dispatch(slice.actions.startLoading());
+
+        try {
+            const response = await axiosServices.get('/rest_node/curriculum');
+            dispatch(slice.actions.fetchCurriculumsSuccess(response.data));
+        } catch (error) {
+            dispatch(slice.actions.hasError(error));
+        } finally {
+            dispatch(slice.actions.finishLoading());
+        }
+    };
+}
+
+/**
+ * UPDATE CURRICULUM
+ * @param updatedCurriculum 
+ * @returns 
+ */
+export function updateCurriculum(updatedCurriculum: Curriculum) {
+    return async () => {
+        dispatch(slice.actions.startLoading());
+
+        try {
+            const response = await axiosServices.put(`/rest_node/curriculum/${updatedCurriculum._id}`, updatedCurriculum);
+            dispatch(slice.actions.updateCurriculumSuccess(response.data));
+        } catch (error) {
+            dispatch(slice.actions.hasError(error));
+        } finally {
+            dispatch(slice.actions.finishLoading());
+        }
+    };
+}
+
+/**
+ * DELETE CURRICULUM
+ * @param curriculumId 
+ * @returns 
+ */
+export function deleteCurriculum(curriculumId: number) {
+    return async () => {
+        dispatch(slice.actions.startLoading());
+
+        try {
+            await axiosServices.delete(`/rest_node/curriculum/${curriculumId}`);
+            dispatch(slice.actions.deleteCurriculumSuccess(curriculumId));
+        } catch (error) {
+            dispatch(slice.actions.hasError(error));
+        } finally {
+            dispatch(slice.actions.finishLoading());
+        }
+    };
+}

Project/Frontend/SignConnectPlus/src/store/reducers/tutorial.ts

+// third-party
+import { createSlice } from '@reduxjs/toolkit';
+
+// project imports
+import { axiosServices } from 'utils/axios';
+import { dispatch } from '../index';
+
+// types
+import { DefaultRootStateProps, Tutorial } from 'types/tutorial';
+
+// ----------------------------------------------------------------------
+
+const initialState: DefaultRootStateProps['tutorial'] = {
+    error: null,
+    success: null,
+    tutorials: [],
+    tutorial: null,
+    isLoading: false
+};
+
+const slice = createSlice({
+    name: 'tutorial',
+    initialState,
+    reducers: {
+        // TO INITIAL STATE
+        hasInitialState(state) {
+            state.error = null;
+            state.success = null;
+            state.isLoading = false;
+        },
+
+        // HAS ERROR
+        hasError(state, action) {
+            state.error = action.payload;
+        },
+
+        startLoading(state) {
+            state.isLoading = true;
+        },
+
+        finishLoading(state) {
+            state.isLoading = false;
+        },
+
+        // POST TUTORIAL
+        addTutorialSuccess(state, action) {
+            state.tutorials.push(action.payload);
+            state.success = "Tutorial created successfully."
+        },
+
+        // GET TUTORIAL
+        fetchTutorialSuccess(state, action) {
+            state.tutorial = action.payload;
+            state.success = null
+        },
+
+        // GET ALL TUTORIAL
+        fetchTutorialsSuccess(state, action) {
+            state.tutorials = action.payload;
+            state.success = null
+        },
+
+        // UPDATE TUTORIAL
+        updateTutorialSuccess(state, action) {
+            const updatedTutorialIndex = state.tutorials.findIndex(tutorial => tutorial._id === action.payload._id);
+            if (updatedTutorialIndex !== -1) {
+                state.tutorials[updatedTutorialIndex] = action.payload;
+            }
+            state.success = "Tutorial updated successfully."
+        },
+
+        // DELETE TUTORIAL
+        deleteTutorialSuccess(state, action) {
+            state.tutorials = state.tutorials.filter(tutorial => tutorial._id !== action.payload._id);
+            state.success = "Tutorial deleted successfully."
+        },
+
+    }
+});
+
+// Reducer
+export default slice.reducer;
+
+// ----------------------------------------------------------------------
+
+/**
+ * TO INITIAL STATE
+ * @returns 
+ */
+export function toInitialState() {
+    return async () => {
+        dispatch(slice.actions.hasInitialState())
+    }
+}
+
+/**
+ * POST TUTORIAL
+ * @param newTutorial 
+ * @returns 
+ */
+export function addTutorial(newTutorial: Tutorial) {
+    return async () => {
+        dispatch(slice.actions.startLoading());
+
+        try {
+            const response = await axiosServices.post('/rest_node/tutorial', newTutorial);
+            dispatch(slice.actions.addTutorialSuccess(response.data));
+        } catch (error) {
+            dispatch(slice.actions.hasError(error));
+        } finally {
+            dispatch(slice.actions.finishLoading());
+        }
+    };
+}
+
+/**
+ * GET TUTORIAL
+ * @param id 
+ * @returns 
+ */
+export function fetchTutorial(id: number) {
+    return async () => {
+        dispatch(slice.actions.startLoading());
+
+        try {
+            const response = await axiosServices.get(`/rest_node/tutorial/${id}`);
+            dispatch(slice.actions.fetchTutorialSuccess(response.data));
+        } catch (error) {
+            dispatch(slice.actions.hasError(error));
+        } finally {
+            dispatch(slice.actions.finishLoading());
+        }
+    };
+}
+
+/**
+ * GET ALL TUTORIALS 
+ * @returns 
+ */
+export function fetchTutorials() {
+    return async () => {
+        dispatch(slice.actions.startLoading());
+
+        try {
+            const response = await axiosServices.get('/rest_node/tutorial');
+            dispatch(slice.actions.fetchTutorialsSuccess(response.data));
+        } catch (error) {
+            dispatch(slice.actions.hasError(error));
+        } finally {
+            dispatch(slice.actions.finishLoading());
+        }
+    };
+}
+
+/**
+ * UPDATE TUTORIAL
+ * @param updatedTutorial 
+ * @returns 
+ */
+export function updateTutorial(updatedTutorial: Tutorial) {
+    return async () => {
+        dispatch(slice.actions.startLoading());
+
+        try {
+            const response = await axiosServices.put(`/rest_node/tutorial/${updatedTutorial._id}`, updatedTutorial);
+            dispatch(slice.actions.updateTutorialSuccess(response.data));
+        } catch (error) {
+            dispatch(slice.actions.hasError(error));
+        } finally {
+            dispatch(slice.actions.finishLoading());
+        }
+    };
+}
+
+/**
+ * DELETE TUTORIAL
+ * @param tutorialId 
+ * @returns 
+ */
+export function deleteTutorial(tutorialId: number) {
+    return async () => {
+        dispatch(slice.actions.startLoading());
+
+        try {
+            await axiosServices.delete(`/rest_node/tutorial/${tutorialId}`);
+            dispatch(slice.actions.deleteTutorialSuccess(tutorialId));
+        } catch (error) {
+            dispatch(slice.actions.hasError(error));
+        } finally {
+            dispatch(slice.actions.finishLoading());
+        }
+    };
+}

Project/Frontend/SignConnectPlus/src/types/curriculum.ts

@@ -14,4 +14,49 @@ export interface curriculumType {
     createdAt: Date
     updatedBy?: string
     updatedAt?: Date
+}
+
+export type Curriculum = {
+    _id?: string
+    curriculumCode: string
+    curriculumLevel: number
+    curriculumTitle: string
+    curriculumDescription: string
+    curriculumImage: string
+    curriculumMark: number
+    tutorials: tutorialType[],
+    status: number
+    createdBy: string
+    createdAt: Date
+    updatedBy?: string
+    updatedAt?: Date
+};
+
+export type Curriculums = {
+    _id?: string
+    curriculumCode: string
+    curriculumLevel: number
+    curriculumTitle: string
+    curriculumDescription: string
+    curriculumImage: string
+    curriculumMark: number
+    tutorials: tutorialType[],
+    status: number
+    createdBy: string
+    createdAt: Date
+    updatedBy?: string
+    updatedAt?: Date
+};
+
+
+export interface CurriculumStateProps {
+    curriculums: Curriculums[];
+    curriculum: Curriculum | null;
+    error: object | string | null;
+    success: object | string | null;
+    isLoading: boolean
+}
+
+export interface DefaultRootStateProps {
+    curriculum: CurriculumStateProps;
 }
\ No newline at end of file

Project/Frontend/SignConnectPlus/src/types/tutorial.ts

@@ -13,4 +13,47 @@ export interface tutorialType {
     createdAt: Date
     updatedBy?: string
     updatedAt?: Date
+}
+
+export type Tutorial = {
+    _id?: string
+    tutorialCode?: string
+    tutorialTitle?: string
+    tutorialDescription?: string
+    tutorialImage?: string
+    tutorialMark: number
+    taskItems: taskItemType[]
+    status: number
+    createdBy: string
+    createdAt: Date
+    updatedBy?: string
+    updatedAt?: Date
+};
+
+export type Tutorials = {
+    _id?: string
+    tutorialCode?: string
+    tutorialTitle?: string
+    tutorialDescription?: string
+    tutorialImage?: string
+    tutorialMark: number
+    taskItems: taskItemType[]
+    status: number
+    createdBy: string
+    createdAt: Date
+    updatedBy?: string
+    updatedAt?: Date
+};
+
+
+export interface TutorialStateProps {
+    tutorials: Tutorials[];
+    tutorial: Tutorial | null;
+    error: object | string | null;
+    success: object | string | null;
+    isLoading: boolean
+}
+
+export interface DefaultRootStateProps {
+    tutorial: TutorialStateProps;
 }
\ No newline at end of file