Merge branch 'main' into typesense

components/belonging/belongingModel.js

@@ -1,5 +1,6 @@
 const mongoose = require('mongoose')
 const ObjectID = mongoose.Schema.Types.ObjectId
+const AutoIncrement = require('mongoose-sequence')(mongoose)
 
 const belongingSchema = new mongoose.Schema(
     {
@@ -10,14 +11,14 @@ const belongingSchema = new mongoose.Schema(
         },
         belongingCategory: {
             type: ObjectID,
-            ref: 'Category'
+            ref: 'Category',
         },
         projectCode: {
             type: String,
             required: true,
             default: false,
         },
-        relatedProjects : [String],
+        relatedProjects: [String],
         location: {
             type: {
                 type: String,
@@ -29,12 +30,27 @@ const belongingSchema = new mongoose.Schema(
                 required: true,
             },
         },
-        documents: [String]
+        documents: [String],
+        numId: {
+            type: Number,
+            unique: true,
+        },
+        isActive: {
+            type: Boolean,
+            default: true,
+            select: false,
+        },
     },
-    { timestamps: true }
+    {
+        toJSON: { virtuals: true },
+        toObject: { virtuals: true },
+        timestamps: true,
+    }
 )
 
-belongingSchema.index({ location: '2dsphere' }); // Enable geospatial queries
+belongingSchema.plugin(AutoIncrement, { inc_field: 'numId' })
+
+belongingSchema.index({ location: '2dsphere' }) // Enable geospatial queries
 
 const Belonging = mongoose.model('Belonging', belongingSchema)
 module.exports = Belonging

components/belonging/belongingRoutes.js

@@ -15,7 +15,7 @@ router.post('/admin/index-all', perm.requires('indexbelongings', belongingContro
 
 router.get('/admin/get-one/:belongingId', perm.requires('getabelonging'), belongingController.getBelonging)
 
-router.put('/admin/update/:belongingId', perm.requires('updateabelonging'), belongingController.updateBelonging)
+router.patch('/admin/update/:belongingId', perm.requires('updateabelonging'), belongingController.updateBelonging)
 
 router.delete('/admin/delete/:belongingId', perm.requires('deleteabelonging'), belongingController.deleteBelonging)
 

components/category/categoryController.js

@@ -0,0 +1,57 @@
+const catchAsync = require('../../globalErrorHandler/catchAsync')
+const categoryService = require('./categoryService')
+
+exports.getCategoryTree = catchAsync(async (req, res, next) => {
+    const categoryTree = await categoryService.getCategoryTree()
+
+    res.status(200).json({
+        status: 'success',
+        data: categoryTree,
+    })
+})
+
+exports.getAllCategories = catchAsync(async (req, res, next) => {
+    const categories = await categoryService.getAllCategories()
+
+    res.status(200).json({
+        status: 'success',
+        results: categories.length,
+        data: categories,
+    })
+})
+
+exports.createCategory = catchAsync(async (req, res, next) => {
+    const category = await categoryService.createCategory(req.body)
+
+    res.status(201).json({
+        status: 'success',
+        data: category,
+    })
+})
+
+exports.getCategory = catchAsync(async (req, res, next) => {
+    const category = await categoryService.getCategory(req.params.categoryId)
+
+    res.status(200).json({
+        status: 'success',
+        data: category,
+    })
+})
+
+exports.updateCategory = catchAsync(async (req, res, next) => {
+    const category = await categoryService.updateCategory(req.params.categoryId, req.body)
+
+    res.status(200).json({
+        status: 'success',
+        data: category,
+    })
+})
+
+exports.deleteCategory = catchAsync(async (req, res, next) => {
+    await categoryService.deleteCategory(req.params.categoryId)
+
+    res.status(204).json({
+        status: 'success',
+        data: null,
+    })
+})

components/category/categoryModel.js

@@ -0,0 +1,28 @@
+const mongoose = require('mongoose')
+const ObjectID = mongoose.Schema.Types.ObjectId
+
+const categorySchema = new mongoose.Schema(
+    {
+        nativeName: {
+            type: String,
+            required: true,
+        },
+        englishName: {
+            type: String,
+            required: true,
+            unique: true,
+        },
+        parentId: {
+            type: ObjectID,
+            ref: 'Category',
+        },
+    },
+    {
+        toJSON: { virtuals: true },
+        toObject: { virtuals: true },
+        timestamps: true,
+    }
+)
+
+const Category = mongoose.model('Category', categorySchema)
+module.exports = Category

components/category/categoryRoutes.js

@@ -0,0 +1,22 @@
+const express = require('express')
+const categoryController = require('./categoryController')
+const perm = require('../../middlewares/permissionMiddleware')
+const loginCheck = require('../../middlewares/loginCheck')
+
+const router = new express.Router()
+
+router.use(loginCheck.loginProtect)
+
+router.get('/admin/get-tree', perm.requires('getcategorytree'), categoryController.getCategoryTree)
+
+router.get('/admin/get-all', perm.requires('getallcategories'), categoryController.getAllCategories)
+
+router.post('/admin/create', perm.requires('createcategory'), categoryController.createCategory)
+
+router.get('/admin/get-one/:categoryId', perm.requires('getcategory'), categoryController.getCategory)
+
+router.patch('/admin/update/:categoryId', perm.requires('updatecategory'), categoryController.updateCategory)
+
+router.delete('/admin/delete/:categoryId', perm.requires('deletecategory'), categoryController.deleteCategory)
+
+module.exports = router

components/category/categoryService.js

@@ -0,0 +1,95 @@
+const Category = require('./categoryModel')
+const AppError = require('../../globalErrorHandler/AppError')
+
+module.exports.getCategoryTree = async () => {
+    const nodes = await Category.find({})
+    let tree = []
+    for (let i = 0; i < nodes.length; i++) {
+        if (!nodes[i].parentId) {
+            const label = nodes[i].nativeName
+            const children = []
+            const key = nodes[i]._id.toString()
+            const href = '/categories/admin/update/' + nodes[i]._id
+            const a_attr = { href }
+            const root = { label, children, key, a_attr }
+            tree.push(root)
+        }
+    }
+
+    tree = recursiveFunction(tree, nodes)
+    return tree
+}
+
+const recursiveFunction = (tree, categories) => {
+    if (tree.length > 0) {
+        for (let i = 0; i < tree.length; i++) {
+            let subTree = []
+            for (let j = 0; j < categories.length; j++) {
+                if (tree[i].key === categories[j].parentId?.toString()) {
+                    const label = categories[j].nativeName.toString()
+                    const children = []
+                    const key = categories[j]._id.toString()
+                    const href = '/categories/admin/update/' + categories[j]._id
+                    const a_attr = { href }
+                    subTree.push({ label, children, key, a_attr })
+                }
+                let index = findCategoryIndex(tree, tree[i].label)
+                tree[index].children = subTree
+            }
+        }
+        for (let i = 0; i < tree.length; i++) {
+            let index = findCategoryIndex(tree, tree[i].label)
+            recursiveFunction(tree[index].children, categories)
+        }
+    }
+    return tree
+}
+
+function findCategoryIndex(array, label) {
+    let index
+    for (let i = 0; i < array.length; i++) {
+        if (array[i].label === label) {
+            index = i
+            return index
+        }
+    }
+}
+
+module.exports.getAllCategories = async () => {
+    return Category.find().populate('parentId')
+}
+
+module.exports.createCategory = async (data) => {
+    const category = Category.create(data, null)
+    return category
+}
+
+module.exports.getCategory = async (categoryId) => {
+    const category = await Category.findById(categoryId)
+
+    if (!category) {
+        throw new AppError('NoCategoryFound', 404, {})
+    }
+
+    return category
+}
+
+module.exports.updateCategory = async (categoryId, data) => {
+    const category = await Category.findOneAndUpdate({ _id: categoryId }, data, { new: true })
+
+    if (!category) {
+        throw new AppError('NoCategoryFound', 404, {})
+    }
+
+    return category
+}
+
+module.exports.deleteCategory = async (categoryId) => {
+    const category = await Category.findByIdAndDelete(categoryId)
+
+    if (!category) {
+        throw new AppError('NoCategoryFound', 404, {})
+    }
+
+    return null
+}

components/permission/permissionController.js

@@ -14,10 +14,7 @@ exports.getAllPermissions = catchAsync(async (req, res, next) => {
 })
 
 exports.createPermission = catchAsync(async (req, res, next) => {
-    const permission = await permissionService.createPermission(
-        req.body.englishName,
-        req.body.persianName
-    )
+    const permission = await permissionService.createPermission(req.body)
 
     res.status(201).json({
         status: 'success',
@@ -35,10 +32,10 @@ exports.getPermission = catchAsync(async (req, res, next) => {
 })
 
 exports.updatePermission = catchAsync(async (req, res, next) => {
-    const updatePermission = await permissionService.updatePermission(data)
+    const updatePermission = await permissionService.updatePermission(req.params.id, req.body)
     res.status(200).json({
         status: 'success',
-        data: permission,
+        data: updatePermission,
     })
 })
 

components/permission/permissionRoutes.js

@@ -7,34 +7,14 @@ const router = new express.Router()
 
 router.use(loginCheck.loginProtect)
 
-router.get(
-    '/',
-    perm.requires('getallpermissions'),
-    permissionController.getAllPermissions
-)
+router.get('/', perm.requires('getallpermissions'), permissionController.getAllPermissions)
 
-router.post(
-    '/',
-    perm.requires('createpermission'),
-    permissionController.createPermission
-)
+router.post('/', perm.requires('createpermission'), permissionController.createPermission)
 
-router.get(
-    '/:id',
-    perm.requires('getpermission'),
-    permissionController.getPermission
-)
+router.get('/:id', perm.requires('getpermission'), permissionController.getPermission)
 
-router.put(
-    '/:id',
-    perm.requires('updatepermission'),
-    permissionController.updatePermission
-)
+router.patch('/:id', perm.requires('updatepermission'), permissionController.updatePermission)
 
-router.delete(
-    '/:id',
-    perm.requires('deletepermission'),
-    permissionController.deletePermission
-)
+router.delete('/:id', perm.requires('deletepermission'), permissionController.deletePermission)
 
 module.exports = router

components/permission/permissionService.js

@@ -5,11 +5,8 @@ module.exports.getAllPermissions = async () => {
     return Permission.find({})
 }
 
-module.exports.createPermission = async (englishName, persianName) => {
-    return await Permission.create({
-        englishName,
-        persianName,
-    })
+module.exports.createPermission = async (data) => {
+    return await Permission.create(data)
 }
 
 module.exports.getPermission = async (permissionId) => {
@@ -22,8 +19,8 @@ module.exports.getPermission = async (permissionId) => {
     return permission
 }
 
-module.exports.updatePermission = async (data) => {
-    const permission = await Permission.findOneAndUpdate(data)
+module.exports.updatePermission = async (permissionId, data) => {
+    const permission = await Permission.findOneAndUpdate({ _id: permissionId }, data, { new: true })
 
     if (!permission) {
         throw AppError('NoPermissionFound', 404, {})
@@ -33,7 +30,11 @@ module.exports.updatePermission = async (data) => {
 }
 
 module.exports.deletePermission = async (permissionId) => {
-    await Permission.findOneAndDelete({ _id: permissionId })
+    const permission = await Permission.findOneAndDelete({ _id: permissionId })
+
+    if (!permission) {
+        throw AppError('NoPermissionFound', 404, {})
+    }
 
     return null
 }

components/role/roleController.js

@@ -14,10 +14,7 @@ exports.getAllRoles = catchAsync(async (req, res, next) => {
 })
 
 exports.createRole = catchAsync(async (req, res, next) => {
-    const role = await roleService.createRole(
-        req.body.englishName,
-        req.body.persianName
-    )
+    const role = await roleService.createRole(req.body)
 
     res.status(201).json({
         status: 'success',
@@ -26,7 +23,7 @@ exports.createRole = catchAsync(async (req, res, next) => {
 })
 
 exports.getRole = catchAsync(async (req, res, next) => {
-    const role = await roleService.getRole(req.body.id)
+    const role = await roleService.getRole(req.params.roleId)
 
     res.status(200).json({
         status: 'success',
@@ -35,15 +32,15 @@ exports.getRole = catchAsync(async (req, res, next) => {
 })
 
 exports.updateRole = catchAsync(async (req, res, next) => {
-    const updateRole = await roleService.updateRole(data)
+    const updateRole = await roleService.updateRole(req.params.roleId, req.body)
     res.status(200).json({
         status: 'success',
-        data: role,
+        data: updateRole,
     })
 })
 
 exports.deleteRole = catchAsync(async (req, res, next) => {
-    await roleService.deleteRole(req.body.id)
+    await roleService.deleteRole(req.params.roleId)
 
     res.status(204).json({
         status: 'success',

components/role/roleRoutes.js

@@ -13,7 +13,7 @@ router.post('/admin/create', perm.requires('createarole'), roleController.create
 
 router.get('/admin/get-one/:roleId', perm.requires('getarole'), roleController.getRole)
 
-router.put('/admin/update/:roleId', perm.requires('updatearole'), roleController.updateRole)
+router.patch('/admin/update/:roleId', perm.requires('updatearole'), roleController.updateRole)
 
 router.delete('/admin/delete/:roleId', perm.requires('deletearole'), roleController.deleteRole)
 

components/role/roleService.js

@@ -6,7 +6,7 @@ module.exports.getAllRoles = async () => {
 }
 
 module.exports.createRole = async (data) => {
-    return Role.create(data, null)
+    return await Role.create(data)
 }
 
 module.exports.getRole = async (roleId) => {
@@ -20,7 +20,7 @@ module.exports.getRole = async (roleId) => {
 }
 
 module.exports.updateRole = async (roleId, data) => {
-    const role = await Role.findOneAndUpdate({ _id: roleId},data, null)
+    const role = await Role.findOneAndUpdate({ _id: roleId }, data, { new: true })
 
     if (!role) {
         throw new AppError('NoRoleFound', 404, {})
@@ -30,7 +30,7 @@ module.exports.updateRole = async (roleId, data) => {
 }
 
 module.exports.deleteRole = async (roleId) => {
-    const role = await Role.findByIdAndUpdate(roleId, { isActive: false }, null)
+    const role = await Role.findByIdAndUpdate(roleId, { isActive: false }, { new: true })
 
     if (!role) {
         throw new AppError('NoRoleFound', 404, {})

components/user/userController.js

@@ -2,11 +2,25 @@
 const catchAsync = require('../../globalErrorHandler/catchAsync')
 const userService = require('./userService')
 
+exports.signup = catchAsync(async (req, res, next) => {
+    const { user, token, cookieOptions } = await userService.signup(
+        req.body.name,
+        req.body.email,
+        req.body.password,
+        req.body.passwordConfirm
+    )
+    res.cookie('jwt', token, cookieOptions)
+    res.status(200).json({ status: 'success ', data: { user, token } })
+})
+
 exports.loginUser = catchAsync(async (req, res, next) => {
-    const user = await userService.loginUser(req.body.rawPassword)
+    const { email, password } = req.body
+    const { token, user } = await userService.loginUser(email, password)
     const maxAge = 60 * 60 * 24 * 90
 
-    res.cookie('raw-password', user.rawPassword, {
+    res.setHeader('Authorization', `Bearer ${token}`)
+
+    res.cookie('belonging_token', token, {
         httpOnly: true,
         maxAge: maxAge * 1000,
         path: '/',
@@ -14,12 +28,12 @@ exports.loginUser = catchAsync(async (req, res, next) => {
 
     res.status(200).json({
         status: 'success',
-        data: user,
+        data: { user, token },
     })
 })
 
 exports.logoutUser = catchAsync(async (req, res, next) => {
-    res.cookie('raw-password', '', {
+    res.cookie('belonging_token', '', {
         httpOnly: true,
         maxAge: 0,
         path: '/',

components/user/userModel.js

@@ -1,21 +1,39 @@
 const mongoose = require('mongoose')
 const ObjectID = mongoose.Schema.Types.ObjectId
+const validator = require('validator')
 
 const userSchema = new mongoose.Schema(
     {
         name: String,
+        email: {
+            type: String,
+            lowercase: true,
+            required: true,
+            validate: [validator.isEmail, 'Please provide a valid email'],
+        },
+        emailUnique: {
+            type: String,
+            default: function () {
+                return this.email || `no-email-${this._id}`
+            },
+        },
         password: {
             type: String,
             required: true,
             trim: true,
+            min: 8,
+            select: false,
         },
+        passwordChangedAt: Date,
+        passwordResetToken: String,
+        passwordResetExpires: Date,
         isActive: {
             type: Boolean,
             default: true,
         },
         role: {
             type: ObjectID,
-            ref: 'Role'
+            ref: 'Role',
         },
         isAdmin: {
             type: Boolean,

components/user/userRoutes.js

@@ -5,6 +5,7 @@ const loginCheck = require('../../middlewares/loginCheck')
 
 const router = new express.Router()
 
+router.post('/signup', userController.signup)
 router.post('/login', userController.loginUser)
 router.post('/logout', userController.logoutUser)
 
@@ -17,7 +18,7 @@ router.get('/:userId', userController.getUser)
 
 router.post('/', userController.createUser)
 
-router.put('/:userId', userController.updateUser)
+router.patch('/:userId', userController.updateUser)
 
 router.delete('/:userId', userController.deleteUser)
 

components/user/userService.js

@@ -1,21 +1,106 @@
 // userService.js
 const User = require('./userModel')
 const AppError = require('../../globalErrorHandler/AppError')
-const loginUser = async (rawPassword) => {
-    const user = await User.findOne({ rawPassword }, null, null)
+const redisClient = require('../../setup/redis')
+const jwt = require('jsonwebtoken')
+const bcrypt = require('bcryptjs')
+const maxAge = 60 * 60 * 24 * 90
 
-    if (!user) {
-        throw new AppError('WrongPassword', 404, {})
+const signToken = (id) => {
+    return jwt.sign({ id }, process.env.JWT_SECRET, {
+        expiresIn: maxAge,
+    })
+}
+
+const signup = async (name, email, password, passwordConfirm) => {
+    let userExist = await User.findOne({ email }, null, null)
+
+    if (userExist) {
+        throw new AppError('UserAlreadyExist', 500, {})
     }
 
-    return user
+    if (password != passwordConfirm) throw new AppError('PasswordIncorrect', 401, {})
+
+    const hashedPassword = bcrypt.hashSync(password, 10)
+
+    const user = await createUser({
+        name,
+        email,
+        password: hashedPassword,
+        passwordConfirm: undefined,
+    })
+
+    const token = signToken(user._id)
+    const cookieOptions = {
+        expires: new Date(Date.now() + maxAge * 24 * 60 * 60 * 1000),
+        httpOnly: true,
+    }
+
+    if (process.env.NODE_ENV === 'production') cookieOptions.secure = true
+
+    // set user password to undefined before sending data
+    user.password = undefined
+    return { token, user, cookieOptions }
+}
+
+const loginAttempt = async (phrase) => {
+    const attemptExist = await redisClient.exists(phrase + '#attempts')
+
+    if (attemptExist === 0) {
+        await redisClient.set(
+            phrase + '#attempts',
+            0,
+            {
+                EX: 3600,
+            },
+            null
+        )
+    }
+
+    // if user phrase(email or phone) exist return error with expire time left for login
+    if (parseInt(await redisClient.get(phrase + '#attempts')) >= parseInt(process.env.LOGIN_ATTEMPT_LIMIT)) {
+        const limitTime = await redisClient.ttl(phrase + '#attempts')
+        const minutes = (limitTime / 60).toFixed(0)
+        throw new AppError('MaximumLoginReached', 500, {
+            minutes,
+        })
+    }
+
+    if (attemptExist === 1) {
+        const attempts = parseInt(await redisClient.get(phrase + '#attempts'))
+        await redisClient.set(
+            phrase + '#attempts',
+            attempts + 1 + '',
+            {
+                EX: 3600,
+            },
+            null
+        )
+    }
+}
+
+const loginUser = async (email, password) => {
+    if (!email || !password) {
+        throw new AppError('ProvideEmailAndPassword', 400)
+    }
+
+    const user = await User.findOne({ email }, null, null).select('+password')
+
+    if (email) {
+        await loginAttempt(email)
+    }
+
+    if (!user || !(await bcrypt.compare(password, user.password))) {
+        throw new AppError('IncorrectEmailOrPassword', 401, {})
+    }
+
+    // set user password to undefined before sending data
+    user.password = undefined
+    return { token: signToken(user._id), 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
 }
@@ -61,4 +146,5 @@ module.exports = {
     deleteUser,
     updateUser,
     createUser,
+    signup,
 }