addded all files

Database/DbConnection.js

@@ -0,0 +1,18 @@
+const mongoose = require("mongoose")
+require('dotenv').config();
+
+const musfiCollection = 'mongodb+srv://abu:[email protected]/?retryWrites=true&w=majority&appName=musficollection'
+
+const hayatCollections = 'mongodb+srv://basith:[email protected]/RegisterLogin?retryWrites=true&w=majority'
+
+function dbConnection() {
+  mongoose.connect(musfiCollection, {
+    connectTimeoutMS: 30000, // Set a custom timeout (default is 30,000 ms)
+  })
+  .then(() => console.log('MongoDB connected successfully'))
+  .catch(error => console.error('MongoDB connection error:', error));
+
+mongoose.Promise = global.Promise;
+}
+
+module.exports = {dbConnection}

Database/models/BabyItems.js

@@ -0,0 +1,23 @@
+var mongoose = require('mongoose');
+
+const babyItems = mongoose.Schema({
+    _id: mongoose.Schema.Types.ObjectId,
+    name: {
+        type: String,
+    },
+    price: {
+        type: Number,
+    },
+    description: {
+        type: String,
+    },
+    image: {
+        type: String,
+    },
+    isLiked: {
+        type: Boolean,
+        default: false,
+    }
+});
+
+module.exports = mongoose.model('BabyItems', babyItems);

Database/models/DriedNoodles.js

@@ -0,0 +1,23 @@
+var mongoose = require('mongoose');
+
+const driedNoodles = mongoose.Schema({
+    _id: mongoose.Schema.Types.ObjectId,
+    name: {
+        type: String,
+    },
+    price: {
+        type: Number,
+    },
+    description: {
+        type: String,
+    },
+    image: {
+        type: String,
+    },
+    isLiked: {
+        type: Boolean,
+        default: false,
+    }
+});
+
+module.exports = mongoose.model('DriedNoodles', driedNoodles);

Database/models/address.js

@@ -0,0 +1,42 @@
+var mongoose = require('mongoose');
+var Schema = mongoose.Schema;
+
+addressSchema = new Schema({
+    _id: mongoose.Schema.Types.ObjectId,
+    user_id: {
+        type: String
+    },
+    address: [
+        {
+            name: {
+                type: String
+            },
+            userId: {
+                type: String
+            },
+            mobileNumber: {
+                type: String
+            },
+            pinCode: {
+                type: String
+            },
+            address: {
+                type: String
+            },
+            area: {
+                type: String
+            },
+            landMark: {
+                type: String
+            },
+            alterMobileNumber: {
+                type: String
+            }
+
+        }
+    ]
+},
+    { timestamps: true }
+);
+
+module.exports = mongoose.model('Address', addressSchema);

Database/models/banner.js

@@ -0,0 +1,37 @@
+var mongoose = require('mongoose');
+
+const bannerScheme = mongoose.Schema({
+    _id: mongoose.Schema.Types.ObjectId,
+    name: {
+        type: String,
+    },
+    percentage: {
+        type: String,
+    },
+    image: {
+        type: String
+    },
+    products: [
+        {
+            _id: mongoose.Schema.Types.ObjectId,
+            name: {
+                type: String,
+            },
+            price: {
+                type: Number,
+            },
+            description: {
+                type: String,
+            },
+            image: {
+                type: String,
+            },
+            isLiked: {
+                type: Boolean,
+                default: false,
+            }
+        },
+    ],
+});
+
+module.exports = mongoose.model('Banner', bannerScheme);

Database/models/category.js

@@ -0,0 +1,12 @@
+
+const { Schema, model } = require("mongoose");
+
+const categorySchema = Schema({
+  id: Schema.Types.ObjectId,
+  name: { type: String, required: true },
+  description: { type: String },
+  image: { type: String },
+  link: { type: String },
+});
+
+module.exports = model("Category", categorySchema);

Database/models/comments.js

@@ -0,0 +1,70 @@
+const mongoose = require('mongoose');
+
+const commentSchema = new mongoose.Schema(
+    {
+        user: {
+            type: mongoose.Schema.Types.ObjectId,
+            ref: 'User',
+        },
+        createdAt: {
+            type: Date,
+            default: Date.now,
+        },
+        comment: {
+            type: String,
+            required: [true, 'Comment is required'],
+        },
+        likes: [
+            {
+                type: mongoose.Schema.Types.ObjectId,
+                ref: 'User',
+            },
+        ],
+        post: {
+            type: mongoose.Schema.Types.ObjectId,
+            ref: 'Post',
+        },
+        // reply: [
+        //   {
+        //     user: {
+        //       type: mongoose.Schema.Types.ObjectId,
+        //       ref: 'User',
+        //     },
+        //     comment: {
+        //       type: String,
+        //     },
+        //     like: [
+        //       {
+        //         type: mongoose.Schema.Types.ObjectId,
+        //         ref: 'Profile',
+        //       },
+        //     ],
+        //   },
+        // ],
+    },
+    {
+        toJSON: { virtuals: true },
+        toObject: { virtuals: true },
+    }
+);
+
+// commentSchema.virtual('replies', {
+//             ref: 'Reply',
+//             localField: '_id',
+//             foreignField: 'comment'
+
+// })
+
+commentSchema.pre(/^find/, function (next) {
+    this.find()
+        .populate('user')
+        .populate({
+            path: 'likes',
+            select: 'username user name photo _id',
+        });
+
+    next();
+});
+
+const Comment = mongoose.model('Comment', commentSchema);
+module.exports = Comment;

Database/models/dairy.js

@@ -0,0 +1,23 @@
+var mongoose = require('mongoose');
+
+const diaryScheme = mongoose.Schema({
+    _id: mongoose.Schema.Types.ObjectId,
+    name: {
+        type: String,
+    },
+    price: {
+        type: Number,
+    },
+    description: {
+        type: String,
+    },
+    image: {
+        type: String,
+    },
+    isLiked: {
+        type: Boolean,
+        default: false,
+    }
+});
+
+module.exports = mongoose.model('Diary', diaryScheme);

Database/models/drinks.js

@@ -0,0 +1,23 @@
+var mongoose = require('mongoose');
+
+const drinksScheme = mongoose.Schema({
+    _id: mongoose.Schema.Types.ObjectId,
+    name: {
+        type: String,
+    },
+    price: {
+        type: Number,
+    },
+    description: {
+        type: String,
+    },
+    image: {
+        type: String,
+    },
+    isLiked: {
+        type: Boolean,
+        default: false,
+    }
+});
+
+module.exports = mongoose.model('Drinks', drinksScheme);

Database/models/fruits.js

@@ -0,0 +1,23 @@
+var mongoose = require('mongoose');
+
+const fruitsScheme = mongoose.Schema({
+    _id: mongoose.Schema.Types.ObjectId,
+    name: {
+        type: String,
+    },
+    price: {
+        type: Number,
+    },
+    description: {
+        type: String,
+    },
+    image: {
+        type: String,
+    },
+    isLiked: {
+        type: Boolean,
+        default: false,
+    }
+});
+
+module.exports = mongoose.model('Fruits', fruitsScheme);

Database/models/gocery.js

@@ -0,0 +1,23 @@
+var mongoose = require('mongoose');
+
+const groceryScheme = mongoose.Schema({
+    _id: mongoose.Schema.Types.ObjectId,
+    name: {
+        type: String,
+    },
+    price: {
+        type: Number,
+    },
+    description: {
+        type: String,
+    },
+    image: {
+        type: String,
+    },
+    isLiked: {
+        type: Boolean,
+        default: false,
+    }
+});
+
+module.exports = mongoose.model('Grocery', groceryScheme);

Database/models/healthCare.js

@@ -0,0 +1,23 @@
+var mongoose = require('mongoose');
+
+const healthCare = mongoose.Schema({
+    _id: mongoose.Schema.Types.ObjectId,
+    name: {
+        type: String,
+    },
+    price: {
+        type: Number,
+    },
+    description: {
+        type: String,
+    },
+    image: {
+        type: String,
+    },
+    isLiked: {
+        type: Boolean,
+        default: false,
+    }
+});
+
+module.exports = mongoose.model('HealthCare', healthCare);

Database/models/home.js

@@ -0,0 +1,14 @@
+
+const { Schema, model } = require("mongoose");
+import bannerSchema from '../models/banner'
+import productSchema from '../models/product'
+import categorySchema from '../models/category'
+
+const homeSchema = new Schema({
+    banners: [bannerSchema],
+    categories: [categorySchema],
+    recentPurchase: [],
+    newProducts: [productSchema]
+});
+
+module.exports = model('Home', homeSchema);

Database/models/newPost.js

@@ -0,0 +1,66 @@
+const mongoose = require('mongoose');
+const Profile = require('./user');
+
+const postSchema = new mongoose.Schema(
+    {
+        user: {
+            type: mongoose.Schema.Types.ObjectId,
+            ref: 'User',
+        },
+        createdAt: {
+            type: Date,
+            default: Date.now,
+        },
+        profile: {
+            type: mongoose.Schema.Types.ObjectId,
+            ref: 'User',
+        },
+        caption: {
+            type: String,
+            trim: true,
+        },
+        location: {
+            type: String,
+        },
+        likes: [
+            {
+                type: mongoose.Schema.Types.ObjectId,
+                ref: 'User',
+            },
+        ],
+        image: String,
+        // comment: {
+        //     type: mongoose.Schema.Types.ObjectId,
+        //     ref: 'Comment',
+        // },
+    },
+    {
+        toJSON: { virtuals: true },
+        toObject: { virtuals: true },
+    }
+);
+
+postSchema.set('toObject', { virtuals: true });
+postSchema.set('toJSON', { virtuals: true });
+
+postSchema.virtual('commentsPost', {
+    ref: 'Comment',
+    localField: '_id',
+    foreignField: 'post',
+});
+
+postSchema.methods.getProfileId = async function (id) {
+    const { _id } = await Profile.findOne({ unique_id: id });
+    return _id;
+};
+
+// //Todo
+// postSchema.pre(/^find/, function (next) {
+//   this.find().populate('commentsPost');
+
+//   next();
+// });
+
+const Post = mongoose.model('PostTest', postSchema);
+
+module.exports = Post;

Database/models/order.js

@@ -0,0 +1,33 @@
+const mongoose = require('mongoose');
+
+const orderSchema = new mongoose.Schema(
+    {
+        unique_id: { type: Number, required: true },
+        numOfItems: { type: Number, required: true },
+        user_id: { type: Number, required: true },
+        user_name: { type: String, required: true },
+        products: [
+            {
+                productId: {
+                    type: String,
+                },
+                productName: {
+                    type: String,
+                },
+                productImage: {
+                    type: String,
+                    //  required: true 
+                },
+                quantity: {
+                    type: String,
+                },
+            },
+        ],
+        amount: { type: Number, required: true },
+        address: { type: Object, required: true },
+        status: { type: String, default: "Packing" },
+    },
+    { timestamps: true }
+);
+
+module.exports = mongoose.model('Order', orderSchema);

Database/models/personalCare.js

@@ -0,0 +1,23 @@
+var mongoose = require('mongoose');
+
+const personalCareScheme = mongoose.Schema({
+    _id: mongoose.Schema.Types.ObjectId,
+    name: {
+        type: String,
+    },
+    price: {
+        type: Number,
+    },
+    description: {
+        type: String,
+    },
+    image: {
+        type: String,
+    },
+    isLiked: {
+        type: Boolean,
+        default: false,
+    }
+});
+
+module.exports = mongoose.model('PersonalCare', personalCareScheme);

