temple

.gitignore

@@ -1,3 +1,4 @@
 node_modules
 .env
-tmp
+tmp
+tmp/

app.js

@@ -23,6 +23,10 @@ app.use(fileUpload({
 //auth
 import user from "./resources/user/userRoute.js"
 app.use("/api/v1/", user);
+
+//Temple
+import TempleRouter from "./resources/Temple/TempleRoute.js";
+app.use("/api/temple", TempleRouter);
 //state
 import StateRouter from "./resources/setting/state/state_routes.js";
 app.use("/api/state", StateRouter);

resources/Temple/TempleModel.js

@@ -0,0 +1,26 @@
+import mongoose from "mongoose";
+const { Schema, model } = mongoose;
+
+const TempleSchema = new Schema(
+    {
+        name: { type: String, default: "" },
+
+        address_line_1: { type: String, default: "" },
+        address_line_2: { type: String, default: "" },
+
+        city: { type: mongoose.Schema.ObjectId, ref: "City" },
+
+        products: [
+            {
+                type: mongoose.Schema.ObjectId,
+                ref: "Product",
+            },
+        ],
+        url: { type: String, default: "" },
+        short_url: { type: String, default: "" },
+        banner: { type: Object, default: { url: "", public_id: "" } },
+    },
+    { timestamps: true }
+);
+
+export const Temple = model("Temple", TempleSchema);

resources/Temple/TempleRoute.js

@@ -0,0 +1,30 @@
+import { Router } from "express";
+const router = Router();
+import {
+    addTemple,
+    getAllTemples,
+    getTempleById,
+    updateTemple,
+    deleteTempleById,
+    getTempleByIdWithoutPopulate,
+    getAllTemplesPopulated,
+    // getAllTemplesPopulatedWithOption,
+    addProductToTemple,
+    // addGradeToTemple,
+    getTempleByIdPopulated,
+} from "./Temple_controller.js";
+import { authorizeRoles, isAuthenticatedUser } from "../../middlewares/auth.js";
+
+router.get("/", getAllTemples);
+router.get("/withpopulate", isAuthenticatedUser, getAllTemplesPopulated);
+// router.get("/withpopulate/:option", getAllTemplesPopulatedWithOption);
+router.get("/withoutpopulate/:id", isAuthenticatedUser, getTempleByIdWithoutPopulate);
+router.get("/:id", isAuthenticatedUser, getTempleById);
+router.get("/arrayspopulate/:id", getTempleByIdPopulated);
+router.post("/", isAuthenticatedUser, authorizeRoles("admin"), addTemple);
+router.patch("/product/:id", isAuthenticatedUser, addProductToTemple);
+// router.patch("/grade/:id", addGradeToTemple);
+router.patch("/:id", isAuthenticatedUser, authorizeRoles("admin"), updateTemple);
+router.delete("/:id", isAuthenticatedUser, authorizeRoles("admin"), deleteTempleById);
+
+export default router;

resources/Temple/Temple_controller.js

@@ -0,0 +1,298 @@
+import { Temple } from "./TempleModel.js";
+
+import cloudinary from "../../Utils/cloudinary.js";
+import fs from "fs";
+import mongoose from "mongoose";
+
+const addTemple = async (req, res) => {
+    const image_file = req?.files?.image;
+    try {
+        const TempleWithURL = await Temple.findOne({
+            short_url: req.body?.short_url,
+        });
+        if (TempleWithURL?._id) {
+            if (req?.files?.image?.tempFilePath)
+                fs.unlinkSync(image_file?.tempFilePath);
+            return res.status(400).json({ message: "Temple URL is not available!" });
+        }
+        if (image_file?.tempFilePath) {
+            const result = await cloudinary.v2.uploader.upload(
+                image_file?.tempFilePath,
+                {
+                    folder: "ATP/Temple_banners",
+                }
+            );
+            const image = { url: result?.secure_url, public_id: result?.public_id };
+            req.body.banner = image;
+            fs.unlinkSync(image_file?.tempFilePath);
+        }
+        const entity = await Temple.create(req.body);
+        res.status(200).json({ status: "OK", data: entity });
+    } catch (err) {
+        fs.unlinkSync(image_file?.tempFilePath);
+        return res.status(500).json({ message: "Unable to create." });
+    }
+};
+
+const addProductToTemple = async (req, res) => {
+    try {
+        const Temple = await Temple.findByIdAndUpdate(
+            req.params.id,
+            {
+                $push: { products: req.body.product_id },
+            },
+            { new: true }
+        );
+        res
+            .status(200)
+            .json({ status: "ok", message: "Product added to Temple successfully" });
+    } catch (err) {
+        return res.status(500).json({ message: "Unable to get ID." });
+    }
+};
+
+
+
+const getTempleById = async (req, res) => {
+    try {
+        const entity = await Temple.findById(req.params.id)
+            .populate("city")
+            .populate("products");
+        return res.status(200).json({ status: "OK", data: entity });
+    } catch (err) {
+        console.log(err);
+        return res.status(500).json({ message: "Unable to get menu items." });
+    }
+};
+
+const getTempleByIdPopulated = async (req, res) => {
+    try {
+        const entity = await Temple.findById(req.params.id).populate({
+            // path: "grades sections houses",
+            sort: "name",
+        });
+        const newId = new mongoose.Types.ObjectId();
+        return res.status(200).json({ status: "OK", data: entity, _id: newId });
+    } catch (err) {
+        return res.status(500).json({ message: "Unable to get menu items." });
+    }
+};
+
+const getTempleByIdWithoutPopulate = async (req, res) => {
+    try {
+        const entity = await Temple.findById(req.params.id);
+        return res.status(200).json({ status: "OK", data: entity });
+    } catch (err) {
+        console.log(err);
+        return res.status(500).json({ message: "Unable to get menu items." });
+    }
+};
+
+const getAllTemples = async (req, res) => {
+    try {
+        const entity = await Temple.find({}).populate("city");
+        return res.status(200).json({ status: "OK", data: entity });
+    } catch (err) {
+        return res.status(500).json({ message: "Unable to get menu items." });
+    }
+};
+
+const getAllTemplesPopulated = async (req, res) => {
+    try {
+        const entity = await Temple.find({})
+            .populate("city");
+        return res.status(200).json({ status: "OK", data: entity });
+    } catch (err) {
+        return res.status(500).json({ message: "Unable to get menu items." });
+    }
+};
+
+
+
+const updateTemple = async (req, res) => {
+    const image_file = req?.files?.image;
+    try {
+        const TempleWithURL = await Temple.findOne({
+            short_url: req.body?.short_url,
+        });
+        if (
+            TempleWithURL?._id &&
+            TempleWithURL?._id?.toString() !== req.params.id
+        ) {
+            if (req?.files?.image?.tempFilePath)
+                fs.unlinkSync(image_file?.tempFilePath);
+            return res.status(400).json({ message: "Temple URL is not available!" });
+        }
+        const getTemple = await Temple.findById(req.params.id);
+        if (image_file?.tempFilePath) {
+            if (getTemple?.banner) {
+                const imageId = getTemple?.banner?.public_id;
+
+                await cloudinary.uploader.destroy(imageId)
+            }
+            const result = await cloudinary.v2.uploader.upload(
+                image_file?.tempFilePath,
+                {
+                    folder: "ATP/Temple_banners",
+                }
+            );
+            const image = { url: result?.secure_url, public_id: result?.public_id };
+            req.body.banner = image;
+            fs.unlinkSync(image_file?.tempFilePath);
+            await cloudinary.v2.uploader.destroy(getTemple.banner.public_id);
+        }
+        const entity = await Temple.findByIdAndUpdate(req.params.id, req.body);
+        res.status(200).json({ status: "OK", data: entity });
+    } catch (err) {
+        console.log(err);
+        if (req?.files?.image?.tempFilePath)
+            fs.unlinkSync(image_file?.tempFilePath);
+        return res.status(500).json({ message: "Unable to create." });
+    }
+};
+
+const deleteTempleById = async (req, res) => {
+    try {
+        const findTemple = await Temple.findById(req.params.id);
+        if (findTemple?.banner?.public_id)
+            await cloudinary.v2.uploader.destroy(findTemple?.banner?.public_id);
+
+
+        const temple = await Temple.findByIdAndDelete(req.params.id)
+        if (!temple) {
+            return res.status(400).json({ message: 'temple Not Found' });
+        }
+        await temple.remove();
+
+        res.status(200).json({ status: "OK", msg: 'Deteted successfully' });
+    } catch (err) {
+        return res.status(500).json({ message: err.message ? err.message : "Unable to delete." });
+    }
+};
+
+//website requests
+const findTempleByURL = async (req, res) => {
+    try {
+        const entity = await Temple.findOne({ short_url: req.params.url })
+            .populate({
+                path: "city",
+                select: "city_name state -_id",
+                populate: {
+                    path: "state",
+                    select: "state_name state_code -_id",
+                },
+            })
+            .select(
+                " -products -url -short_url -state_name -createdAt -updatedAt"
+            );
+        if (entity?._id) {
+            return res.status(200).json({ status: "OK", data: entity });
+        } else {
+            return res.status(404).json({ message: "Temple not found" });
+        }
+    } catch (err) {
+        console.log(err);
+        return res.status(500).json({ message: "Temple not found" });
+    }
+};
+
+// const getTempleProductsForChild = async (req, res) => {
+//     try {
+//         const Temple = await Temple.findById(req.parent.Temple);
+//         if (!Temple?.option)
+//             return res.status(400).json({ message: "No option selected by Temple!" });
+
+//         const child = await Student.findById(req.params.id);
+//         if (!child?._id)
+//             return res.status(400).json({ message: "Child not found!" });
+
+//         if (Temple.option === "group") {
+//             const groups = await Group.find({
+//                 Temple: req.parent.Temple,
+//                 gender: child.gender,
+//                 grades: { $in: child.grade },
+//                 house: child.house,
+//             })
+//                 .populate({
+//                     path: "grades house",
+//                     select: "name",
+//                 })
+//                 .populate({
+//                     path: "products",
+//                     select: "-createdAt -updatedAt",
+//                     populate: {
+//                         path: "images category variants",
+//                         select: "url name size weight price tax",
+//                     },
+//                 });
+//             return res.status(200).json({
+//                 status: "OK",
+//                 Temple_name: Temple.name,
+//                 option: "group",
+//                 data: groups,
+//             });
+//         }
+//         const bundles = await Bundle.find({
+//             Temple: req.parent.Temple,
+//             gender: child.gender,
+//             grades: { $in: child.grade },
+//             house: child.house,
+//         })
+//             .populate({
+//                 path: "grades house",
+//                 select: "name",
+//             })
+//             .populate({
+//                 path: "products.product",
+//                 select: "-createdAt -updatedAt",
+//                 populate: {
+//                     path: "images category variants",
+//                     select: "url name size weight price tax",
+//                 },
+//             });
+//         return res.status(200).json({
+//             status: "OK",
+//             Temple_name: Temple.name,
+//             option: "bundle",
+//             data: bundles,
+//         });
+//     } catch (error) {
+//         return res.status(500).json({ message: "Something went wrong!" });
+//     }
+// };
+
+// const getTempleGradesAndHousesByParent = async (req, res) => {
+//     try {
+//         const Temple = await Temple.findById(req.parent.Temple).populate({
+//             path: "grades houses sections",
+//             select: "name",
+//             sort: "name",
+//         });
+//         return res.status(200).json({
+//             status: "ok",
+//             Temple_name: Temple.name,
+//             grades: Temple.grades,
+//             houses: Temple.houses,
+//             sections: Temple?.sections || [],
+//         });
+//     } catch (error) {
+//         return res.status(500).json({ message: "Something went wrong!" });
+//     }
+// };
+
+export {
+    addTemple,
+    getAllTemples,
+    getAllTemplesPopulated,
+    getTempleById,
+    getTempleByIdPopulated,
+    updateTemple,
+    deleteTempleById,
+    getTempleByIdWithoutPopulate,
+    // getAllTemplesPopulatedWithOption,
+    findTempleByURL,
+    // getTempleProductsForChild,
+    addProductToTemple,
+    // addGradeToTemple,
+    // getTempleGradesAndHousesByParent,
+};

resources/setting/Configration/Config_controller.js

@@ -218,36 +218,34 @@ const addLogo = async (req, res) => {
   try {
     const configuration = await Config.find();
 
-    // console.log(req.files);
-    console.log(configuration.length)
-    //   const result1 = await cloudinary.uploader.upload(req.files.Headerlogo[0].path,{folder: 'Vardhaman'});
-    //   const result2 = await cloudinary.uploader.upload(req.files.Footerlogo[0].path,{folder: 'Vardhaman'});
-    //   const result3 = await cloudinary.uploader.upload(req.files.Adminlogo[0].path,{folder: 'Vardhaman'});
 
-    let result1 = req.body.Headerlogo ? req.body.Headerlogo : "";
+    console.log(req.files);
-    let result2 = req.body.Footerlogo ? req.body.Footerlogo : "";
+
-    let result3 = req.body.Adminlogo ? req.body.Adminlogo : "";
+
+    let result1
+    let result2
+    let result3
     // console.log(req.files.Headerlogo)
     if (req.files.Headerlogo) {
-      console.log(req.files.Headerlogo[0].path)
 
-      const result = await cloudinary.uploader.upload(
+
-        req.files.Headerlogo[0].path,
+      const result = await cloudinary.v2.uploader.upload(
+        req.files.Headerlogo.tempFilePath,
         { folder: "ATP/Logo" }
       );
       result1 = result.secure_url;
     }
     if (req.files.Footerlogo) {
-      const result = await cloudinary.uploader.upload(
+      const result = await cloudinary.v2.uploader.upload(
-        req.files.Footerlogo[0].path,
+        req.files.Footerlogo.tempFilePath,
         { folder: "ATP/Logo" }
       );
       result2 = result.secure_url;
     }
     if (req.files.Adminlogo) {
-      console.log(req.files.Adminlogo[0].path)
+      console.log(req.files.Adminlogo.path)
-      const result = await cloudinary.uploader.upload(
+      const result = await cloudinary.v2.uploader.upload(
-        req.files.Adminlogo[0].path,
+        req.files.Adminlogo.tempFilePath,
         { folder: "ATP/Logo" }
       );
       result3 = result.secure_url;
@@ -273,9 +271,7 @@ const addLogo = async (req, res) => {
         });
       }
     } else {
-      //     const result1 = await cloudinary.uploader.upload(req.files.Headerlogo[0].path,{folder: 'Vardhaman'});
+
-      //     const result2 = await cloudinary.uploader.upload(req.files.Footerlogo[0].path,{folder: 'Vardhaman'});
-      //     const result3 = await cloudinary.uploader.upload(req.files.Adminlogo[0].path,{folder: 'Vardhaman'});
 
       const updateLogo = await Config.updateOne(
         {},

resources/setting/Configration/Config_routes.js

@@ -17,12 +17,12 @@ import { authorizeRoles, isAuthenticatedUser } from "../../../middlewares/auth.j
 
 const router = Router();
 
-let cpUpload = upload.fields([
+// let cpUpload = upload.fields([
-  { name: "Headerlogo", maxCount: 1 },
+//   { name: "Headerlogo", maxCount: 1 },
-  { name: "Footerlogo", maxCount: 1 },
+//   { name: "Footerlogo", maxCount: 1 },
-  { name: "Adminlogo", maxCount: 1 },
+//   { name: "Adminlogo", maxCount: 1 },
-]);
+// ]);
-console.log(cpUpload)
+
 // router.route("/gst").post(isAuthenticatedUser, authorizeRoles("admin"), addGST);
 router.route("/social").post(isAuthenticatedUser, authorizeRoles("admin"), addSocialMedia);
 router.route("/address").post(isAuthenticatedUser, authorizeRoles("admin"), addAddress);

resources/user/userController.js

@@ -19,7 +19,7 @@ export const registerUser = async (req, res) => {
         if (req.files) {
             const files = req.files.avatar;
             const myCloud = await cloudinary.uploader.upload(files.tempFilePath, {
-                folder: "ATM/user-image",
+                folder: "ATP/user-image",
             },
                 function (error, result) { (result, error) });
         }
@@ -258,7 +258,7 @@ export const updateProfile = catchAsyncErrors(async (req, res, next) => {
 
         const myCloud = await cloudinary.v2.uploader.upload(userImage.tempFilePath,
             {
-                folder: "ATM/user-image",
+                folder: "ATP/user-image",
 
             });