create-vrrsystem-app 1.0.0

package/templates/VehicleRentalReservationSystem/backend-project/controllers/reservation.controller.js

@@ -0,0 +1,94 @@
+const RR = require('../models/ReservationRental');
+const Vehicle = require('../models/Vehicle');
+
+const pop = (q) => q.populate('customerId').populate('vehicleId').populate('userId', 'username fullName role');
+
+exports.list = async (req, res, next) => {
+  try {
+    const { search = '', status, page = 1, limit = 10 } = req.query;
+    const q = {};
+    if (status) q.reservationStatus = status;
+    const total = await RR.countDocuments(q);
+    let items = await pop(RR.find(q).sort('-createdAt').skip((page-1)*limit).limit(+limit));
+    if (search) {
+      const re = new RegExp(search, 'i');
+      items = items.filter(r => re.test(r.customerId?.fullName || '') || re.test(r.vehicleId?.plateNumber || ''));
+    }
+    res.json({ items, total, page: +page, pages: Math.ceil(total/limit) });
+  } catch (e) { next(e); }
+};
+
+exports.get = async (req, res, next) => { try { const r = await pop(RR.findById(req.params.id)); if(!r) return res.status(404).json({message:'Not found'}); res.json(r);} catch(e){next(e);} };
+
+exports.create = async (req, res, next) => {
+  try {
+    const body = { ...req.body, userId: req.user._id };
+    const start = new Date(body.startDate), end = new Date(body.endDate);
+    const days = Math.max(1, Math.ceil((end - start) / 86400000));
+    const v = await Vehicle.findById(body.vehicleId);
+    if (!v) return res.status(404).json({ message: 'Vehicle not found' });
+    if (!body.rentalFee) body.rentalFee = days * (v.dailyRate || 50);
+    const r = await RR.create(body);
+    await Vehicle.findByIdAndUpdate(v._id, { status: 'RESERVED' });
+    res.status(201).json(await pop(RR.findById(r._id)));
+  } catch (e) { next(e); }
+};
+
+exports.update = async (req, res, next) => {
+  try {
+    const r = await RR.findByIdAndUpdate(req.params.id, req.body, { new: true, runValidators: true });
+    if (!r) return res.status(404).json({ message: 'Not found' });
+    res.json(await pop(RR.findById(r._id)));
+  } catch (e) { next(e); }
+};
+
+exports.remove = async (req, res, next) => {
+  try {
+    const r = await RR.findById(req.params.id);
+    if (r) await Vehicle.findByIdAndUpdate(r.vehicleId, { status: 'AVAILABLE' });
+    await RR.findByIdAndDelete(req.params.id);
+    res.json({ message: 'Deleted' });
+  } catch (e) { next(e); }
+};
+
+exports.approve = async (req, res, next) => {
+  try {
+    const r = await RR.findByIdAndUpdate(req.params.id, { reservationStatus: 'APPROVED' }, { new: true });
+    res.json(await pop(RR.findById(r._id)));
+  } catch (e) { next(e); }
+};
+exports.reject = async (req, res, next) => {
+  try {
+    const r = await RR.findByIdAndUpdate(req.params.id, { reservationStatus: 'REJECTED' }, { new: true });
+    if (r) await Vehicle.findByIdAndUpdate(r.vehicleId, { status: 'AVAILABLE' });
+    res.json(await pop(RR.findById(r._id)));
+  } catch (e) { next(e); }
+};
+exports.pickup = async (req, res, next) => {
+  try {
+    const r = await RR.findByIdAndUpdate(req.params.id, { rentalDate: new Date(), rentalStatus: 'ONGOING' }, { new: true });
+    if (r) await Vehicle.findByIdAndUpdate(r.vehicleId, { status: 'RENTED' });
+    res.json(await pop(RR.findById(r._id)));
+  } catch (e) { next(e); }
+};
+exports.returnVehicle = async (req, res, next) => {
+  try {
+    const r = await RR.findById(req.params.id);
+    if (!r) return res.status(404).json({ message: 'Not found' });
+    const now = new Date();
+    const late = r.endDate && now > r.endDate;
+    let extra = 0;
+    if (late) {
+      const v = await Vehicle.findById(r.vehicleId);
+      const lateDays = Math.ceil((now - r.endDate) / 86400000);
+      extra = lateDays * (v?.dailyRate || 50) * 1.5;
+    }
+    r.returnDate = now;
+    r.rentalStatus = late ? 'LATE' : 'RETURNED';
+    r.reservationStatus = 'COMPLETED';
+    r.rentalFee = (r.rentalFee || 0) + extra;
+    await r.save();
+    await Vehicle.findByIdAndUpdate(r.vehicleId, { status: 'AVAILABLE' });
+    res.json(await pop(RR.findById(r._id)));
+  } catch (e) { next(e); }
+};