Database/models/postNews.js

@@ -0,0 +1,13 @@
+const mongoose = require('mongoose');
+
+const postSchema = new mongoose.Schema({
+    postId: {
+        type: mongoose.Schema.Types.ObjectId, ref: 'User'
+    },
+    postedBy: String,
+    caption: String,
+    imageUrl: String,
+    liked: String,
+});
+
+module.exports = mongoose.model('Post', postSchema);

Database/models/product.js

@@ -0,0 +1,23 @@
+var mongoose = require('mongoose');
+
+const productSchema = mongoose.Schema({
+    _id: mongoose.Schema.Types.ObjectId,
+    name: {
+        type: String,
+    },
+    price: {
+        type: Number,
+    },
+    description: {
+        type: String,
+    },
+    image: {
+        type: String,
+    },
+    isLiked: {
+        type: Boolean,
+        default: false,
+    }
+});
+
+module.exports = mongoose.model('Product', productSchema);

Database/models/special_offers.js

@@ -0,0 +1,9 @@
+var mongoose = require('mongoose');
+
+const specialOffer = mongoose.Schema({
+    _id: mongoose.Schema.Types.ObjectId,
+    offerName: { type: String, require: true },
+    offerBannerImage: { type: String, require: true }
+})
+
+module.exports = mongoose.model('Offers', specialOffer);

Database/models/user.js

@@ -0,0 +1,118 @@
+const mongoose = require('mongoose');
+const { Schema } = mongoose;
+
+const userSchema = new Schema({
+	unique_id: {
+		type: Number,
+		required: true,
+		unique: true
+	},
+	email: {
+		type: String,
+		unique: true,
+		sparse: true,  // Indexing only if present
+		validate: {
+			validator: function (value) {
+				// Validate only if the email field is updated
+				if (this.isModified('email') && value) {
+					return !this.mobileNumber;
+				}
+				return true;
+			},
+			message: 'Mobile number must be empty if email is provided.'
+		}
+	},
+
+	username: {
+		type: String,
+		required: true
+	},
+	dateOfBirth: {
+		type: String
+	},
+	mobileNumber: {
+		type: String,
+		unique: true,
+		sparse: true,  // Indexing only if present
+		validate: {
+			validator: function (value) {
+				// Validate only if the mobileNumber field is updated
+				if (this.isModified('mobileNumber') && value) {
+					return !this.email;
+				}
+				return true;
+			},
+			message: 'Email must be empty if mobile number is provided.'
+		}
+	},
+	password: {
+		type: String,
+		required: true
+	},
+	pushToken: {
+		type: String
+	},
+	token: {
+		type: String
+	},
+	role: {
+		type: String,
+		enum: ['user', 'admin', 'customer'],
+		default: 'user'
+	},
+	googleId: {
+		type: String
+	},
+	profilePic: {
+		type: String
+	},
+	address: [
+		{
+			name: {
+				type: String
+			},
+			userId: {
+				type: String
+			},
+			mobileNumber: {
+				type: String
+			},
+			pinCode: {
+				type: String
+			},
+			address: {
+				type: String
+			},
+			area: {
+				type: String
+			},
+			landMark: {
+				type: String
+			},
+			alterMobileNumber: {
+				type: String
+			}
+		}
+	]
+}, {
+	timestamps: true // This adds `createdAt` and `updatedAt` fields
+});
+
+// Pre-update hook to ensure validation happens only when email or mobileNumber are updated
+// userSchema.pre('findOneAndUpdate', function (next) {
+// 	const update = this.getUpdate();
+// 	const user = this._conditions;
+
+// 	// Check if email and mobileNumber are both in the update query
+// 	if (update.email && update.mobileNumber) {
+// 		const error = new Error('Email and mobile number cannot both be provided.');
+// 		return next(error);  // Return error if both fields are set
+// 	}
+
+// 	// Proceed with the update
+// 	next();
+// });
+
+const User = mongoose.model('User', userSchema);
+
+module.exports = User;

Database/models/vegitables.js

@@ -0,0 +1,23 @@
+var mongoose = require('mongoose');
+
+const vegetablesSchema = mongoose.Schema({
+    _id: mongoose.Schema.Types.ObjectId,
+    name: {
+        type: String,
+    },
+    price: {
+        type: Number,
+    },
+    description: {
+        type: String,
+    },
+    image: {
+        type: String,
+    },
+    isLiked: {
+        type: Boolean,
+        default: false,
+    }
+});
+
+module.exports = mongoose.model('Vegetables', vegetablesSchema);

Database/mufiModels/featureProduct.js

@@ -0,0 +1,61 @@
+const { Schema, model } = require("mongoose");
+const mongoose = require("mongoose");
+
+const featureProductsScema = new Schema(
+    {
+        name: {
+            type: String,
+            required: true,
+            unique: true,
+            trim: true,
+            minLength: [3, "Too Short product Name"],
+        },
+        images: {
+            type: [String],
+        },
+        description: {
+            type: String,
+            maxlength: [100, "Description should be less than or equal to 100"],
+            minlength: [10, "Description should be more than or equal to 10"],
+            required: true,
+            trim: true,
+        },
+        price: {
+            type: Number,
+            default: 0,
+            min: 0,
+            required: true,
+        },
+        priceAfterDiscount: {
+            type: Number,
+            default: 0,
+            min: 0,
+        },
+        quantity: {
+            type: Number,
+            default: 0,
+            min: 0,
+        },
+        sold: {
+            type: Number,
+            default: 0,
+            min: 0,
+        },
+        category: {
+            type: Schema.ObjectId,
+            ref: "Category",
+        },
+        ratingAvg: {
+            type: Number,
+            min: 1,
+            max: 5,
+        },
+        ratingCount: {
+            type: Number,
+            min: 0,
+        },
+    },
+    { timestamps: true, toJSON: { virtuals: true }, toObject: { virtuals: true } }
+)
+
+module.exports = mongoose.model('featureProducts', featureProductsScema);

Database/mufiModels/hijabs.js

@@ -0,0 +1,62 @@
+const { Schema, model } = require("mongoose");
+const mongoose = require("mongoose");
+
+const hijabsScema = new Schema(
+    {
+        name: {
+            type: String,
+            required: true,
+            unique: true,
+            trim: true,
+            minLength: [3, "Too Short product Name"],
+        },
+        images: {
+            type: [String],
+        },
+        description: {
+            type: String,
+            maxlength: [100, "Description should be less than or equal to 100"],
+            minlength: [10, "Description should be more than or equal to 10"],
+            required: true,
+            trim: true,
+        },
+        price: {
+            type: Number,
+            default: 0,
+            min: 0,
+            required: true,
+        },
+        priceAfterDiscount: {
+            type: Number,
+            default: 0,
+            min: 0,
+        },
+        quantity: {
+            type: Number,
+            default: 0,
+            min: 0,
+        },
+        sold: {
+            type: Number,
+            default: 0,
+            min: 0,
+        },
+        category: {
+            type: Schema.ObjectId,
+            ref: "Category",
+            required: true,
+        },
+        ratingAvg: {
+            type: Number,
+            min: 1,
+            max: 5,
+        },
+        ratingCount: {
+            type: Number,
+            min: 0,
+        },
+    },
+    { timestamps: true, toJSON: { virtuals: true }, toObject: { virtuals: true } }
+)
+
+module.exports = mongoose.model('hijabs', hijabsScema);

Database/mufiModels/scarfs.js

@@ -0,0 +1,62 @@
+const { Schema, model } = require("mongoose");
+const mongoose = require("mongoose");
+
+const scarfsScema = new Schema(
+    {
+        name: {
+            type: String,
+            required: true,
+            unique: true,
+            trim: true,
+            minLength: [3, "Too Short product Name"],
+        },
+        images: {
+            type: [String],
+        },
+        description: {
+            type: String,
+            maxlength: [100, "Description should be less than or equal to 100"],
+            minlength: [10, "Description should be more than or equal to 10"],
+            required: true,
+            trim: true,
+        },
+        price: {
+            type: Number,
+            default: 0,
+            min: 0,
+            required: true,
+        },
+        priceAfterDiscount: {
+            type: Number,
+            default: 0,
+            min: 0,
+        },
+        quantity: {
+            type: Number,
+            default: 0,
+            min: 0,
+        },
+        sold: {
+            type: Number,
+            default: 0,
+            min: 0,
+        },
+        category: {
+            type: Schema.ObjectId,
+            ref: "Category",
+            required: true,
+        },
+        ratingAvg: {
+            type: Number,
+            min: 1,
+            max: 5,
+        },
+        ratingCount: {
+            type: Number,
+            min: 0,
+        },
+    },
+    { timestamps: true, toJSON: { virtuals: true }, toObject: { virtuals: true } }
+)
+
+module.exports = mongoose.model('scarfs', scarfsScema);

Dockerfile

@@ -18,5 +18,5 @@ RUN npm ci --only=production
 # Copy the rest of your application code
 COPY . .
 
-EXPOSE 7860
+EXPOSE 4000
 CMD ["node", "server.js"]

README.md

@@ -1,12 +1 @@
----
-title: Hayat
-emoji: 🏃
-colorFrom: pink
-colorTo: green
-sdk: docker
-pinned: false
-license: apache-2.0
-short_description: Node JS backend project
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# MyApi

app.js

@@ -0,0 +1,117 @@
+var express = require('express');
+var router = express.Router();
+var app = express();
+const http = require('http');
+var bodyParser = require('body-parser');
+const morgan = require('morgan');
+
+
+//Routes
+const login = require("./routes/login");
+const register = require("./routes/register");
+const profile = require("./routes/profile");
+const profileUpdate = require("./routes/profileUpdate");
+const changePassword = require("./routes/changePassword");
+const productRoutes = require("./routes/products");
+const orderRoutes = require("./routes/orders");
+const category = require("./routes/category");
+const vegetables = require("./routes/vegetables");
+const grocery = require("./routes/grocery");
+const drinks = require("./routes/drinks");
+const fruites = require("./routes/fruits");
+const dairy = require("./routes/dairy");
+const forgotPassword = require("./routes/forgotPassword")
+const fcm = require("./routes/fcm");
+const banner = require("./routes/banner");
+const address = require("./routes/address")
+const firebase = require("./utils/firebase")
+const post = require("./routes/post")
+const newPost = require("./routes/newPost");
+const comment = require("./routes/cmd");
+const personalCare = require("./routes/personalCare");
+const healthCare = require("./routes/healthCare");
+const driedNoodles = require("./routes/driedNoodles");
+const home = require("./routes/home")
+const babyItems = require("./routes/babyItems")
+
+// //Mongoes Db
+// mongoose.connect('mongodb+srv://basith:[email protected]/RegisterLogin?retryWrites=true&w=majority', {
+// 	useNewUrlParser: true,
+// 	useUnifiedTopology: true
+// }, (err) => {
+// 	if (!err) {
+// 		console.log('MongoDB Connection Succeeded.');
+// 	} else {
+// 		console.log('Error in DB connection : ' + err);
+// 	}
+// });
+
+// mongoose.Promise = global.Promise;
+
+
+//Setting the requestParse
+app.use(morgan("dev"));
+app.use('/uploads', express.static('uploads'));
+app.use(bodyParser.urlencoded({ extended: false }));
+app.use(bodyParser.json());
+
+
+//IDK why we use this and i think this is Header what required....
+app.use((req, res, next) => {
+	res.header("Access-Control-Allow-Origin", "*");
+	res.header(
+		"Access-Control-Allow-Headers",
+		"Origin, X-Requested-With, Content-Type, Accept, Authorization"
+	);
+	if (req.method === "OPTIONS") {
+		res.header("Access-Control-Allow-Methods", "PUT, POST, PATCH, DELETE, GET");
+		return res.status(200).json({});
+	}
+	next();
+});
+
+// Routes which should handle requests
+app.use("/login", login);
+app.use("/register", register);
+app.use("/profile", profile);
+app.use("/profileUpdate", profileUpdate);
+app.use("/products", productRoutes);
+app.use("/category", category);
+app.use("/orders", orderRoutes);
+app.use("/vegetables", vegetables);
+app.use("/grocery", grocery);
+app.use("/fruits", fruites);
+app.use("/drinks", drinks);
+app.use("/dairy", dairy);
+app.use("/forgotPassword", forgotPassword);
+app.use("/changePassword", changePassword);
+app.use("/fcm", fcm);
+app.use("/banner", banner);
+app.use("/address", address);
+app.use("/newPost", newPost);
+app.use("/cmd", comment);
+app.use("/personalCare", personalCare);
+app.use("/healthCare", healthCare);
+app.use("/driedNoodles", driedNoodles);
+app.use("/home", home)
+app.use("/babyItems", babyItems)
+
+
+//Error catch
+app.use((req, res, next) => {
+	const error = new Error("Not found");
+	error.status = 404;
+	next(error);
+});
+
+//Some other error show
+app.use((error, req, res, next) => {
+	res.status(error.status || 500);
+	res.json({
+		error: {
+			message: error.message
+		}
+	});
+});
+
+module.exports = app;

