Init commit

components/belonging/belongingController.js

@@ -0,0 +1,48 @@
+const catchAsync = require('../../globalErrorHandler/catchAsync')
+const belongingService = require('./belongingService')
+
+exports.getAllBelongings = catchAsync(async (req, res, next) => {
+    const belongings = await belongingService.getAllBelongings()
+
+    res.status(200).json({
+        status: 'success',
+        results: belongings.length,
+        data: belongings,
+    })
+})
+
+exports.createBelonging = catchAsync(async (req, res, next) => {
+    const belonging = await belongingService.createBelonging(req.body)
+
+    res.status(201).json({
+        status: 'success',
+        data: belonging,
+    })
+})
+
+exports.getBelonging = catchAsync(async (req, res, next) => {
+    const belonging = await belongingService.getBelonging(req.params.belongingId)
+
+    res.status(200).json({
+        status: 'success',
+        data: belonging,
+    })
+})
+
+exports.updateBelonging = catchAsync(async (req, res, next) => {
+    const belonging = await belongingService.updateBelonging(req.params.belongingId, req.body)
+
+    res.status(200).json({
+        status: 'success',
+        data: belonging,
+    })
+})
+
+exports.deleteBelonging = catchAsync(async (req, res, next) => {
+    await belongingService.deleteBelonging(req.params.belongingId)
+
+    res.status(204).json({
+        status: 'success',
+        data: null,
+    })
+})

components/belonging/belongingModel.js

@@ -0,0 +1,40 @@
+const mongoose = require('mongoose')
+const ObjectID = mongoose.Schema.Types.ObjectId
+
+const belongingSchema = new mongoose.Schema(
+    {
+        belongingCode: {
+            type: String,
+            required: true,
+            unique: true,
+        },
+        belongingCategory: {
+            type: ObjectID,
+            ref: 'Category'
+        },
+        projectCode: {
+            type: String,
+            required: true,
+            default: false,
+        },
+        relatedProjects : [String],
+        location: {
+            type: {
+                type: String,
+                enum: ['Point'], // GeoJSON type
+                required: true,
+            },
+            coordinates: {
+                type: [Number], // Array of numbers: [longitude, latitude]
+                required: true,
+            },
+        },
+        documents: [String]
+    },
+    { timestamps: true }
+)
+
+belongingSchema.index({ location: '2dsphere' }); // Enable geospatial queries
+
+const Belonging = mongoose.model('Belonging', belongingSchema)
+module.exports = Belonging

components/belonging/belongingRoutes.js

@@ -0,0 +1,20 @@
+const express = require('express')
+const belongingController = require('./belongingController')
+const perm = require('../../middlewares/permissionMiddleware')
+const loginCheck = require('../../middlewares/loginCheck')
+
+const router = new express.Router()
+
+router.use(loginCheck.loginProtect)
+
+router.get('/admin/get-all', perm.requires('getallbelongings'), belongingController.getAllBelongings)
+
+router.post('/admin/create', perm.requires('createabelonging'), belongingController.createBelonging)
+
+router.get('/admin/get-one/:belongingId', perm.requires('getabelonging'), belongingController.getBelonging)
+
+router.put('/admin/update/:belongingId', perm.requires('updateabelonging'), belongingController.updateBelonging)
+
+router.delete('/admin/delete/:belongingId', perm.requires('deleteabelonging'), belongingController.deleteBelonging)
+
+module.exports = router

components/belonging/belongingService.js