package/templates/VehicleRentalReservationSystem/backend-project/controllers/user.controller.js

@@ -0,0 +1,16 @@
+const User = require('../models/User');
+exports.list = async (req, res, next) => { try { res.json(await User.find().sort('-createdAt')); } catch(e){next(e);} };
+exports.get = async (req, res, next) => { try { const u = await User.findById(req.params.id); if(!u) return res.status(404).json({message:'Not found'}); res.json(u);} catch(e){next(e);} };
+exports.create = async (req, res, next) => { try { res.status(201).json(await User.create(req.body)); } catch(e){next(e);} };
+exports.update = async (req, res, next) => {
+  try {
+    const data = { ...req.body };
+    if (!data.password) delete data.password;
+    const u = await User.findById(req.params.id);
+    if (!u) return res.status(404).json({ message: 'Not found' });
+    Object.assign(u, data);
+    await u.save();
+    res.json(u);
+  } catch (e) { next(e); }
+};
+exports.remove = async (req, res, next) => { try { await User.findByIdAndDelete(req.params.id); res.json({ message: 'Deleted' }); } catch(e){next(e);} };

package/templates/VehicleRentalReservationSystem/backend-project/controllers/vehicle.controller.js

@@ -0,0 +1,20 @@
+const Vehicle = require('../models/Vehicle');
+exports.list = async (req, res, next) => {
+  try {
+    const { search = '', status, page = 1, limit = 10 } = req.query;
+    const q = {};
+    if (search) q.$or = [
+      { plateNumber: new RegExp(search, 'i') },
+      { brand: new RegExp(search, 'i') },
+      { model: new RegExp(search, 'i') }
+    ];
+    if (status) q.status = status;
+    const total = await Vehicle.countDocuments(q);
+    const items = await Vehicle.find(q).sort('-createdAt').skip((page-1)*limit).limit(+limit);
+    res.json({ items, total, page: +page, pages: Math.ceil(total/limit) });
+  } catch (e) { next(e); }
+};
+exports.get = async (req, res, next) => { try { const c = await Vehicle.findById(req.params.id); if(!c) return res.status(404).json({message:'Not found'}); res.json(c);} catch(e){next(e);} };
+exports.create = async (req, res, next) => { try { res.status(201).json(await Vehicle.create(req.body)); } catch(e){next(e);} };
+exports.update = async (req, res, next) => { try { const c = await Vehicle.findByIdAndUpdate(req.params.id, req.body, { new: true, runValidators: true }); if(!c) return res.status(404).json({message:'Not found'}); res.json(c);} catch(e){next(e);} };
+exports.remove = async (req, res, next) => { try { await Vehicle.findByIdAndDelete(req.params.id); res.json({ message: 'Deleted' }); } catch(e){next(e);} };

package/templates/VehicleRentalReservationSystem/backend-project/middleware/auth.js

@@ -0,0 +1,22 @@
+const jwt = require('jsonwebtoken');
+const User = require('../models/User');
+
+exports.protect = async (req, res, next) => {
+  try {
+    const header = req.headers.authorization;
+    if (!header || !header.startsWith('Bearer ')) return res.status(401).json({ message: 'No token' });
+    const token = header.split(' ')[1];
+    const decoded = jwt.verify(token, process.env.JWT_SECRET);
+    const user = await User.findById(decoded.id);
+    if (!user || !user.active) return res.status(401).json({ message: 'Invalid token' });
+    req.user = user;
+    next();
+  } catch (e) {
+    return res.status(401).json({ message: 'Unauthorized', error: e.message });
+  }
+};
+
+exports.authorize = (...roles) => (req, res, next) => {
+  if (!roles.includes(req.user.role)) return res.status(403).json({ message: 'Forbidden: insufficient role' });
+  next();
+};

package/templates/VehicleRentalReservationSystem/backend-project/middleware/errorHandler.js

@@ -0,0 +1,10 @@
+module.exports = (err, req, res, next) => {
+  console.error(err);
+  if (err.code === 11000) {
+    return res.status(409).json({ message: 'Duplicate value', field: Object.keys(err.keyValue)[0] });
+  }
+  if (err.name === 'ValidationError') {
+    return res.status(400).json({ message: err.message });
+  }
+  res.status(err.status || 500).json({ message: err.message || 'Server error' });
+};

package/templates/VehicleRentalReservationSystem/backend-project/middleware/validate.js

