database-connector 1.0.0

package/models/Payment.js

@@ -0,0 +1,117 @@
+const mongoose = require('mongoose');
+var ObjectId = require('mongodb').ObjectID;
+
+const paymentSchema = new mongoose.Schema(
+	{
+		userId: {
+			type: mongoose.Schema.Types.ObjectId,
+			required: true,
+			ref: 'User',
+		},
+		sellerId: {
+			type: mongoose.Schema.Types.ObjectId,
+			required: true,
+			ref: 'User',
+		},
+		gateway: {
+			type: String,
+			required: true,
+		},
+
+		paymentStatus: {
+			type: String,
+			required: true,
+		},
+		paymentAmount: {
+			type: Number,
+			required: true,
+		},
+		paymentCurrency: {
+			type: String,
+			required: true,
+		},
+		paymentMethod: {
+			type: String,
+			required: true,
+		},
+		paymentDate: {
+			type: Date,
+			required: true,
+		},
+		paymentTime: {
+			type: Date,
+			required: true,
+		},
+		paymentDetails: {
+			type: Object,
+			required: true,
+		},
+		totalPrice: {
+			type: Number,
+			required: true,
+			default: 0,
+		},
+		card: {
+			brand: {
+				type: String,
+				required: true,
+			},
+			last4: {
+				type: String,
+				required: true,
+			},
+			exp_month: {
+				type: Number,
+				required: true,
+			},
+			exp_year: {
+				type: Number,
+				required: true,
+			},
+			funding: {
+				type: String,
+				required: true,
+			},
+			country: {
+				type: String,
+				required: true,
+			},
+			name: {
+				type: String,
+				required: true,
+			},
+			address_line1: {
+				type: String,
+				required: true,
+			},
+			address_line2: {
+				type: String,
+				required: true,
+			},
+			address_city: {
+				type: String,
+				required: true,
+			},
+			ccvVerified: {
+				type: Boolean,
+				required: true,
+				default: false,
+			},
+			ccv: {
+				type: String,
+				required: true,
+			},
+		},
+		timestamps: {
+			type: Date,
+			required: true,
+			default: Date.now(),
+		},
+		token: {
+			type: String,
+			required: true,
+		},
+	},
+	{ timestamps: true }
+);
+module.exports = mongoose.model('Payment', paymentSchema);

package/models/PaymentType.js

@@ -0,0 +1,14 @@
+const mongoose = require('mongoose');
+
+const paymentTypeSchema = new mongoose.Schema(
+	{
+		type: {
+			type: String,
+			required: true,
+			unique: true,
+		},
+	},
+	{}
+);
+
+module.exports = mongoose.model('PaymentType', paymentTypeSchema);

package/models/Plan.js

@@ -0,0 +1,42 @@
+const mongoose = require('mongoose');
+
+const planSchema = new mongoose.Schema(
+	{
+		type: {
+			type: String,
+			required: true,
+			unique: false,
+			validate: {
+				validator: function (value) {
+					const predefinedTypes = ['Annual', 'Semi-annual', 'Quarterly', 'Monthly'];
+					return predefinedTypes.includes(value) || /^[a-zA-Z\s]+$/.test(value);
+				},
+				message: props => `${props.value} is not a valid plan type!`
+			}
+		},
+		months: {
+			type: Number,
+			required: true,
+			unique: false
+		},
+		price: {
+			type: Number,
+			required: true,
+		},
+		reductionOffers: [
+			{
+				type: mongoose.Schema.Types.ObjectId,
+				ref: 'ReductionOffer'
+			}
+		],
+		status: {
+			type: String,
+			enum: ['active', 'suspended'],
+			default: 'active',
+		},
+
+	},
+	{}
+);
+
+module.exports = mongoose.model('Plan', planSchema);

package/models/Policy.js