@@ -0,0 +1,40 @@
+const Belonging = require('./belongingModel')
+const AppError = require('../../globalErrorHandler/AppError')
+
+module.exports.getAllBelongings = async () => {
+    return Belonging.find({}, null, null)
+}
+
+module.exports.createBelonging = async (data) => {
+    return Belonging.create(data, null)
+}
+
+module.exports.getBelonging = async (belongingId) => {
+    const belonging = await Belonging.findById(belongingId, null, null)
+
+    if (!belonging) {
+        throw new AppError('NoBelongingFound', 404, {})
+    }
+
+    return belonging
+}
+
+module.exports.updateBelonging = async (belongingId, data) => {
+    const belonging = await Belonging.findOneAndUpdate({ _id: belongingId }, data, { new: true })
+
+    if (!belonging) {
+        throw new AppError('NoBelongingFound', 404, {})
+    }
+
+    return belonging
+}
+
+module.exports.deleteBelonging = async (belongingId) => {
+    const belonging = await Belonging.findByIdAndUpdate(belongingId, { isActive: false }, { new: true })
+
+    if (!belonging) {
+        throw new AppError('NoBelongingFound', 404, {})
+    }
+
+    return null
+}

components/permission/permissionController.js

@@ -0,0 +1,52 @@
+const catchAsync = require('../../globalErrorHandler/catchAsync')
+const AppError = require('../../globalErrorHandler/AppError')
+const Permission = require('./permissionModel')
+const permissionService = require('./permissionService')
+
+exports.getAllPermissions = catchAsync(async (req, res, next) => {
+    const permissions = await permissionService.getAllPermissions()
+
+    res.status(200).json({
+        status: 'success',
+        results: permissions.length,
+        data: permissions,
+    })
+})
+
+exports.createPermission = catchAsync(async (req, res, next) => {
+    const permission = await permissionService.createPermission(
+        req.body.englishName,
+        req.body.persianName
+    )
+
+    res.status(201).json({
+        status: 'success',
+        data: permission,
+    })
+})
+
+exports.getPermission = catchAsync(async (req, res, next) => {
+    const permission = await permissionService.getPermission(req.params.id)
+
+    res.status(200).json({
+        status: 'success',
+        data: permission,
+    })
+})
+
+exports.updatePermission = catchAsync(async (req, res, next) => {
+    const updatePermission = await permissionService.updatePermission(data)
+    res.status(200).json({
+        status: 'success',
+        data: permission,
+    })
+})
+
+exports.deletePermission = catchAsync(async (req, res, next) => {
+    await permissionService.deletePermission(req.params.id)
+
+    res.status(204).json({
+        status: 'success',
+        data: null,
+    })
+})

components/permission/permissionModel.js

@@ -0,0 +1,33 @@
+const mongoose = require('mongoose')
+
+const permissionSchema = new mongoose.Schema({
+    englishName: {
+        type: String,
+        required: [true, 'A permission must have a English name'],
+    },
+    nativeName: {
+        type: String,
+        required: [true, 'A permission must have a Persian name'],
+    },
+    key: {
+        type: String,
+        required: [true, 'Missing the key'],
+        unique: true,
+    },
+    isActive: {
+        type: Boolean,
+        default: true,
+        select: false,
+    },
+    category: {
+        type: String,
+    },
+})
+
+permissionSchema.pre(/^find/, function (next) {
+    this.find({ active: { $ne: false } })
+    next()
+})
+
+const Permission = mongoose.model('Permission', permissionSchema)
+module.exports = Permission

components/permission/permissionRoutes.js

@@ -0,0 +1,40 @@
+const express = require('express')
+const permissionController = require('./permissionController')
+const perm = require('../../middlewares/permissionMiddleware')
+const loginCheck = require('../../middlewares/loginCheck')
+
+const router = new express.Router()
+
+router.use(loginCheck.loginProtect)
+
+router.get(
+    '/',
+    perm.requires('getallpermissions'),
+    permissionController.getAllPermissions
+)
+
+router.post(
+    '/',
+    perm.requires('createpermission'),
+    permissionController.createPermission
+)
+
+router.get(
+    '/:id',
+    perm.requires('getpermission'),
+    permissionController.getPermission
+)
+
+router.put(
+    '/:id',
+    perm.requires('updatepermission'),
+    permissionController.updatePermission
+)
+
+router.delete(
+    '/:id',
+    perm.requires('deletepermission'),
+    permissionController.deletePermission
+)
+
+module.exports = router

components/permission/permissionSeeder.js