@@ -0,0 +1,6 @@
+const { validationResult } = require('express-validator');
+module.exports = (req, res, next) => {
+  const errors = validationResult(req);
+  if (!errors.isEmpty()) return res.status(400).json({ message: 'Validation failed', errors: errors.array() });
+  next();
+};

package/templates/VehicleRentalReservationSystem/backend-project/models/Customer.js

@@ -0,0 +1,11 @@
+const mongoose = require('mongoose');
+const customerSchema = new mongoose.Schema({
+  fullName: { type: String, required: true, trim: true },
+  nationalId: { type: String, required: true, unique: true, trim: true },
+  phone: { type: String, required: true, trim: true },
+  email: { type: String, required: true, lowercase: true, trim: true },
+  address: { type: String, required: true, trim: true }
+}, { timestamps: true });
+customerSchema.virtual('customerId').get(function() { return this._id.toHexString(); });
+customerSchema.set('toJSON', { virtuals: true });
+module.exports = mongoose.model('Customer', customerSchema);

package/templates/VehicleRentalReservationSystem/backend-project/models/ReservationRental.js

@@ -0,0 +1,17 @@
+const mongoose = require('mongoose');
+const schema = new mongoose.Schema({
+  customerId: { type: mongoose.Schema.Types.ObjectId, ref: 'Customer', required: true },
+  vehicleId: { type: mongoose.Schema.Types.ObjectId, ref: 'Vehicle', required: true },
+  userId: { type: mongoose.Schema.Types.ObjectId, ref: 'User', required: true },
+  reservationDate: { type: Date, default: Date.now },
+  startDate: { type: Date, required: true },
+  endDate: { type: Date, required: true },
+  reservationStatus: { type: String, enum: ['PENDING','APPROVED','REJECTED','CANCELLED','COMPLETED'], default: 'PENDING' },
+  rentalDate: { type: Date, default: null },
+  returnDate: { type: Date, default: null },
+  rentalFee: { type: Number, default: 0 },
+  rentalStatus: { type: String, enum: ['NOT_STARTED','ONGOING','RETURNED','LATE'], default: 'NOT_STARTED' }
+}, { timestamps: true });
+schema.virtual('reservationRentalId').get(function() { return this._id.toHexString(); });
+schema.set('toJSON', { virtuals: true });
+module.exports = mongoose.model('ReservationRental', schema);

package/templates/VehicleRentalReservationSystem/backend-project/models/User.js

@@ -0,0 +1,20 @@
+const mongoose = require('mongoose');
+const bcrypt = require('bcryptjs');
+const userSchema = new mongoose.Schema({
+  username: { type: String, required: true, unique: true, trim: true },
+  password: { type: String, required: true, minlength: 6 },
+  fullName: { type: String, default: '' },
+  email: { type: String, default: '' },
+  role: { type: String, enum: ['ADMIN', 'STAFF', 'MANAGER'], required: true },
+  active: { type: Boolean, default: true }
+}, { timestamps: true });
+
+userSchema.pre('save', async function(next) {
+  if (!this.isModified('password')) return next();
+  this.password = await bcrypt.hash(this.password, 10);
+  next();
+});
+userSchema.methods.compare = function(p) { return bcrypt.compare(p, this.password); };
+userSchema.virtual('userId').get(function() { return this._id.toHexString(); });
+userSchema.set('toJSON', { virtuals: true, transform: (_, ret) => { delete ret.password; return ret; } });
+module.exports = mongoose.model('User', userSchema);

package/templates/VehicleRentalReservationSystem/backend-project/models/Vehicle.js

@@ -0,0 +1,14 @@
+const mongoose = require('mongoose');
+const vehicleSchema = new mongoose.Schema({
+  plateNumber: { type: String, required: true, unique: true, uppercase: true, trim: true },
+  brand: { type: String, required: true, trim: true },
+  model: { type: String, required: true, trim: true },
+  year: { type: Number, required: true, min: 1980, max: new Date().getFullYear() + 1 },
+  vehicleType: { type: String, required: true, enum: ['Sedan','SUV','Hatchback','Pickup','Van','Bus','Truck','Coupe'] },
+  purchasePrice: { type: Number, required: true, min: 0 },
+  dailyRate: { type: Number, required: true, min: 0, default: 50 },
+  status: { type: String, enum: ['AVAILABLE','RESERVED','RENTED','MAINTENANCE'], default: 'AVAILABLE' }
+}, { timestamps: true });
+vehicleSchema.virtual('vehicleId').get(function() { return this._id.toHexString(); });
+vehicleSchema.set('toJSON', { virtuals: true });
+module.exports = mongoose.model('Vehicle', vehicleSchema);