bootstrap.js

@@ -0,0 +1,75 @@
+const { AppError } = require("./utils/AppError.js");
+const globalErrorHandling = require("./utils/GlobalErrorHandling.js");
+
+// Routes
+const login = require("./routes/login");
+const register = require("./routes/register");
+const profile = require("./routes/profile");
+const profileUpdate = require("./routes/profileUpdate");
+const changePassword = require("./routes/changePassword");
+const productRoutes = require("./routes/products");
+const orderRoutes = require("./routes/orders");
+const category = require("./routes/category");
+const vegetables = require("./routes/vegetables");
+const grocery = require("./routes/grocery");
+const drinks = require("./routes/drinks");
+const fruites = require("./routes/fruits");
+const dairy = require("./routes/dairy");
+const forgotPassword = require("./routes/forgotPassword");
+const fcm = require("./routes/fcm");
+const banner = require("./routes/banner");
+const address = require("./routes/address");
+const post = require("./routes/post");
+const newPost = require("./routes/newPost");
+const comment = require("./routes/cmd");
+const personalCare = require("./routes/personalCare");
+const healthCare = require("./routes/healthCare");
+const driedNoodles = require("./routes/driedNoodles");
+const home = require("./routes/home");
+const babyItems = require("./routes/babyItems");
+
+const hijabRouter = require("./routes/musfiRouters/hijabs/hijabsRouter.js");
+const featureRoute = require("./routes/musfiRouters/featureProducts/featureProductsRouter.js");
+const scarfsRouter = require("./routes/musfiRouters/scarfs/scarfsRouter.js");
+
+function bootstrap(app) {
+    app.use("/api/v1/login", login);
+    app.use("/api/v1/register", register);
+    app.use("/api/v1/profile", profile);
+    app.use("/api/v1/profileUpdate", profileUpdate);
+    app.use("/api/v1/changePassword", changePassword);
+    app.use("/api/v1/productRoutes", productRoutes);
+    app.use("/api/v1/orderRoutes", orderRoutes);
+    app.use("/api/v1/category", category);
+    app.use("/api/v1/vegetables", vegetables);
+    app.use("/api/v1/grocery", grocery);
+    app.use("/api/v1/drinks", drinks);
+    app.use("/api/v1/fruites", fruites);
+    app.use("/api/v1/dairy", dairy);
+    app.use("/api/v1/forgotPassword", forgotPassword);
+    app.use("/api/v1/address", address);
+    app.use("/api/v1/fcm", fcm);
+    app.use("/api/v1/banner", banner);
+    app.use("/api/v1/home", home);
+    app.use("/api/v1/babyItems", babyItems);
+    app.use("/api/v1/personalCare", personalCare);
+    app.use("/api/v1/healthCare", healthCare);
+    app.use("/api/v1/driedNoodles", driedNoodles);
+    app.use("/api/v1/post", post);
+    app.use("/api/v1/newPost", newPost);
+    app.use("/api/v1/comment", comment);
+
+    app.use("/api/v1/hijabs", hijabRouter);
+    app.use("/api/v1/featureProducts", featureRoute)
+    app.use("/api/v1/scarfs", scarfsRouter)
+
+    // Catch-all for undefined routes
+    app.all("*", (req, res, next) => {
+        next(new AppError("Endpoint was not found", 404));
+    });
+
+    // // Global error handling middleware
+    // app.use(globalErrorHandling);
+}
+
+module.exports = { bootstrap };

core/auth.js

@@ -0,0 +1,27 @@
+const { OAuth2Client } = require('google-auth-library');
+require('dotenv').config();
+const googleClientId = process.env.GOOGLE_ID;
+
+// Initialize the OAuth2 client with your Google Client ID
+const client = new OAuth2Client('YOUR_GOOGLE_CLIENT_ID');
+
+async function verifyGoogleToken(token) {
+    try {
+        // Verify the token
+        const ticket = await client.verifyIdToken({
+            idToken: token,
+            audience: googleClientId, // Specify the CLIENT_ID of the app that accesses the backend
+        });
+
+        // Get the user payload from the ticket
+        const payload = ticket.getPayload();
+
+        // Return the payload with user information
+        return ticket;
+    } catch (error) {
+        console.error('Google token verification failed:', error);
+        throw new Error('Invalid Google token');
+    }
+}
+
+module.exports = verifyGoogleToken;

package.json

@@ -1,13 +1,42 @@
 {
-    "name": "node-docker-example",
-    "version": "1.0.0",
-    "description": "A simple Node.js project to test Docker deployment",
-    "main": "server.js",
-    "scripts": {
-      "start": "node server.js"
-    },
-    "author": "Your Name",
-    "license": "MIT",
-    "dependencies": {}
+  "name": "creating-registration-and-login-form-in-nodejs-and-mongodb",
+  "version": "1.0.0",
+  "engines": {
+    "node": "21.x"
+  },
+  "description": "This is a user login and registration app using Node.js, Express, Mongoose and express-sessions. ",
+  "main": "server.js",
+  "dependencies": {
+    "@pusher/push-notifications-server": "^1.0.1",
+    "axios": "^1.2.5",
+    "bcrypt": "^5.0.1",
+    "connect-mongo": "^3.0.0",
+    "crypto": "^1.0.1",
+    "dotenv": "^8.6.0",
+    "cors": "^2.8.5",
+    "ejs": "^3.0.1",
+    "express": "^4.21.2",
+    "express-handlebars": "^6.0.6",
+    "express-session": "^1.16.2",
+    "fcm-node": "^1.3.0",
+    "fcm-push": "^1.1.3",
+    "firebase": "^9.23.0",
+    "firebase-admin": "^11.5.0",
+    "form-data": "^4.0.0",
+    "google-auth-library": "^9.14.0",
+    "jsonwebtoken": "^9.0.0",
+    "mailgun.js": "^7.0.0",
+    "mongodb": "^6.8.0",
+    "mongoose": "^8.9.1",
+    "morgan": "^1.10.0",
+    "multer": "^1.4.5-lts.1",
+    "nodemailer": "^6.7.7",
+    "nodemon": "^2.0.16",
+    "salted-md5": "^4.0.5"
+  },
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1",
+    "start": "nodemon server.js",
+    "build": "nodemon server.js"
   }
-  
+}

push-notification-key.json

@@ -0,0 +1,13 @@
+{
+    "type": "service_account",
+    "project_id": "flutter-hayat",
+    "private_key_id": "f558d83ec7eb29dd6b0ea474f6d4001cdcc6f6df",
+    "private_key": "-----BEGIN PRIVATE KEY-----\nMIIEvgIBADANBgkqhkiG9w0BAQEFAASCBKgwggSkAgEAAoIBAQCxivFISQeNWg5t\ndiNYzA2cuNvhbLL3kMmxMk7EIVdxVXrnM9YIzh2PPa82dyKyhJaCr/9DPPrhxRtW\nnHyTwqXxh6ycjxTHazM2Nj8aScUvK382Tl7QIynzcwirQ48iJSQtXeo7sy3fJLTd\nC8lYfGQV2is4l+bOYIDmcMdLzQ43RAiIjj+Xy8QLAW7GBOsJtuMsask7MVAhOph7\nfn/aQK9rWXKRutyKrstBpwkI4aGKfd3y89gxPuk8Fj4H3PyB3FZUF5eb5E11VD0R\n7mU7s7VWWtMja0pDUO8sFq+AmB6hFi3Ua7wS1M1uBl7eEMNDlVlUyBpsa15JODHD\nosq+guahAgMBAAECggEABPvlR5XzPhLV3llHZz39MNXYqFSclooMO2rx3pwgAAi6\nBUUFgGRG3KdK5KDGCtRhhEQsCodq9I0Ltiv47E31yhi4rgFvQCTggGhX76U8AZW7\nQbtD+pxOGG01hFdGbJs1z4c4JNpkEoRNhnoG+jKtvZZNCc7r1gXMAIwQcC6OtFrq\nwyZAFTiUdDartKAe5eevNf8HCb/vchl34rzxEb669Mujju8LRm/3LF393Kxr9Wum\nV+oEVyp6ofieSr8Do5vvg94TD2/2pEvtPuainfnbe99b3UPw1CgF7+16jKumV3RE\nMxSAX2UXgKPre6Gs5JvKE4d1ubGnBIDk0VhZmrWqVQKBgQDwVu6Bo0HDSM3wy8w2\nJXeW/aSCV03TpPZn5nmpapikZHuCx0U6OnMmoUbAYKMTdKzNeBy6xgYFED5P7jEn\nlDD4hY0+jIySyie6gcnYPy4mAqxQeltPvo538dAxPaxFKR43sFmDYFdo6Zifitut\n2DPFcY5XZsD/+zS3cK7ChuNHZQKBgQC9HIGeX1BENIeef0W/oyYPhfQEejVZNMpU\n8OGo36FELcfd+DmzgD2lNNNUFEoENc5QceJ0d1GMerTLBMp+0AUriB5O+E9na9EM\nWEp3Zx0ZXacaPw7IYGSG44cG4qMSnBj88h+WHZrfLhADXKXBpZb8PXV9tFCfVdpi\nUoMwY2sEjQKBgQCkWN3JumjK8GsbQVFIqYBIuPOYybiHhKOW0wzY4/KzX57yA+/7\n7GI3xUsLXEnHkR5ldsA2nBkbt0rU/62PQg/msfSvFA9AhYp7SCtNe47EIUnR0onE\nUys7LBlQwrqdpItsS2Q6qVO8gxiB6MNl8pUcbBWJANPzd8VJt31ZukGK3QKBgQC5\nBoAHbOgCo4ahW5Lpif2+KGh0TQGPUyg3bSrMaGjHZSdtFOWXq3wk/IdbdzJn5iEC\n8joHi4p9ML1c+UYKRwsX6WkGCMrfvExfkK7jHj8JR2ksM9AJ2s3gcBL3eJzmo1WL\nfnXLERIrFE1UjLwcuB/+kT84C0jqbDxsAKEcodjeLQKBgHTBa43VlAH3X9cbyikW\nm+ZEN7o7AGoyQySVMJ1jTIDn1cq/AqnpH4Bl3Lu8U4PYYaBP2aPdFUpEGX9nXUzK\nwLPTIifwd0UHjkQGKpH68lbc4pW1iNcRpJTp5IG5W0XVOWl6MnPD8BSRdA1zfJi7\nxBlMV2UDVJCZIT2ySY03C89l\n-----END PRIVATE KEY-----\n",
+    "client_email": "[email protected]",
+    "client_id": "102750862365764776921",
+    "auth_uri": "https://accounts.google.com/o/oauth2/auth",
+    "token_uri": "https://oauth2.googleapis.com/token",
+    "auth_provider_x509_cert_url": "https://www.googleapis.com/oauth2/v1/certs",
+    "client_x509_cert_url": "https://www.googleapis.com/robot/v1/metadata/x509/firebase-adminsdk-fr502%40flutter-hayat.iam.gserviceaccount.com"
+  }
+  