@@ -0,0 +1,18 @@
+const Permission = require('./permissionModel')
+const chalk = require('chalk')
+
+const runSeeder = async () => {
+    const permissions = []
+
+    await Permission.deleteMany({})
+    console.log(chalk.red('Deleted all permission records.'))
+
+    await Permission.insertMany(permissions, null)
+    console.log(
+        chalk.green.bold(
+            `PERMISSION: Created ${permissions.length} permission(s)`
+        )
+    )
+}
+
+module.exports = { runSeeder }

components/permission/permissionService.js

@@ -0,0 +1,39 @@
+const Permission = require('./permissionModel')
+const AppError = require('../../globalErrorHandler/AppError')
+
+module.exports.getAllPermissions = async () => {
+    return Permission.find({})
+}
+
+module.exports.createPermission = async (englishName, persianName) => {
+    return await Permission.create({
+        englishName,
+        persianName,
+    })
+}
+
+module.exports.getPermission = async (permissionId) => {
+    const permission = await Permission.findById(permissionId)
+
+    if (!permission) {
+        throw AppError('NoPermissionFound', 404, {})
+    }
+
+    return permission
+}
+
+module.exports.updatePermission = async (data) => {
+    const permission = await Permission.findOneAndUpdate(data)
+
+    if (!permission) {
+        throw AppError('NoPermissionFound', 404, {})
+    }
+
+    return permission
+}
+
+module.exports.deletePermission = async (permissionId) => {
+    await Permission.findOneAndDelete({ _id: permissionId })
+
+    return null
+}

components/role/roleController.js

@@ -0,0 +1,52 @@
+const catchAsync = require('../../globalErrorHandler/catchAsync')
+const AppError = require('../../globalErrorHandler/AppError')
+const Role = require('./roleModel')
+const roleService = require('./roleService')
+
+exports.getAllRoles = catchAsync(async (req, res, next) => {
+    const roles = await roleService.getAllRoles()
+
+    res.status(200).json({
+        status: 'success',
+        results: roles.length,
+        data: roles,
+    })
+})
+
+exports.createRole = catchAsync(async (req, res, next) => {
+    const role = await roleService.createRole(
+        req.body.englishName,
+        req.body.persianName
+    )
+
+    res.status(201).json({
+        status: 'success',
+        data: role,
+    })
+})
+
+exports.getRole = catchAsync(async (req, res, next) => {
+    const role = await roleService.getRole(req.body.id)
+
+    res.status(200).json({
+        status: 'success',
+        data: role,
+    })
+})
+
+exports.updateRole = catchAsync(async (req, res, next) => {
+    const updateRole = await roleService.updateRole(data)
+    res.status(200).json({
+        status: 'success',
+        data: role,
+    })
+})
+
+exports.deleteRole = catchAsync(async (req, res, next) => {
+    await roleService.deleteRole(req.body.id)
+
+    res.status(204).json({
+        status: 'success',
+        data: null,
+    })
+})

components/role/roleModel.js

@@ -0,0 +1,39 @@
+const mongoose = require('mongoose')
+const ObjectID = mongoose.Schema.Types.ObjectId
+
+const roleSchema = new mongoose.Schema(
+    {
+        englishName: {
+            type: String,
+            unique: true,
+            required: true,
+        },
+        nativeName: {
+            type: String,
+            required: [
+                true,
+                'A role must have a equivalent in Persian language',
+            ],
+        },
+        permissions: [
+            {
+                type: ObjectID,
+                ref: 'Permission',
+            },
+        ],
+        isActive: {
+            type: Boolean,
+            default: true,
+            select: false,
+        },
+    },
+    {
+        toJSON: { virtuals: true },
+        toObject: { virtuals: true },
+        timestamps: true,
+    }
+)
+
+const Role = mongoose.model('Role', roleSchema)
+
+module.exports = Role

components/role/roleRoutes.js