@@ -0,0 +1,94 @@
+const { Schema, model } = require('mongoose');
+
+exports.policySchema = new Schema(
+	{   
+        
+        workingTime : {
+            type : {
+                openTime: { type: String  ,  default : ""},
+                closeTime: { type: String ,  default : ""} ,
+            } , 
+        },
+        pickup: { 
+            type : {
+                timeLimit : { type: Number  ,  default : null} , 
+            } , 
+        },
+        delivery: {
+            type : {
+                    delivery : {type : Boolean,  default : null } , 
+                    zone : {
+                        centerPoint : {
+                            latitude : { type : Number ,  default : null} , 
+                            longitude : { type : Number ,  default : null} , 
+                        } , 
+                        radius : { type : Number ,  default : null } , 
+                    } ,
+                    pricing : {
+                        fixe : {type : Number ,  default : null} ,
+                        km : {type : Number ,  default : null} ,
+                    } ,
+                }
+        
+            } ,
+        
+        reservation : {
+            type : {
+                duration : {type : Number ,  default : null} ,
+                payment : {
+                    free : {type : Boolean ,  default : null} ,
+                    partial : { 
+                        fixe : {type : Number ,  default : null} ,
+                        percentage : {type : Number ,  default : null} ,
+                    } ,
+                    total : {type : Boolean ,  default : null} ,
+                } ,
+                cancelation : {
+                    restrictions : {
+                        fixe : {type : Number ,  default : null} ,
+                        percentage : {type : Number ,  default : null} ,
+                    }
+                } ,
+            } , 
+        } , 
+        return : {
+            type : {
+                duration : {type : Number ,  default : null} ,
+                productStatus : {type : String ,  default : ""} ,
+                returnMethod : {type : String ,  default : ""} ,
+                refund : {
+                    order : {
+                        fixe : {type : Number ,  default : null} ,
+                        percentage : {type : Number ,  default : null} ,
+                    } , 
+                    shipping : {
+                        fixe : {type : Number ,  default : null} ,
+                        percentage : {type : Number ,  default : null} ,
+                    },
+                } , 
+            } , 
+
+        } , 
+        order : {
+            type : {
+            
+            notification : {
+                realtime :{type : Boolean ,  default : null} , 
+                time :{type : Number ,  default : null} , 
+                perOrdersNbr :{type : Number ,  default : null} , 
+                sendMode : {
+                    mail :{type : Boolean ,  default : null} , 
+                    sms :{type : Boolean ,  default : null} , 
+                    popup :{type : Boolean ,  default : null} , 
+                    vibration :{type : Boolean ,  default : null} , 
+                    ringing :{type : Boolean ,  default : null} , 
+                } ,
+            } 
+
+            }
+        }
+    },
+	{
+        
+	}
+);

package/models/Product.js

@@ -0,0 +1,197 @@
+const mongoose = require('mongoose');
+const { policySchema } = require('./Policy');
+var ObjectId = require('mongodb').ObjectID;
+
+const productSchema = new mongoose.Schema(
+	{
+		name: {
+			type: String,
+			required: true,
+		},
+		description: { type: String, required: true },
+		price: { type: Number, required: true },
+		storeCategoryId : {
+			type: mongoose.Schema.Types.ObjectId,
+			ref: 'StoreCategory',
+			required: true,
+		} , 
+		categoryId: {
+			type: mongoose.Schema.Types.ObjectId,
+			ref: 'Category',
+			required: true,
+		},
+		subCategoryId: {
+			type: mongoose.Schema.Types.ObjectId,
+			//required: true,
+		},
+		rayonId: {
+			type: mongoose.Schema.Types.ObjectId,
+			required: true,
+		},
+		//customCategory: { type: String, required: true },
+		//customCategoryId: { type: String, required: true },
+		images: [{ type: String, required: true }],
+		tags: [{ type: String, required: true }],
+		variants: [
+			{
+				characterstics: {
+					type: Object,
+					required: true,
+				},
+				price: {
+					type: Number,
+					required: true,
+				},
+				quantity: {
+					type: Number,
+					required: true,
+					default: 1,
+				},
+				img: {
+					type: String,
+					//required: true,
+				},
+				available: {
+					type: Boolean,
+					required: true,
+					default: true,
+				},
+			},
+		],
+		sellerId: {
+			type: mongoose.Schema.Types.ObjectId,
+			ref: 'Seller',
+			required: true,
+		},
+		storeId: {
+			type: mongoose.Schema.Types.ObjectId,
+			ref: 'Store',
+			required: true,
+		},
+		deleted: {
+			type: Boolean,
+			required: true,
+			default: false,
+		},
+
+		discountCode: {
+			type: String,
+		},
+		discount: {
+			type: Number,
+			default: 0,
+		},
+		discountType: {
+			type: String,
+			enum: ['percentage', 'amount'],
+		},
+		discountExpiration: {
+			type: Date,
+			required: true,
+			default: Date.now() + 86400000,
+		},
+		flashDeal: {
+			type: mongoose.Schema.Types.ObjectId,
+			ref: 'FlashDeal',
+		},
+		offer: {
+			type: mongoose.Schema.Types.ObjectId,
+			ref: 'Offer',
+		},
+		
+		
+		numberOfSales: {
+			type: Number,
+			default: 0,
+		  },
+		  numberOfViews: {
+			type: Number,
+			default: 0,
+		  },
+		  numberOfSearches: {
+			type: Number,
+			default: 0,
+		  },
+		  averageRating: {
+			type: Number,
+			default: 0,
+		  },
+
+		reports: [
+			{
+				idUser: {
+					type: mongoose.Schema.Types.ObjectId,
+					ref: 'User',
+				},
+
+				message: { type: String },
+
+				date: {
+					type: Date,
+					required: true,
+				},
+			},
+		],
+		policy: policySchema,
+	},
+	{
+		timestamp: true,
+		toJSON: { virtuals: true },
+	}
+);/*
+productSchema.virtual('quantity').get(function () {
+	const variants = this.variants;
+	return variants.reduce(function (total, currentValue) {
+		return total + currentValue.quantity;
+	}, 0);
+});
+productSchema.virtual('PriceMin').get(function () {
+	const variants = this.variants;
+	return variants.reduce(function (prev, curr) {
+		return prev.price < curr.price ? prev : curr;
+	}).price;
+});
+
+productSchema.virtual('PriceMax').get(function () {
+	const variants = this.variants;
+	return variants.reduce(function (prev, curr) {
+		return prev.price > curr.price ? prev : curr;
+	}).price;
+});*/
+//virtual array of all the images of the product
+productSchema.virtual('imagesss').get(function () {
+	if (this.images != null) {
+		const images = this.images;
+		console.log(images);
+		console.log('images');
+		return images.map(function (image) {
+			return `${process.env.APP_URL}/${image}`;
+		});
+	}
+});
+productSchema.virtual('discounted').get(function () {
+	if (this.offer) {
+		console.log('Disount')
+	
+	  return this.offer.discount;
+	  
+	} else {
+	  return this.price;
+	}
+  });
+//virtual array for all the images of the variants
+productSchema.virtual('variantImages').get(function () {
+	if (this.variants != null) {
+		const variants = this.variants;
+		console.log(variants);
+		return variants.map(function (variant) {
+			if (variant.img != null) {
+				return `${process.env.APP_URL}/${variant.img}`;
+			} else {
+				return `${process.env.APP_URL}/images/default.png`;
+			}
+		});
+	}
+});
+
+module.exports = mongoose.model('Product', productSchema);