routes/address.js

@@ -0,0 +1,99 @@
+const express = require("express");
+const router = express.Router();
+const mongoose = require("mongoose");
+const Address = require("../Database/models/address");
+
+function successResponse(message) {
+    return {
+        "status": 200,
+        "connection": "Connected",
+        "message": message
+    }
+}
+
+function failedResponse(message) {
+    return {
+        "status": 400,
+        "connection": "Dissconnected",
+        "message": message
+    }
+}
+
+//Post order
+router.post("/", async (req, res, next) => {
+
+    console.log(req.body);
+
+    const address = new Address(req.body);
+
+    try {
+        const address = await address.save();
+
+        res.status(500).send(successResponse(address));
+    } catch (err) {
+        console.log(err);
+        res.status(500).send(failedResponse(err));
+    }
+
+});
+
+router.get("/:user_id", async (req, res, next) => {
+
+    console.log(req.params.user_id);
+
+    try {
+        const orders = await Address.find({ user_id: req.params.user_id });
+        res.status(200).send(successResponse(orders));
+    } catch (err) {
+        res.status(500).send(failedResponse(err));
+    }
+});
+
+//UPDATE
+router.put("/:id", async (req, res) => {
+    console.log(req.params.id);
+    console.log(req.body);
+
+    try {
+
+        Address.updateOne({ _id: req.params.id },
+            { $set: { status: req.body.status } }, function (err, data) {
+
+                if (err) {
+                    return res.status(500).send(failedResponse(err))
+                } else {
+                    return res.status(200).send(successResponse(data))
+                }
+            })
+
+    } catch (err) {
+        console.log(err);
+        res.status(500).send(failedResponse(err));
+    }
+
+
+});
+
+// //GET ALL
+router.get("/", async (req, res) => {
+    try {
+        const address = await Address.find();
+        res.status(200).json(successResponse(address));
+    } catch (err) {
+        res.status(500).json(failedResponse(err));
+    }
+});
+
+//DELETE
+router.delete("/:id", (req, res, next) => {
+    Order.remove({ _id: req.params.id })
+        .exec()
+        .then(result => {
+            res.status(200).send(successResponse(result));
+        })
+        .catch(err => {
+            res.status(500).send(failedResponse(err));
+        });
+});
+
+module.exports = router;

routes/babyItems.js

@@ -0,0 +1,142 @@
+const express = require("express");
+const router = express.Router();
+const mongoose = require("mongoose");
+const multer = require('multer');
+const { responseAddProduct, responseFetchProduct } = require("../utils/responseModel");
+const firebase = require("../utils/firebase");
+const BabyItems = require("../Database/models/BabyItems");
+var imageUrl = ""
+
+//Disk storage where image store
+const storage = multer.diskStorage({
+    destination: function (req, file, cb) {
+        cb(null, './uploads');
+    },
+    filename: function (req, file, cb) {
+        cb(null, file.originalname);
+    }
+});
+
+//Check the image formate
+const fileFilter = (req, file, cb) => {
+    // reject a file
+    if (file.mimetype === 'image/jpeg' || file.mimetype === 'image/png' || file.mimetype === 'image/jpg' || file.mimetype === 'image/webp') {
+        cb(null, true);
+    } else {
+        cb(null, false);
+    }
+};
+
+const upload = multer({
+    storage: storage,
+    limits: {
+        fileSize: 1024 * 1024 * 5
+    },
+    fileFilter: fileFilter
+});
+
+//Add products
+router.post("/", upload.single('file'), async (req, res, next) => {
+
+    await firebase.uploadFile(req.file.path, "BabyItems/" + req.file.filename)
+    await firebase.generateSignedUrl("BabyItems/" + req.file.filename).then(res => {
+        imageUrl = res
+    })
+
+    if (imageUrl == "") {
+        imageUrl = req.file.path
+    }
+
+    console.log(req.body)
+    const babyItems = BabyItems({
+        _id: mongoose.Types.ObjectId(),
+        name: req.body.name,
+        price: req.body.price,
+        description: req.body.description,
+        image: imageUrl,
+        isLiked: req.body.isLiked,
+
+    });
+    babyItems
+        .save()
+        .then(result => {
+            console.log(result);
+            res.status(200).send(
+                responseAddProduct(true, result));
+        })
+        .catch(err => {
+            console.log(err.message);
+            res.status(500).send(responseAddProduct(false, err));
+        });
+});
+
+
+//Get products
+router.get("/", (req, res, next) => {
+    BabyItems.find()
+        .exec()
+        .then(result => {
+            res.status(200).send(responseFetchProduct(true, result));
+        })
+        .catch(err => {
+            console.log(err);
+            res.status(500).send(responseFetchProduct(false, err));
+        });
+});
+
+//Update products
+router.put('/:id', upload.single('fruitImage'), async (req, res) => {
+    const id = req.params.id;
+    console.log(req.body);
+    const updateOps = {};
+    for (const ops of Object.keys(req.body)) {
+        updateOps[ops] = req.body[ops];
+    }
+
+    console.log(updateOps);
+    BabyItems.updateOne({ _id: id }, { $set: updateOps })
+        .exec()
+        .then(result => {
+            res.status(200).json({
+                message: 'Product updated',
+                request: {
+                    type: 'GET',
+                    url: 'http://localhost:4000/products/' + id
+                }
+            });
+        })
+        .catch(err => {
+            console.log(err);
+            res.status(500).json({
+                error: err
+            });
+        });
+});
+
+//Delete products
+router.delete("/:id", (req, res) => {
+    const id = req.params.id;
+    BabyItems.deleteOne({ _id: id })
+        .exec()
+        .then(result => {
+            res.status(200).json({
+                message: 'Fruit item deleted',
+                request: {
+                    type: 'POST',
+                    url: 'http://localhost:3000/products',
+                    body: { name: 'String', price: 'Number' }
+                }
+            });
+        })
+        .catch(err => {
+            console.log(err);
+            res.status(500).json({
+                error: err
+            });
+        });
+});
+
+
+
+
+module.exports = router;

routes/banner.js

@@ -0,0 +1,148 @@
+const express = require("express");
+const router = express.Router();
+var Banner = require('../Database/models/banner');
+const mongoose = require("mongoose");
+const multer = require('multer');
+const firebase = require("../utils/firebase")
+var imageUrl = ""
+
+//Disk storage where image store
+const storage = multer.diskStorage({
+    destination: function (req, file, cb) {
+        cb(null, './uploads');
+    },
+    filename: function (req, file, cb) {
+        cb(null, file.originalname);
+    }
+});
+
+//Check the image formate
+const fileFilter = (req, file, cb) => {
+    // reject a file
+    if (file.mimetype === 'image/jpeg' || file.mimetype === 'image/png' || file.mimetype === 'image/jpg') {
+        cb(null, true);
+    } else {
+        cb(null, false);
+    }
+};
+
+const upload = multer({
+    storage: storage,
+    limits: {
+        fileSize: 1024 * 1024 * 5
+    },
+    fileFilter: fileFilter
+});
+
+router.post("/", upload.any(), async (req, res) => {
+    console.log(req.body); // Log non-file data
+    const uploadedFiles = req.files; // Uploaded files
+    let bannerImage = ""
+
+    let bannerImageName = uploadedFiles.find(
+        (f) => f.fieldname.includes('banner')
+    );
+
+    if (bannerImageName != "" && bannerImageName != undefined) {
+
+        let bannerImagePath = uploadedFiles.find(
+            (f) => f.path.includes('banner')
+        );
+        await firebase.uploadFile(bannerImagePath, "bannerImage/" + bannerImageName);
+
+        // Generating signed URL for the uploaded image
+        await firebase.generateSignedUrl("bannerImage/" + bannerImageName)
+            .then((url) => {
+                imageUrl = url;
+            })
+            .catch((err) => {
+                console.error(`Error generating signed URL for ${fileName.filename}:`, err);
+                return res.status(500).json({ error: 'Error generating image URL.' });
+            });
+    }
+
+    try {
+        const { name, percentage, products } = req.body; // Non-file data
+
+        const bannerProducts = [];
+        let imageUrl = ''; // Declare imageUrl variable
+
+        for (let i = 0; i < products.length; i++) {
+            const product = products[i]; // Directly use product if it's already an object
+            const fileName = uploadedFiles.find(
+                (f) => f.fieldname === `products[${i}][image]`
+            );
+
+            // If no file is found for the product, skip
+            if (!fileName) {
+                console.log(`No image found for product ${i}`);
+                continue;
+            }
+
+            const filePath = fileName.path;
+
+            // Upload file and generate the signed URL
+            await firebase.uploadFile(filePath, "bannerProducts/" + fileName.filename);
+
+            // Generating signed URL for the uploaded image
+            await firebase.generateSignedUrl("bannerProducts/" + fileName.filename)
+                .then((url) => {
+                    imageUrl = url;
+                })
+                .catch((err) => {
+                    console.error(`Error generating signed URL for ${fileName.filename}:`, err);
+                    return res.status(500).json({ error: 'Error generating image URL.' });
+                });
+
+            bannerProducts.push({
+                _id: new mongoose.Types.ObjectId(),
+                name: product.name,
+                image: imageUrl,
+                price: product.price,
+            });
+        }
+
+        const banner = new Banner({
+            _id: new mongoose.Types.ObjectId(),
+            name,
+            percentage,
+            bannerImage,
+            products: bannerProducts,
+        });
+
+        const savedBanner = await banner.save();
+        res.status(201).json({ message: 'Banner created successfully', savedBanner });
+    } catch (error) {
+        console.error('Error in creating banner:', error);
+        res.status(500).json({ error: error.message });
+    }
+});
+
+router.get("/", function (req, res) {
+    Banner.find()
+        .exec()
+        .then((data) => {
+            console.log(data)
+            try {
+                const response = {
+                    count: data.length,
+                    products: data
+                };
+                res.status(200).json(response);
+            } catch (e) {
+                res.status(400).json({
+                    error: e
+                });
+            }
+
+        })
+        .catch((error) => {
+            res.status(400).json({
+                error: error
+            });
+        })
+});
+
+module.exports = router;
+
+

routes/category.js