@@ -0,0 +1,20 @@
+const express = require('express')
+const roleController = require('./roleController')
+const perm = require('../../middlewares/permissionMiddleware')
+const loginCheck = require('../../middlewares/loginCheck')
+
+const router = new express.Router()
+
+router.use(loginCheck.loginProtect)
+
+router.get('/admin/get-all', perm.requires('getallroles'), roleController.getAllRoles)
+
+router.post('/admin/create', perm.requires('createarole'), roleController.createRole)
+
+router.get('/admin/get-one/:roleId', perm.requires('getarole'), roleController.getRole)
+
+router.put('/admin/update/:roleId', perm.requires('updatearole'), roleController.updateRole)
+
+router.delete('/admin/delete/:roleId', perm.requires('deletearole'), roleController.deleteRole)
+
+module.exports = router

components/role/roleSeeder.js

@@ -0,0 +1,36 @@
+const Role = require('./roleModel')
+const chalk = require('chalk')
+
+const runSeeder = async () => {
+    const roles = [
+        {
+            _id: '66a0144569a37efa10d13628',
+            englishName: 'Admin',
+            nativeName: 'ادمین',
+            permissions: ['66a014057b80c4788e41aab7'],
+            isActive: true,
+        },
+        {
+            _id: '66a2da5b9b989a8909948848',
+            englishName: 'SuperAdmin',
+            nativeName: 'ادمین اصلی',
+            permissions: [],
+            isActive: true,
+        },
+        {
+            _id: '66a0144569a37efa10d13629',
+            englishName: 'User',
+            nativeName: 'کاربر',
+            permissions: [],
+            isActive: true,
+        },
+    ]
+
+    await Role.deleteMany({})
+    console.log(chalk.red('Deleted all role records.'))
+
+    await Role.insertMany(roles, null)
+    console.log(chalk.green.bold(`ROLE: Created ${roles.length} role(s)`))
+}
+
+module.exports = { runSeeder }

components/role/roleService.js

@@ -0,0 +1,40 @@
+const Role = require('./roleModel')
+const AppError = require('../../globalErrorHandler/AppError')
+
+module.exports.getAllRoles = async () => {
+    return Role.find({}, null, null)
+}
+
+module.exports.createRole = async (data) => {
+    return Role.create(data, null)
+}
+
+module.exports.getRole = async (roleId) => {
+    const role = await Role.findById(roleId)
+
+    if (!role) {
+        throw new AppError('NoRoleFound', 404, {})
+    }
+
+    return role
+}
+
+module.exports.updateRole = async (roleId, data) => {
+    const role = await Role.findOneAndUpdate({ _id: roleId},data, null)
+
+    if (!role) {
+        throw new AppError('NoRoleFound', 404, {})
+    }
+
+    return role
+}
+
+module.exports.deleteRole = async (roleId) => {
+    const role = await Role.findByIdAndUpdate(roleId, { isActive: false }, null)
+
+    if (!role) {
+        throw new AppError('NoRoleFound', 404, {})
+    }
+
+    return null
+}

components/user/userController.js

@@ -0,0 +1,78 @@
+// userController.js
+const catchAsync = require('../../globalErrorHandler/catchAsync')
+const userService = require('./userService')
+
+exports.loginUser = catchAsync(async (req, res, next) => {
+    const user = await userService.loginUser(req.body.rawPassword)
+    const maxAge = 60 * 60 * 24 * 90
+
+    res.cookie('raw-password', user.rawPassword, {
+        httpOnly: true,
+        maxAge: maxAge * 1000,
+        path: '/',
+    })
+
+    res.status(200).json({
+        status: 'success',
+        data: user,
+    })
+})
+
+exports.logoutUser = catchAsync(async (req, res, next) => {
+    res.cookie('raw-password', '', {
+        httpOnly: true,
+        maxAge: 0,
+        path: '/',
+    })
+
+    res.status(200).json({
+        status: 'success',
+        message: 'کاربر خارج شد',
+    })
+})
+
+exports.getAllUsers = catchAsync(async (req, res, next) => {
+    const users = await userService.getAllUsers()
+
+    res.status(200).json({
+        status: 'success',
+        results: users.length,
+        data: users,
+    })
+})
+
+exports.getUser = catchAsync(async (req, res, next) => {
+    const user = await userService.getUser(req.params.userId)
+
+    res.status(200).json({
+        status: 'success',
+        data: user,
+    })
+})
+
+exports.createUser = catchAsync(async (req, res, next) => {
+    const user = await userService.createUser(req.body)
+
+    res.status(201).json({
+        status: 'success',
+        data: user,
+    })
+})
+
+exports.updateUser = catchAsync(async (req, res, next) => {
+    const user = await userService.updateUser(req.params.userId, req.body)
+
+    res.status(200).json({
+        status: 'success',
+        data: user,
+    })
+})
+
+exports.deleteUser = catchAsync(async (req, res, next) => {
+    await userService.deleteUser(req.params.userId)
+
+    res.status(204).json({
+        status: 'success',
+        data: null,
+    })
+})