package/models/ReductionOffer.js

@@ -0,0 +1,89 @@
+const mongoose = require('mongoose');
+
+const ReductionOfferSchema = new mongoose.Schema(
+	{
+		name: {
+			type: String,
+			unique: true,
+			required: true,
+		},
+		discount: {
+			type: Number,
+			required: true,
+		},
+		storesNumber: {
+			type: Number,
+			required: true,
+		},
+		plan: {
+			type: mongoose.Schema.Types.ObjectId,
+			required: true,
+			ref: 'Plan',
+		},
+		StartDate: {
+			type: Date,
+			required: false,
+		},
+		EndDate: {
+			type: Date,
+			required: false,
+		},
+		description: {
+			type: String,
+			required: false,
+		},
+		status: {
+			type: String,
+			enum: ['inactive', 'active', 'expired'],
+			default: 'inactive',
+		},
+		plan: {
+			type: mongoose.Schema.Types.ObjectId,
+			ref: 'Plan',
+			required: true
+		}
+	},
+	{ timestamps: true }
+);
+
+// Pre-save hook to ensure only one offer is active at a time
+ReductionOfferSchema.pre('save', async function (next) {
+	const offer = this;
+
+	// If the current offer is being set to active
+	if (offer.status === 'active') {
+		// Find the currently active offer
+		const activeOffer = await mongoose.model('ReductionOffer').findOne({ status: 'active' });
+
+		// If another active offer is found and it's not the current offer being updated
+		if (activeOffer && activeOffer._id.toString() !== offer._id.toString()) {
+			// Set the old active offer to inactive
+			activeOffer.status = 'inactive';
+			await activeOffer.save();
+		}
+	}
+
+	next();
+});
+
+// Pre-update hook to ensure only one offer is active at a time
+ReductionOfferSchema.pre('findOneAndUpdate', async function (next) {
+	const update = this.getUpdate();
+
+	// If the status is being set to active
+	if (update.status === 'active') {
+		// Find the currently active offer
+		const activeOffer = await mongoose.model('ReductionOffer').findOne({ status: 'active' });
+
+		// If another active offer is found and it's not the current offer being updated
+		if (activeOffer && activeOffer._id.toString() !== this.getQuery()._id.toString()) {
+			// Set the old active offer to inactive
+			activeOffer.status = 'inactive';
+			await activeOffer.save();
+		}
+	}
+
+	next();
+});
+
+module.exports = mongoose.model('ReductionOffer', ReductionOfferSchema);

package/models/ResetPassword.js

@@ -0,0 +1,23 @@
+const mongoose = require('mongoose');
+
+const resetPasswordSchema = new mongoose.Schema(
+	{
+		userId: {
+			type: mongoose.Schema.Types.ObjectId,
+			required: true,
+			ref: 'User',
+		},
+		token: {
+			type: String,
+			required: true,
+		},
+		createAt: {
+			type: Date,
+			default: Date.now,
+            expires : 3600
+		}
+	},
+	{ toJSON: { virtuals: true } }
+);
+
+module.exports = mongoose.model('ResetPassword', resetPasswordSchema);

package/models/Sale.js

@@ -0,0 +1,11 @@
+const mongoose = require('mongoose');
+
+const Sale = new mongoose.Schema({
+  sellerId: { type: mongoose.Schema.Types.ObjectId, ref: 'Seller' },
+  storeId: { type: mongoose.Schema.Types.ObjectId, ref: 'Store' },
+  productId: { type: mongoose.Schema.Types.ObjectId, ref: 'Product' },
+  date: { type: Date, required: true },
+  region: { type: String }, // If you want to track region for each sale
+});
+
+module.exports = mongoose.model('Sale', Sale);