@@ -0,0 +1,128 @@
+const Category = require("../Database/models/category");
+const express = require("express");
+const { responseAddProduct, responseFetchProduct } = require("../utils/responseModel");
+const router = express.Router();
+const firebase = require("../utils/firebase");
+const { filePath } = require("../utils/upladImageUtils");
+const multer = require('multer');
+var imageUrl = ""
+
+
+//Disk storage where image store
+const storage = multer.diskStorage({
+    destination: function (req, file, cb) {
+        cb(null, './uploads');
+    },
+    filename: function (req, file, cb) {
+        cb(null, file.originalname);
+    }
+});
+
+//Check the image formate
+const fileFilter = (req, file, cb) => {
+    // reject a file
+    if (file.mimetype === 'image/jpeg' || file.mimetype === 'image/png' || file.mimetype === 'image/jpg') {
+        cb(null, true);
+    } else {
+        cb(null, false);
+    }
+};
+
+const upload = multer({
+    storage: storage,
+    limits: {
+        fileSize: 1024 * 1024 * 5
+    },
+    fileFilter: fileFilter
+});
+
+router.get("/", async (req, res) => {
+    const categoryList = await Category.find();
+
+    if (!categoryList) {
+        res.status(500).json({ success: false });
+    }
+    res.status(200).send(
+        categoryList);
+});
+
+
+//GetCategory
+router.get("/:id", async (req, res) => {
+    const category = await Category.findById(req.params.id);
+
+    if (!category) {
+        res
+            .status(500)
+            .json({ message: "the category with the given ID not found" });
+    }
+    res.status(200).send(category);
+});
+
+
+//Add
+router.post("/", upload.single('file'), async (req, res) => {
+
+    await firebase.uploadFile(req.file.path, "hijab/" + req.file.filename)
+    await firebase.generateSignedUrl("hijab/" + req.file.filename).then(res => {
+        imageUrl = res
+    })
+
+    if (imageUrl == "") {
+        imageUrl = req.file.path
+    }
+
+    console.log(req.body);
+    let category = new Category({
+        name: req.body.name,
+        description: req.body.description,
+        image: imageUrl,
+        link: req.body.link,
+    });
+    category.save()
+        .then(result => {
+            res.status(200).send(responseFetchProduct(true, result))
+        }).catch(error => {
+            res.status(400).send(responseAddProduct(false,));
+        })
+});
+
+
+//Upadte
+router.put("/:id", async (req, res) => {
+    const category = await Category.findByIdAndUpdate(
+        req.params.id,
+        {
+            name: req.body.name,
+            icon: req.body.icon,
+            color: req.body.color,
+        },
+        { new: true }
+    );
+
+    if (!category) return res.status(400).send("the category cannot be created");
+
+    res.send(category);
+});
+
+
+//delete
+router.delete("/:id", (req, res) => {
+    Category.findByIdAndRemove(req.params.id)
+        .then((category) => {
+            if (category) {
+                return res
+                    .status(200)
+                    .json({ success: true, message: "the category deleted" });
+            } else {
+                return res
+                    .status(404)
+                    .json({ success: false, message: "categry not found" });
+            }
+        })
+        .catch((err) => {
+            return res.status(400).json({ success: false, error: err });
+        });
+});
+
+module.exports = router;

routes/changePassword.js

@@ -0,0 +1,48 @@
+var express = require('express');
+var router = express.Router();
+var app = express();
+var User = require('../Database/models/user');
+const bcrypt = require("bcrypt");
+const { successResponse, failedResponse } = require('../utils/responseModel');
+
+router.post('/', async function (req, res, next) {
+
+    var newPassword = req.body.newPassword;
+    var cnfrmNewPassword = req.body.cnfrmNewPassword;
+
+    // generate salt to hash password
+    const salt = await bcrypt.genSalt(10);
+    // now we set user password to hashed password
+    const password = await bcrypt.hash(newPassword, salt);
+
+    const updateOps = {
+        password: password,
+        passwordConf: cnfrmNewPassword
+    };
+    console.log(updateOps);
+    try {
+        const { email } = req.body;
+        // Find the user by email
+        const user = await User.findOne({ email: email }).exec();
+
+        if (user) {
+            // Update the user's password
+            await User.updateOne({ email: user.email }, { $set: updateOps }).exec();
+            res.status(200).send(successResponse("Password changed successfully!"));
+        } else {
+            res.status(201).send(failedResponse("Email not registered!", 400));
+        }
+    } catch (err) {
+        console.error(err);
+        res.status(500).send(failedResponse(err.message, 500));
+    }
+
+    // }
+    //  else {
+    //     res.send(failedResponse("Password not matched"));
+    // }
+
+});
+
+
+module.exports = router;

routes/cmd.js

@@ -0,0 +1,173 @@
+const express = require("express");
+const router = express.Router();
+const mongoose = require("mongoose");
+const multer = require('multer');
+const User = require('../Database/models/user');
+const Post = require('../Database/models/newPost');
+const Comment = require('../Database/models/comments');
+const response = require('../utils/responseModel');
+
+
+
+//Disk storage where image store
+const storage = multer.diskStorage({
+    destination: function (req, file, cb) {
+        cb(null, './uploads/fruits');
+    },
+    filename: function (req, file, cb) {
+        cb(null, file.originalname);
+    }
+});
+
+//Check the image formate
+const fileFilter = (req, file, cb) => {
+    // reject a file
+    if (file.mimetype === 'image/jpeg' || file.mimetype === 'image/png' || file.mimetype === 'image/jpg') {
+        cb(null, true);
+    } else {
+        cb(null, false);
+    }
+};
+
+const upload = multer({
+    storage: storage,
+    limits: {
+        fileSize: 1024 * 1024 * 10
+    },
+    fileFilter: fileFilter
+});
+
+router.post('/create', upload.single('file'), async (req, res, next) => {
+    console.log(req.body);
+    const userData = await User.findOne({ unique_id: req.body.userId }).exec();
+    if (!userData) {
+        res.send(response.failedResponse('Data not found!'))
+    } else {
+        console.log(" Data => " + userData)
+
+        Post.findOne({ _id: req.body.postId }, function (err, postData) {
+            if (!postData) {
+                res.status(500).json({ error: 'Post not found!' });
+            } else {
+                var comment = Comment({
+                    user: userData,
+                    post: postData,
+                    userId: req.body.userId,
+                    comment: req.body.comment,
+                    likes: userData
+                })
+
+                comment.save()
+                    .then((post) => {
+                        res.status(200).json(post);
+                    })
+                    .catch((error) => {
+                        res.status(500).json({ error: 'An error occurred while creating the post.' });
+                    });
+
+            }
+
+        });
+    }
+});
+
+router.get('/:id', async (req, res, next) => {
+    const postData = await Post.findOne({ _id: req.params.id }).exec();
+    if (!postData) {
+        res.status(500).json({ error: 'Post not found!' });
+    } else {
+        const comments = await Comment.find({ post: postData })
+            .sort({ createdAt: 'descending' });
+        if (!comments) {
+            res.status(500).json({ error: 'Comments not found!' });
+        } else {
+            res.status(200).json({
+                status: 'success',
+                count: comments.length,
+                comments,
+            });
+        }
+    }
+});
+
+router.get('/byId', async (req, res, next) => {
+    const post = await Post.findById(req.params.id).populate({
+        path: 'profile',
+        select: '-bio -website -user -_v',
+    });
+
+    if (!post) {
+        return next(new AppError('Post not found', 400));
+    }
+
+    res.status(200).json({
+        status: 'success',
+        post,
+    });
+});
+
+router.delete('/', async (req, res, next) => {
+    //const post = await Post.deleteOne({ _id: req.params.id });
+    const post = await Post.findById(req.params.id);
+    if (!post) {
+        return next(new AppError('Post not found', 400));
+    }
+    //  console.log(post, post.user.toString() === req.user.id)
+    if (post.user.toString() !== req.user.id) {
+        return next(
+            new AppError('You are not authorized to delete this post', 401)
+        );
+    }
+
+    post.commentsPost.length &&
+        (await Comment.findByIdAndDelete(post.commentsPost[0]._id));
+
+    await post.remove();
+
+    res.status(200).json({
+        message: 'deleted',
+    });
+});
+
+router.post('/like', async (req, res, next) => {
+    const post = await Post.findById(req.params.id).populate('profile');
+
+    if (!post) {
+        return next(new AppError('Post not found', 400));
+    }
+    const id = await post.getProfileId(req.user.id);
+
+    if (post.likes.includes(id)) {
+        const index = post.likes.indexOf(id);
+        post.likes.splice(index, 1);
+        await post.save((err) => {
+            console.log(err);
+        });
+        await Notification.deleteMany({
+            to: post.profile._id,
+            user: id,
+            type: 'Like',
+        });
+    } else {
+        post.likes.push(id);
+        await post.save();
+    }
+
+    res.status(200).json({
+        status: 'success',
+        post,
+    });
+});
+
+router.delete('/:id', async (req, res) => {
+    Comment.remove({ _id: req.params.id })
+        .exec()
+        .then(result => {
+            res.status(200).send(response.successResponse(result));
+        })
+        .catch(error => {
+            res.send(500).send(response.failedResponse(error))
+        });
+});
+
+module.exports = router;

routes/comment.js

@@ -0,0 +1,57 @@
+const express = require("express");
+const router = express.Router();
+const User = require('../models/user');
+const Post = require('../models/postNews');
+const Comment = require('../models/comments');
+const response = require('../utils/responseModel');
+
+
+router.post('/', async (req, res) => {
+    console.log(req.body)
+    User.findOne({ unique_id: req.body.userId }, function (err, data) {
+        if (!data) {
+            res.send(failedResponse('Data not found!'))
+        } else {
+            console.log(" Data => " + data)
+            Post.findOne({ postId: req.body.postId }, function (err, postData) {
+                if (!postData) {
+                    res.send(failedResponse('Data not found!: ' + err))
+                } else {
+                    var comment = Comment({
+                        user: data,
+                        post: postData,
+                        userId: req.body.userId,
+                        text: req.body.comment
+                    })
+
+                    comment.save()
+                        .then((post) => {
+                            res.status(200).json(post);
+                        })
+                        .catch((error) => {
+                            res.status(500).json({ error: 'An error occurred while creating the post.' });
+                        });
+
+                }
+
+            })
+        }
+    });
+
+});
+
+
+router.delete('/:id', async (req, res) => {
+
+    Comment.remove({ _id: req.params.id })
+        .exec()
+        .then(result => {
+            res.status(200).send(response.successResponse(result));
+        })
+        .catch(error => {
+            res.send(500).send(response.failedResponse(error))
+        });
+
+});
+
+module.exports = router;

routes/dairy.js

