requirement add

app.js

@@ -49,4 +49,8 @@ app.use("/api", cmpRistriction);
 //feedback
 import feedback from "./routes/feedbackRoute.js"
 app.use("/api", feedback);
+
+//feedback
+import requirement from "./routes/RequirementRoute.js"
+app.use("/api", requirement);
 export default app;

controllers/NewsController.js

@@ -8,7 +8,7 @@ export const createNews = async (req, res) => {
     try {
         const files = req.files.image;
 
-        // console.log(files)
+        console.log(files.tempFilePath)
         const myCloud = await cloudinary.uploader.upload(files.tempFilePath, {
             folder: "cmp/News",
         },

controllers/RequirementController.js

@@ -0,0 +1,191 @@
+import RequirementModel from "../models/RequirementModel.js"
+import cloudinary from "cloudinary";
+// import cloudinary from "../Utils/cloudinary.js"
+//import { v2 as cloudinary } from 'cloudinary'
+
+export const createRequirement = async (req, res) => {
+
+    try {
+        let images = [];
+        let Allfiles = req.files.image;
+        // console.log(typeof Allfiles.tempFilePath)
+        if (typeof Allfiles.tempFilePath === "string") {
+            let filepath = Allfiles.tempFilePath;
+            // console.log(filepath)
+            images.push(filepath)
+        } else {
+            Allfiles.map(item => {
+                images.push(item.tempFilePath);
+            })
+        }
+        // console.log(images.length)
+        const imagesLinks = [];
+        for (let i = 0; i < images.length; i++) {
+            const result = await cloudinary.v2.uploader.upload(images[i], {
+                folder: "cmp",
+            });
+
+            imagesLinks.push({
+                public_id: result.public_id,
+                url: result.secure_url,
+            });
+        }
+
+
+        req.body.image = imagesLinks;
+        req.body.addedBy = req.user.id;
+
+        const Requirement = await RequirementModel.create(req.body);
+        res.status(201).json({
+            success: true,
+            msg: " create Requirement Successfully!!",
+            Requirement,
+        });
+    } catch (error) {
+        res.status(500).json({
+            success: false,
+            msg: "Failled to create !!"
+        });
+    }
+
+};
+//get All Requirement
+export const getAllRequirement = async (req, res) => {
+
+    try {
+        const Requirement = await RequirementModel.find();
+        // console.log(news)
+        res.status(200).json({
+            success: true,
+            msg: " fetch  Successfully!!",
+            Requirement,
+        });
+    } catch (error) {
+        res.status(500).json({
+            success: false,
+            msg: "Failled to fetch !!"
+        });
+    }
+
+};
+//get One Requirement
+export const getOneRequirement = async (req, res) => {
+
+    try {
+        const Requirement = await RequirementModel.findById(req.params.id);
+        // console.log(news)
+        res.status(200).json({
+            success: true,
+            msg: " fetch  Successfully!!",
+            Requirement,
+        });
+    } catch (error) {
+        // console.log(error)
+        res.status(500).json({
+            success: false,
+            msg: "Failled to fetch !!"
+        });
+    }
+
+};
+
+// 3.update Requirement
+export const updateRequirement = async (req, res) => {
+    try {
+        const Requirement = await RequirementModel.findById(req.params.id);
+        if (!Requirement) {
+            return res.status(400).json({ message: 'Requirement Not Found' });
+        }
+        //handle image------------------------------------------------------------
+        let images = [];
+        let Allfiles = req.files.image;
+        // console.log(typeof Allfiles.tempFilePath)
+        if (typeof Allfiles.tempFilePath === "string") {
+            let filepath = Allfiles.tempFilePath;
+            // console.log(filepath)
+            images.push(filepath)
+        } else {
+            Allfiles.map(item => {
+                images.push(item.tempFilePath);
+            })
+        }
+
+
+        if (images !== undefined) {
+            // Deleting Images From Cloudinary
+            for (let i = 0; i < Requirement.image.length; i++) {
+                await cloudinary.v2.uploader.destroy(Requirement.image[i].public_id);
+            }
+
+            const imagesLinks = [];
+
+            for (let i = 0; i < images.length; i++) {
+                const result = await cloudinary.v2.uploader.upload(images[i], {
+                    folder: "cmp",
+                });
+
+                imagesLinks.push({
+                    public_id: result.public_id,
+                    url: result.secure_url,
+                });
+            }
+
+            req.body.image = imagesLinks;
+        }
+        // ------------------------------------------------------------------------
+
+        const ModifyRequirement = await RequirementModel.findByIdAndUpdate(req.params.id, req.body,
+
+            {
+                new: true,
+                runValidators: true,
+                useFindAndModify: false
+            }
+
+        );
+
+        res.status(200).json({
+            success: true,
+            ModifyRequirement
+        });
+
+    } catch (error) {
+        // console.log(error)
+        res.status(500).json({
+            success: false,
+            msg: "Failled to UpDate !!"
+
+        });
+    }
+
+};
+
+//delete one Requirement
+export const deleteOneRequirement = async (req, res) => {
+
+    try {
+        const findRequirement = await RequirementModel.findById(req.params.id);
+
+        if (!findRequirement) {
+            return res.status(400).json({ message: 'Requirement Not Found' });
+        }
+        // Deleting Images From Cloudinary
+        for (let i = 0; i < findRequirement.image.length; i++) {
+            await cloudinary.v2.uploader.destroy(findRequirement.image[i].public_id);
+        }
+
+
+        await findRequirement.remove();
+        res.status(200).json({
+            success: true,
+            msg: "Requirement Deleted Successfully!!",
+            // news,
+        });
+    } catch (error) {
+        res.status(500).json({
+            success: false,
+            msg: "Failled to Delete !!"
+        });
+    }
+
+};

models/RequirementModel.js

@@ -0,0 +1,40 @@
+import mongoose from "mongoose"
+const RequirementSchema = new mongoose.Schema(
+    {
+        title: {
+            type: String,
+            required: true
+        },
+        areaOfInterest: {
+            type: String,
+            required: true
+        },
+
+        image: [
+            {
+                public_id: {
+                    type: String,
+                    required: true,
+                },
+                url: {
+                    type: String,
+                    required: true,
+                },
+            },
+        ],
+
+        description: {
+            type: String,
+            required: true
+        },
+
+        addedBy: {
+            type: mongoose.Schema.ObjectId,
+            ref: "User",
+            required: true,
+        },
+
+    }, { timestamps: true }
+);
+const RequirementModel = mongoose.model("Requirement", RequirementSchema);
+export default RequirementModel;

routes/RequirementRoute.js

@@ -0,0 +1,17 @@
+import express from "express";
+import {
+    createRequirement,
+    getAllRequirement,
+    getOneRequirement,
+    updateRequirement,
+    deleteOneRequirement
+} from "../controllers/RequirementController.js"
+import { isAuthenticatedUser, authorizeRoles } from "../middlewares/auth.js"
+const router = express.Router();
+
+router.route("/requirement/create/").post(isAuthenticatedUser, createRequirement)
+router.route("/requirement/getAll/").get(isAuthenticatedUser, getAllRequirement)
+router.route("/requirement/getOne/:id").get(isAuthenticatedUser, getOneRequirement)
+router.route("/requirement/update/:id").put(isAuthenticatedUser, updateRequirement);
+router.route("/requirement/delete/:id").delete(isAuthenticatedUser, deleteOneRequirement);
+export default router;

server.js

@@ -4,7 +4,7 @@ dotenv.config()
 import app from "./app.js"
 import connectDatabase from "./database/db.js";
 import cloudinary from "cloudinary"
-// const PORT = 5000;
+
 // Connecting to database
 connectDatabase();