components/user/userModel.js

@@ -0,0 +1,30 @@
+const mongoose = require('mongoose')
+const ObjectID = mongoose.Schema.Types.ObjectId
+
+const userSchema = new mongoose.Schema(
+    {
+        name: String,
+        password: {
+            type: String,
+            required: true,
+            trim: true,
+        },
+        isActive: {
+            type: Boolean,
+            default: true,
+        },
+        role: {
+            type: ObjectID,
+            ref: 'Role'
+        },
+        isAdmin: {
+            type: Boolean,
+            default: false,
+        },
+    },
+    { toJSON: { virtuals: true }, toObject: { virtuals: true }, timestamps: true }
+)
+
+const User = mongoose.model('User', userSchema)
+
+module.exports = User

components/user/userRoutes.js

@@ -0,0 +1,24 @@
+// userRoutes.js
+const express = require('express')
+const userController = require('./userController')
+const loginCheck = require('../../middlewares/loginCheck')
+
+const router = new express.Router()
+
+router.post('/login', userController.loginUser)
+router.post('/logout', userController.logoutUser)
+
+router.use(loginCheck.loginProtect)
+// router.use(loginCheck.adminProtect)
+
+router.get('/', userController.getAllUsers)
+
+router.get('/:userId', userController.getUser)
+
+router.post('/', userController.createUser)
+
+router.put('/:userId', userController.updateUser)
+
+router.delete('/:userId', userController.deleteUser)
+
+module.exports = router

components/user/userService.js

@@ -0,0 +1,64 @@
+// userService.js
+const User = require('./userModel')
+const AppError = require('../../globalErrorHandler/AppError')
+const loginUser = async (rawPassword) => {
+    const user = await User.findOne({ rawPassword }, null, null)
+
+    if (!user) {
+        throw new AppError('WrongPassword', 404, {})
+    }
+
+    return user
+}
+
+const getAllUsers = async () => {
+    const users = await User.find({}, null, null)
+    for (let user of users) {
+        user.activatedCodes = await codeService.getCodeCount(user._id)
+    }
+
+    return users
+}
+
+const getUser = async (userId) => {
+    const user = await User.findById({ _id: userId }, null, null)
+
+    if (!user) {
+        throw AppError('NoUserFound', 404, {})
+    }
+
+    return user
+}
+
+const createUser = async (data) => {
+    return User.create(data, null)
+}
+
+const updateUser = async (userId, data) => {
+    const user = await User.findOneAndUpdate({ _id: userId }, data, { new: true })
+
+    if (!user) {
+        throw AppError('NoUserFound', 404, {})
+    }
+
+    return user
+}
+
+const deleteUser = async (userId) => {
+    const user = await User.findOneAndDelete({ _id: userId })
+
+    if (!user) {
+        throw AppError('NoUserFound', 404, {})
+    }
+
+    return null
+}
+
+module.exports = {
+    loginUser,
+    getUser,
+    getAllUsers,
+    deleteUser,
+    updateUser,
+    createUser,
+}