@@ -0,0 +1,125 @@
+const express = require("express");
+const router = express.Router();
+const mongoose = require("mongoose");
+const multer = require('multer');
+const Dairy = require("../Database/models/dairy");
+const { responseAddProduct, responseFetchProduct } = require("../utils/responseModel");
+const firebase = require("../utils/firebase")
+var imageUrl = ""
+
+//Disk storage where image store
+const storage = multer.diskStorage({
+    destination: function (req, file, cb) {
+        cb(null, './uploads/dairy');
+    },
+    filename: function (req, file, cb) {
+        cb(null, file.originalname);
+    }
+});
+
+//Check the image formate
+const fileFilter = (req, file, cb) => {
+    // reject a file
+    if (file.mimetype === 'image/jpeg' || file.mimetype === 'image/png' || file.mimetype === 'image/jpg') {
+        cb(null, true);
+    } else {
+        cb(null, false);
+    }
+};
+
+const upload = multer({
+    storage: storage,
+    limits: {
+        fileSize: 1024 * 1024 * 5
+    },
+    fileFilter: fileFilter
+});
+
+//Add products
+router.post("/", upload.single('file'), async (req, res, next) => {
+
+    await firebase.uploadFile(req.file.path, "Dairy/" + req.file.filename)
+    await firebase.generateSignedUrl("Dairy/" + req.file.filename).then(res => {
+        imageUrl = res
+    })
+
+    if (imageUrl == "") {
+        imageUrl = req.file.path
+    }
+
+    const dairy = Dairy({
+        _id: mongoose.Types.ObjectId(),
+        name: req.body.name,
+        price: req.body.price,
+        description: req.body.description,
+        image: imageUrl,
+        isLiked: req.body.isLiked,
+
+    });
+    dairy
+        .save()
+        .then(result => {
+            console.log(result);
+            res.status(200).send(
+                responseAddProduct(true, result));
+        })
+        .catch(err => {
+            console.log(err.message);
+            res.status(500).send(responseAddProduct(false, err));
+        });
+});
+
+
+//Get products
+router.get("/", (req, res, next) => {
+    Dairy.find()
+        .exec()
+        .then(result => {
+            res.status(200).send(responseFetchProduct(true, result));
+        })
+        .catch(err => {
+            console.log(err);
+            res.status(500).send(responseFetchProduct(false, err));
+        });
+});
+
+//Update products
+router.put('/:id', upload.single('dairyImage'), async (req, res) => {
+    const id = req.params.id;
+    console.log(req.body);
+    const updateOps = {};
+    for (const ops of Object.keys(req.body)) {
+        updateOps[ops] = req.body[ops];
+    }
+    console.log(updateOps);
+    Dairy.updateOne({ _id: id }, { $set: updateOps })
+        .exec()
+        .then(result => {
+            res.status(200).send(
+                responseAddProduct(true, result));
+        })
+        .catch(err => {
+            console.log(err);
+            res.status(500).send(responseFetchProduct(false, err));
+        });
+});
+
+//Delete products
+router.delete("/:id", (req, res) => {
+    const id = req.params.id;
+    Dairy.deleteOne({ _id: id })
+        .exec()
+        .then(result => {
+            res.status(200).send(
+                responseAddProduct(true, result));
+        })
+        .catch(err => {
+            res.status(500).send(responseFetchProduct(false, err));
+            console.log(err);
+        });
+});
+
+
+
+
+module.exports = router;

routes/driedNoodles.js

@@ -0,0 +1,128 @@
+const express = require("express");
+const router = express.Router();
+const mongoose = require("mongoose");
+const multer = require('multer');
+const DriedNoodles = require("../Database/models/DriedNoodles")
+const { responseAddProduct, responseFetchProduct } = require("../utils/responseModel");
+
+const firebase = require("../utils/firebase")
+var imageUrl = ""
+
+//Disk storage where image store
+const storage = multer.diskStorage({
+    destination: function (req, file, cb) {
+        cb(null, './uploads');
+    },
+    filename: function (req, file, cb) {
+        cb(null, file.originalname);
+    }
+});
+
+//Check the image formate
+const fileFilter = (req, file, cb) => {
+    // reject a file
+    if (file.mimetype === 'image/jpeg' || file.mimetype === 'image/png' || file.mimetype === 'image/jpg' || file.mimetype === 'image/webp') {
+        cb(null, true);
+    } else {
+        cb(null, false);
+    }
+};
+
+const upload = multer({
+    storage: storage,
+    limits: {
+        fileSize: 1024 * 1024 * 5
+    },
+    fileFilter: fileFilter
+});
+
+//Add products
+router.post("/", upload.single('file'), async (req, res, next) => {
+
+    await firebase.uploadFile(req.file.path, "DriedNoodles/" + req.file.filename)
+    await firebase.generateSignedUrl("DriedNoodles/" + req.file.filename).then(res => {
+        imageUrl = res
+    })
+
+    if (imageUrl == "") {
+        imageUrl = req.file.path
+    }
+
+    console.log(req.body)
+    const fruites = DriedNoodles({
+        _id: mongoose.Types.ObjectId(),
+        name: req.body.name,
+        price: req.body.price,
+        description: req.body.description,
+        image: imageUrl,
+        isLiked: req.body.isLiked,
+
+    });
+    fruites
+        .save()
+        .then(result => {
+            console.log(result);
+            res.status(200).send(
+                responseAddProduct(true, result));
+        })
+        .catch(err => {
+            console.log(err.message);
+            res.status(500).send(responseAddProduct(false, err));
+        });
+});
+
+
+//Get products
+router.get("/", (req, res, next) => {
+    DriedNoodles.find()
+        .exec()
+        .then(result => {
+            res.status(200).send(responseFetchProduct(true, result));
+        })
+        .catch(err => {
+            console.log(err);
+            res.status(500).send(responseFetchProduct(false, err));
+        });
+});
+
+//Update products
+router.put('/:id', upload.single('fruitImage'), async (req, res) => {
+    const id = req.params.id;
+    console.log(req.body);
+    const updateOps = {};
+    for (const ops of Object.keys(req.body)) {
+        updateOps[ops] = req.body[ops];
+    }
+
+    console.log(updateOps);
+    DriedNoodles.updateOne({ _id: id }, { $set: updateOps })
+        .exec()
+        .then(result => {
+            res.status(200).send(
+                responseFetchProduct(true, result));
+        })
+        .catch(err => {
+            console.log(err);
+            res.status(500).send(responseFetchProduct(false, err));
+        });
+});
+
+//Delete products
+router.delete("/:id", (req, res) => {
+    const id = req.params.id;
+    DriedNoodles.deleteOne({ _id: id })
+        .exec()
+        .then(result => {
+            res.status(200).send(
+                responseFetchProduct(true, result));
+        })
+        .catch(err => {
+            console.log(err);
+            res.status(500).send(responseFetchProduct(false, err));
+        });
+});
+
+
+
+
+module.exports = router;

routes/drinks.js

@@ -0,0 +1,125 @@
+const express = require("express");
+const router = express.Router();
+const mongoose = require("mongoose");
+const multer = require('multer');
+const Drinks = require("../Database/models/drinks");
+const { responseAddProduct, responseFetchProduct } = require("../utils/responseModel");
+const firebase = require("../utils/firebase")
+var imageUrl = ""
+
+//Disk storage where image store
+const storage = multer.diskStorage({
+    destination: function (req, file, cb) {
+        cb(null, './uploads/drinks');
+    },
+    filename: function (req, file, cb) {
+        cb(null, file.originalname);
+    }
+});
+
+//Check the image formate
+const fileFilter = (req, file, cb) => {
+    // reject a file
+    if (file.mimetype === 'image/jpeg' || file.mimetype === 'image/png' || file.mimetype === 'image/jpg') {
+        cb(null, true);
+    } else {
+        cb(null, false);
+    }
+};
+
+const upload = multer({
+    storage: storage,
+    limits: {
+        fileSize: 1024 * 1024 * 5
+    },
+    fileFilter: fileFilter
+});
+
+//Add products
+router.post("/", upload.single('file'), async (req, res) => {
+
+    await firebase.uploadFile(req.file.path, "Drinks/" + req.file.filename)
+    await firebase.generateSignedUrl("Drinks/" + req.file.filename).then(res => {
+        imageUrl = res
+    })
+
+    if (imageUrl == "") {
+        imageUrl = req.file.path
+    }
+
+    console.log(req.body)
+    const drinks = Drinks({
+        _id: mongoose.Types.ObjectId(),
+        name: req.body.name,
+        price: req.body.price,
+        description: req.body.description,
+        image: imageUrl,
+        isLiked: req.body.isLiked,
+
+    });
+    drinks
+        .save()
+        .then(result => {
+            console.log(result);
+            res.status(200).send(
+                responseAddProduct(true, result));
+        })
+        .catch(err => {
+            console.log(err.message);
+            res.status(500).send(responseAddProduct(false, err));
+        });
+});
+
+//Get products
+router.get("/", (req, res, next) => {
+    Drinks.find()
+        .exec()
+        .then(result => {
+            res.status(200).send(
+                responseFetchProduct(true, result));
+        })
+        .catch(err => {
+            console.log(err);
+            res.status(500).send(responseFetchProduct(false, err));
+        });
+});
+
+//Update products
+router.put('/:id', upload.single('drinksImage'), async (req, res) => {
+    const id = req.params.id;
+    console.log(req.body);
+    const updateOps = {};
+    for (const ops of Object.keys(req.body)) {
+        updateOps[ops] = req.body[ops];
+    }
+
+    console.log(updateOps);
+    Drinks.updateOne({ _id: id }, { $set: updateOps })
+        .exec()
+        .then(result => {
+            res.status(200).send(
+                responseFetchProduct(true, result));
+        })
+        .catch(err => {
+            console.log(err);
+            res.status(500).send(responseFetchProduct(false, err));
+        });
+});
+
+//Delete products
+router.delete("/:id", (req, res) => {
+    const id = req.params.id;
+    Vegetables.deleteOne({ _id: id })
+        .exec()
+        .then(result => {
+            res.status(200).send(
+                responseFetchProduct(true, result));
+        })
+        .catch(err => {
+            console.log(err);
+            res.status(500).send(responseFetchProduct(false, err));
+        });
+});
+
+
+module.exports = router;

routes/fcm.js

@@ -0,0 +1,75 @@
+var express = require('express');
+var router = express.Router();
+var FCM = require('fcm-node');
+var serverKey = 'AAAAKXRRooI:APA91bH9pMJziYPRNRI2XyMaSIG_e5a-eJzxMSkaozaCrmCencitDrTul4XyrVAV87K6d-56zGJC49y7Cz6mTRpcxca16QzmF1TF8EW7OmxHPvcQdseHWoD3TIAe62u2gfY0pVXlhJ8Y'
+var fcm = new FCM(serverKey);
+var User = require('../Database/models/user');
+const { successResponse, failedResponse } = require('../utils/responseModel');
+// const admin = require('firebase-admin');
+const admin = require("../utils/firebase")
+
+// Initialize the Firebase Admin SDK (replace with your credentials)
+// admin.initializeApp({
+//     credential: admin.credential.cert(require('../push-notification-key.json'))
+//   });
+
+router.post('/pushToken', async function (req, res) {
+    var unique_idValue = req.body.unique_id;
+    var pushTokenValue = req.body.pushToken;
+    try {
+        const data = await User.findOne({ unique_id: unique_idValue });
+        if (data) {
+            User.updateOne({
+                unique_id
+                    : data.unique_id
+            }, {
+                $set: {
+                    pushToken: pushTokenValue
+                }
+            }).exec()
+                .then(result => {
+                    res.status(200).send(successResponse("Push token updated."));
+                })
+                .catch(err => {
+                    console.log(err);
+                    res.status(500).json({
+                        error: err
+                    });
+                });
+        } else {
+            res.status(201).send(failedResponse("User not found!"));
+        }
+    } catch (e) {
+        res.status(500).send(failedResponse(e));
+    }
+});
+
+
+
+router.post('/push', async (req, res) => {
+    try {
+        const deviceToken = req.body.deviceToken;
+        const title = req.body.title;
+        const bodyText = req.body.bodyText;
+
+        const message = {
+            token: deviceToken,
+            notification: {
+                title: title,
+                body: bodyText,
+            },
+            android: {
+                priority: "high",
+            },
+        };
+
+        // Send message via Firebase Admin SDK
+        const response = await admin.messaging().send(message);
+        res.status(200).send(response);
+    } catch (err) {
+        res.status(400).send("Something has gone wrong! => " + err.message);
+        console.error("Error sending message:", err);
+    }
+});
+
+module.exports = router;

routes/forgotPassword.js

@@ -0,0 +1,214 @@
+const express = require("express");
+const router = express.Router();
+const mongoose = require("mongoose");
+const exphbs = require('express-handlebars');
+var nodemailer = require('nodemailer');
+var User = require('../Database/models/user');
+const { successResponse, failedResponse } = require("../utils/responseModel");
+
+var otp = Math.random();
+otp = otp * 10000;
+otp = parseInt(otp);
+
+
+var transporter = nodemailer.createTransport({
+
+    service: 'gmail',
+
+    auth: {
+        user: '[email protected]', // here use your real email
+        pass: 'vmllbwfiehtqaeep' // put your password correctly (not in this question please)
+    }
+});
+
+router.post('/', async (req, res, next) => {
+    try {
+        var email = req.body.email;
+        console.log(email);
+
+        var newOtpValue = Math.floor(1000 + Math.random() * 9000);
+
+        const data = await User.findOne({ email: email });
+
+        if (data) {
+            console.log(data);
+            //find the user using unique id for update token.
+            User.updateOne({
+                unique_id
+                    : data.unique_id
+            }, {
+                $set: {
+                    token: newOtpValue
+                }
+            }).exec()
+                .then(result => {
+                    //Generate Main formate how you send.
+                    var mailOptions = {
+                        priority: "high",
+                        from: '[email protected]',
+                        to: email,
+                        subject: `OTP for frogot password`,
+                        html: `<div style="font-family: Helvetica,Arial,sans-serif;min-width:1000px;overflow:auto;line-height:2">
+                           <div style="margin:50px auto;width:70%;padding:20px 0">
+                             <div style="border-bottom:1px solid #eee">
+                               <a href="" style="font-size:1.4em;color: #00466a;text-decoration:none;font-weight:600">Hayat Store</a>
+                             </div>
+                             <p style="font-size:1.1em">Hi ${data.username},</p>
+                             <p>Thank you for choosing the Hayat. Use the following OTP to complete your forgot password procedures. OTP is valid for 2 minutes</p>
+                             <h2 style="background: #00466a;margin: 0 auto;width: max-content;padding: 0 10px;color: #fff;border-radius: 4px;">${newOtpValue}</h2>
+                             <p style="font-size:0.9em;">Regards,<br />Hayat Store</p>
+                             <hr style="border:none;border-top:1px solid #eee" />
+                             <div style="float:right;padding:8px 0;color:#aaa;font-size:0.8em;line-height:1;font-weight:300">
+                               <p>Hayat Store Inc</p>
+                               <p>Tamil Nadu,</p>
+                               <p>Nagapattinum dt,</p>
+                               <p>Enangudi.</p>
+                             </div>
+                           </div>
+                         </div>` // html body
+                    };
+                    console.log(mailOptions);
+                    transporter.sendMail(mailOptions, (error, info) => {
+                        if (error) {
+                            res.status(201).send(failedResponse(error));
+                            console.log('Error found' + error);
+                        } else {
+                            //Success message
+                            res.status(200).send(successResponse("OTP sent to your email!"));
+                            console.log('');
+                        }
+                    });
+                })
+                .catch(err => {
+                    console.log(err);
+                    res.status(500).json({
+                        error: err
+                    });
+                });
+
+
+
+        } else {
+            res.send(failedResponse("Invalid user!"))
+        }
+
+    } catch (error) {
+        res.status(500).send(failedResponse(error));
+    }
+
+});
+
+
+//Verify the otp
+router.post('/verify', async (req, res, next) => {
+    try {
+        var email = req.body.email;
+        console.log(req.body.otp)
+
+        const data = await User.findOne({ email: email });
+        if (data) {
+            if (data.token == req.body.otp) {
+
+                User.updateOne({
+                    unique_id
+                        : data.unique_id
+                }, {
+                    $set: {
+                        token: ""
+                    }
+                }).exec()
+                    .then(result => {
+                        res.send(successResponse("Verified successfully!"))
+                    });
+                otp = 0;
+
+            }
+            else {
+                res.send(failedResponse("Invalid OTP!"));
+            }
+        } else {
+            res.send(failedResponse("Data not found!"));
+        }
+
+    } catch (err) {
+        res.send(failedResponse(err));
+    }
+});
+
+
+//Resend the otp
+router.post('/resend', async function (req, res) {
+    try {
+        var email = req.body.email;
+        console.log(email);
+        var newOtpValue = Math.floor(1000 + Math.random() * 9000);
+
+        const data = await User.findOne({ email: email });
+
+        if (data) {
+            console.log(data);
+            //find the user using unique id for update token.
+            User.updateOne({
+                unique_id
+                    : data.unique_id
+            }, {
+                $set: {
+                    token: newOtpValue
+                }
+            }).exec()
+                .then(result => {
+                    //Generate Main formate how you send.
+                    var mailOptions = {
+                        priority: "high",
+                        from: '[email protected]',
+                        to: '[email protected] ',
+                        subject: `OTP for frogot password`,
+                        html: `<div style="font-family: Helvetica,Arial,sans-serif;min-width:1000px;overflow:auto;line-height:2">
+                           <div style="margin:50px auto;width:70%;padding:20px 0">
+                             <div style="border-bottom:1px solid #eee">
+                               <a href="" style="font-size:1.4em;color: #00466a;text-decoration:none;font-weight:600">Hayat Store</a>
+                             </div>
+                             <p style="font-size:1.1em">Hi ${data.username},</p>
+                             <p>Thank you for choosing the Hayat. Use the following OTP to complete your forgot password procedures. OTP is valid for 1 minutes</p>
+                             <h2 style="background: #00466a;margin: 0 auto;width: max-content;padding: 0 10px;color: #fff;border-radius: 4px;">${newOtpValue}</h2>
+                             <p style="font-size:0.9em;">Regards,<br />Hayat Store</p>
+                             <hr style="border:none;border-top:1px solid #eee" />
+                             <div style="float:right;padding:8px 0;color:#aaa;font-size:0.8em;line-height:1;font-weight:300">
+                               <p>Hayat Store Inc</p>
+                               <p>Tamil Nadu,</p>
+                               <p>Nagapattinum dt,</p>
+                               <p>Enangudi.</p>
+                             </div>
+                           </div>
+                         </div>` // html body
+                    };
+                    console.log(mailOptions);
+                    transporter.sendMail(mailOptions, (error, info) => {
+                        if (error) {
+                            res.status(400).send(failedResponse(error));
+                            console.log('Error found' + error);
+                        } else {
+                            //Success message
+                            res.send(successResponse("OTP sent to your email!"));
+                            console.log('OTP sent to your email!');
+                        }
+                    });
+                })
+                .catch(err => {
+                    console.log(err);
+                    res.status(500).json({
+                        error: err
+                    });
+                });
+        } else {
+            res.status(400).send(failedResponse("Invalid user!"))
+        }
+
+    } catch (error) {
+        res.status(400).send(failedResponse(err));
+    }
+
+});
+
+
+module.exports = router;

routes/fruits.js

@@ -0,0 +1,123 @@
+const express = require("express");
+const router = express.Router();
+const mongoose = require("mongoose");
+const multer = require('multer');
+const Fruites = require("../Database/models/fruits");
+const { responseAddProduct, responseFetchProduct } = require("../utils/responseModel");
+const firebase = require("../utils/firebase")
+var imageUrl = ""
+
+//Disk storage where image store
+const storage = multer.diskStorage({
+    destination: function (req, file, cb) {
+        cb(null, './uploads/fruits');
+    },
+    filename: function (req, file, cb) {
+        cb(null, file.originalname);
+    }
+});
+
+//Check the image formate
+const fileFilter = (req, file, cb) => {
+    // reject a file
+    if (file.mimetype === 'image/jpeg' || file.mimetype === 'image/png' || file.mimetype === 'image/jpg') {
+        cb(null, true);
+    } else {
+        cb(null, false);
+    }
+};
+
+const upload = multer({
+    storage: storage,
+    limits: {
+        fileSize: 1024 * 1024 * 5
+    },
+    fileFilter: fileFilter
+});
+
+//Add products
+router.post("/", upload.single('file'), async (req, res, next) => {
+
+    await firebase.uploadFile(req.file.path, "Fruites/" + req.file.filename)
+    await firebase.generateSignedUrl("Fruites/" + req.file.filename).then(res => {
+        imageUrl = res
+    })
+
+    if (imageUrl == "") {
+        imageUrl = req.file.path
+    }
+
+    console.log(req.body)
+    const fruites = Fruites({
+        _id: mongoose.Types.ObjectId(),
+        name: req.body.name,
+        price: req.body.price,
+        description: req.body.description,
+        image: imageUrl,
+        isLiked: req.body.isLiked,
+
+    });
+    fruites
+        .save()
+        .then(result => {
+            console.log(result);
+            res.status(200).send(responseAddProduct(true, result));
+        })
+        .catch(err => {
+            console.log(err.message);
+            res.status(500).send(responseAddProduct(false, err));
+        });
+});
+
+
+//Get products
+router.get("/", (req, res, next) => {
+    Fruites.find()
+        .exec()
+        .then(result => {
+            res.status(200).send(responseFetchProduct(true, result));
+        })
+        .catch(err => {
+            console.log(err);
+            res.status(500).send(responseFetchProduct(false, err));
+        });
+});
+
+//Update products
+router.put('/:id', upload.single('file'), async (req, res) => {
+    const id = req.params.id;
+    console.log(req.body);
+    const updateOps = {};
+    for (const ops of Object.keys(req.body)) {
+        updateOps[ops] = req.body[ops];
+    }
+    console.log(updateOps);
+    Fruites.updateOne({ _id: id }, { $set: updateOps })
+        .exec()
+        .then(result => {
+            res.status(200).send(responseFetchProduct(true, result));
+        })
+        .catch(err => {
+            console.log(err);
+            res.status(500).send(responseFetchProduct(false, err));
+        });
+});
+
+//Delete products
+router.delete("/:id", (req, res) => {
+    const id = req.params.id;
+    Fruites.deleteOne({ _id: id })
+        .exec()
+        .then(result => {
+            res.status(200).send(responseFetchProduct(true, result));
+        })
+        .catch(err => {
+            console.log(err);
+            res.status(500).send(responseFetchProduct(false, err));
+        });
+});
+
+
+
+
+module.exports = router;

routes/grocery.js

@@ -0,0 +1,127 @@
+const express = require("express");
+const router = express.Router();
+const mongoose = require("mongoose");
+const multer = require('multer');
+const Grocery = require("../Database/models/gocery");
+const { responseAddProduct, responseFetchProduct } = require("../utils/responseModel");
+const firebase = require("../utils/firebase")
+var imageUrl = ""
+
+//Disk storage where image store
+const storage = multer.diskStorage({
+    destination: function (req, file, cb) {
+        cb(null, './uploads/grocery');
+    },
+    filename: function (req, file, cb) {
+        cb(null, file.originalname);
+    }
+});
+
+//Check the image formate
+const fileFilter = (req, file, cb) => {
+    // reject a file
+    if (file.mimetype === 'image/jpeg' || file.mimetype === 'image/png' || file.mimetype === 'image/jpg') {
+        cb(null, true);
+    } else {
+        cb(null, false);
+    }
+};
+
+const upload = multer({
+    storage: storage,
+    limits: {
+        fileSize: 1024 * 1024 * 10
+    },
+    fileFilter: fileFilter
+});
+
+//Add products
+router.post("/", upload.single('file'), async (req, res, next) => {
+
+
+    await firebase.uploadFile(req.file.path, "Grocery/" + req.file.filename)
+    await firebase.generateSignedUrl("Grocery/" + req.file.filename).then(res => {
+        imageUrl = res
+    })
+
+    if (imageUrl == "") {
+        imageUrl = req.file.path
+    }
+
+    console.log(req.body)
+    const grocery = Grocery({
+        _id: mongoose.Types.ObjectId(),
+        name: req.body.name,
+        price: req.body.price,
+        description: req.body.description,
+        image: imageUrl,
+        isLiked: req.body.isLiked,
+
+    });
+    grocery
+        .save()
+        .then(result => {
+            console.log(result);
+            res.status(200).send(responseAddProduct(true, result));
+        })
+        .catch(err => {
+            console.log(err.message);
+            res.status(500).send(responseAddProduct(false, err));
+        });
+});
+
+
+//Get products
+router.get("/", (req, res, next) => {
+    Grocery.find()
+        .exec()
+        .then(result => {
+            res.status(200).send(responseFetchProduct(true, result));
+        })
+        .catch(err => {
+            console.log(err);
+            res.status(500).send(responseFetchProduct(false, err));
+        });
+});
+
+//Update products
+router.put('/:id', upload.single('file'), async (req, res) => {
+    const id = req.params.id;
+    console.log(req.body);
+
+
+    const updateOps = {};
+
+    for (const ops of Object.keys(req.body)) {
+        updateOps[ops] = req.body[ops];
+    }
+
+    Grocery.updateOne({ _id: id }, { $set: updateOps })
+        .exec()
+        .then(result => {
+            res.status(200).send(responseFetchProduct(true, result));
+        })
+        .catch(err => {
+            console.log(err);
+            res.status(500).send(responseFetchProduct(false, err));
+        });
+});
+
+//Delete products
+router.delete("/:id", (req, res) => {
+    const id = req.params.id;
+    Grocery.deleteOne({ _id: id })
+        .exec()
+        .then(result => {
+            res.status(200).send(responseFetchProduct(true, result));
+        })
+        .catch(err => {
+            console.log(err);
+            res.status(500).send(responseFetchProduct(false, err));
+        });
+});
+
+
+
+
+module.exports = router;

routes/healthCare.js

@@ -0,0 +1,126 @@
+const express = require("express");
+const router = express.Router();
+const mongoose = require("mongoose");
+const multer = require('multer');
+const HealthCare = require("../Database/models/healthCare");
+const { responseAddProduct, responseFetchProduct } = require("../utils/responseModel");
+
+const firebase = require("../utils/firebase")
+var imageUrl = ""
+
+//Disk storage where image store
+const storage = multer.diskStorage({
+    destination: function (req, file, cb) {
+        cb(null, './uploads/healthCare');
+    },
+    filename: function (req, file, cb) {
+        cb(null, file.originalname);
+    }
+});
+
+//Check the image formate
+const fileFilter = (req, file, cb) => {
+    // reject a file
+    if (file.mimetype === 'image/jpeg' || file.mimetype === 'image/png' || file.mimetype === 'image/jpg') {
+        cb(null, true);
+    } else {
+        cb(null, false);
+    }
+};
+
+const upload = multer({
+    storage: storage,
+    limits: {
+        fileSize: 1024 * 1024 * 5
+    },
+    fileFilter: fileFilter
+});
+
+//Add products
+router.post("/", upload.single('file'), async (req, res, next) => {
+
+    await firebase.uploadFile(req.file.path, "HealthCare/" + req.file.filename)
+    await firebase.generateSignedUrl("HealthCare/" + req.file.filename).then(res => {
+        imageUrl = res
+    })
+
+    if (imageUrl == "") {
+        imageUrl = req.file.path
+    }
+
+    console.log(req.body)
+    const fruites = HealthCare({
+        _id: mongoose.Types.ObjectId(),
+        name: req.body.name,
+        price: req.body.price,
+        description: req.body.description,
+        image: imageUrl,
+        isLiked: req.body.isLiked,
+
+    });
+    fruites
+        .save()
+        .then(result => {
+            console.log(result);
+            res.status(200).send(
+                responseAddProduct(true, result));
+        })
+        .catch(err => {
+            console.log(err.message);
+            res.status(500).send(responseAddProduct(false, err));
+        });
+});
+
+
+//Get products
+router.get("/", (req, res, next) => {
+    HealthCare.find()
+        .exec()
+        .then(result => {
+            res.status(200).send(responseFetchProduct(true, result));
+        })
+        .catch(err => {
+            console.log(err);
+            res.status(500).send(responseFetchProduct(false, err));
+        });
+});
+
+//Update products
+router.put('/:id', upload.single('file'), async (req, res) => {
+    const id = req.params.id;
+    console.log(req.body);
+    const updateOps = {};
+    for (const ops of Object.keys(req.body)) {
+        updateOps[ops] = req.body[ops];
+    }
+
+    console.log(updateOps);
+    HealthCare.updateOne({ _id: id }, { $set: updateOps })
+        .exec()
+        .then(result => {
+            res.status(200).send(responseFetchProduct(true, result));
+        })
+        .catch(err => {
+            console.log(err);
+            res.status(500).send(responseFetchProduct(false, err));
+        });
+});
+
+//Delete products
+router.delete("/:id", (req, res) => {
+    const id = req.params.id;
+    HealthCare.deleteOne({ _id: id })
+        .exec()
+        .then(result => {
+            res.status(200).send(responseFetchProduct(true, result));
+        })
+        .catch(err => {
+            console.log(err);
+            res.status(500).send(responseFetchProduct(false, err));
+        });
+});
+
+
+
+
+module.exports = router;

routes/home.js

@@ -0,0 +1,80 @@
+const express = require("express");
+const router = express.Router();
+const mongoose = require("mongoose");
+const multer = require('multer');
+const DriedNoodles = require("../Database/models/DriedNoodles")
+const { responseAddProduct, responseFetchProduct } = require("../utils/responseModel");
+const Banner = require("../Database/models/banner")
+const Category = require("../Database/models/category")
+const Order = require("../Database/models/order");
+const Products = require("../Database/models/product");
+const User = require("../Database/models/user");
+const featureProduct = require("../Database/mufiModels/featureProduct");
+
+router.get("/", async (req, res, next) => {
+    try {
+        const userId = req.query.id;
+        console.log("UserId -> ", userId);
+        const bannersList = await Banner.find();
+        const categoryList = await Category.find();
+        let userData = {}
+        let ordersList = {}
+        try {
+            ordersList = await Order.find({ unique_id: userId });
+            const tempData = await User.findOne({ unique_id: userId });
+            userData = tempData.toObject();
+            delete userData.passwordConf;
+            delete userData.password;
+            delete userData.pushToken;
+            console.log(userData);
+        } catch (err) {
+            console.log(err)
+        }
+
+        const featureProductList = await featureProduct.find()
+        const productsList = await Products.find();
+
+        const response = {
+            user: userData,
+            banner: bannersList,
+            categories: categoryList,
+            // recentPurchase: ordersList,
+            products: featureProductList ?? productsList
+        }
+
+        res.status(200).send(responseFetchProduct(true, response))
+
+    } catch (e) {
+        res.status(500).send(responseFetchProduct(false, e))
+    }
+});
+
+
+// router.get("/:id", async (req, res) => {
+//     try {
+//         const bannersList = await Banner.find();
+//         const categoryList = await Category.find();
+//         const ordersList = {}
+//         try {
+//             ordersList = await Order.find({ unique_id: req.params.id });
+//         } catch (err) {
+//             console.log(err)
+//         }
+//         const productsList = await Products.find();
+
+//         const response = {
+//             banner: bannersList,
+//             categories: categoryList,
+//             recentPurchase: ordersList,
+//             products: productsList
+//         }
+
+//         res.status(200).send(responseFetchProduct(true, response))
+
+//     } catch (e) {
+//         res.status(500).send(responseFetchProduct(false, e))
+//     }
+
+// });
+
+module.exports = router;

routes/login.js

@@ -0,0 +1,93 @@
+var express = require('express');
+var router = express.Router();
+var User = require('../Database/models/user');
+const bcrypt = require("bcrypt");
+const { profileResponse, failedResponse, successResponse } = require('../utils/responseModel');
+const verifyGoogleToken = require('../core/auth');
+
+// Middleware to parse JSON bodies
+router.use(express.json());
+
+// Utility function to generate unique_id
+async function generateUniqueId() {
+    const lastUser = await User.findOne({}).sort({ _id: -1 }).limit(1);
+    return lastUser ? lastUser.unique_id + 1 : 1;
+}
+
+// Login user
+router.post('/', async function (req, res, next) {
+    const { email, mobileNumber, password, googleToken } = req.body;
+
+    // Validate input
+    if (!email && !mobileNumber && !googleToken) {
+        return res.status(400).send(failedResponse('Please provide email, mobile number, or Google token.'));
+    }
+
+    try {
+        let user;
+        // If Google token is provided, handle Google login
+        if (googleToken) {
+            // Verify Google token and get user information
+            const googleUserDetails = await verifyGoogleToken(googleToken);
+            const googleUser = googleUserDetails.getPayload();
+            console.log("Google user = ", googleUser.name);
+            console.log("Google user = ", googleUser.email);
+            // Find user by Google ID
+            await User.findOne({ email: googleUser.email }).exec().then(async (existUser) => {
+                if (existUser) {
+                    user = existUser;
+                } else {
+                    console.log(" User not found!");
+                    // If user is not found, create a new user
+                    const generatedUniqueId = await generateUniqueId();
+                    const googleUserId = googleUserDetails.getUserId();
+                    const password = googleUser.email + "/" + googleUserId;
+                    const hashedPassword = await bcrypt.hash(password, 10);
+
+                    const newUser = new User({
+                        unique_id: generatedUniqueId, // Implement this function to generate a unique ID
+                        email: googleUser.email,
+                        username: googleUser.name,
+                        profilePic: googleUser.picture,
+                        googleId: googleUserId,
+                        password: hashedPassword
+                        // Add other fields if needed
+                    });
+                    console.log(newUser);
+                    await newUser.save(); // Save the new user to the database
+                    user = newUser;
+                }
+            }); // Use .exec() to ensure a promise is returned
+        } else {
+            // Handle email or mobile number login
+            if (email) {
+                user = await User.findOne({ email });
+            } else if (mobileNumber) {
+                user = await User.findOne({ mobileNumber });
+            }
+
+            if (!user) {
+                return res.status(201).send(failedResponse('User not found.'));
+            }
+
+            // Validate password if email or mobile number is used
+            if (password) {
+                const validPassword = await bcrypt.compare(password, user.password);
+                if (!validPassword) {
+                    return res.status(400).send(failedResponse('Wrong password.'));
+                }
+            }
+        }
+
+        // // Success
+        // req.userId = user.unique_id; // Set user ID in session or handle as needed
+        // console.log(user);
+        res.status(200).send(profileResponse("Login successful", 200, user));
+    } catch (err) {
+        // Handle errors
+        console.error(err);
+        res.status(500).send(failedResponse('Internal server error.'));
+    }
+});
+
+module.exports = router;

routes/logout.js

@@ -0,0 +1,36 @@
+var express = require('express');
+var router = express.Router();
+var app = express();
+var User = require('../models/user');
+const bcrypt = require("bcrypt");
+const jwt = require("jsonwebtoken");
+
+
+router.post('/logout', function (req, res, next) {
+
+    var session = {
+        "cookie": {
+            path: '/', _expires: null,
+            originalMaxAge: null,
+            httpOnly: true
+        },
+        userId: req.body.user_id
+    }
+    console.log(session)
+
+    if (session) {
+        // delete session object
+        req.session.destroy(function (err) {
+            if (err) {
+                return res.send(failedResponse("Logout failed!"))
+
+            } else {
+                return res.send(successResponse('Logout success'));
+
+            }
+        });
+        req.session.destroy;
+    }
+});
+
+module.exports = router;