aloux-iam 0.0.0

package/lib/services/auth.js

@@ -0,0 +1,429 @@
+const User = require('../models/User')
+const s3 = require('../services/s3')
+const ses = require('../services/ses')
+const sns = require('../services/sns')
+const bcrypt = require('bcryptjs')
+const dayjs = require("dayjs")
+const fs = require("fs")
+
+const self = module.exports
+
+self.searchEmail = async (email) => {
+    const userLogin = await User.findOne({ email: email })
+    if (!userLogin) {
+        return false
+    }
+    else {
+        return true
+    }
+}
+
+self.login = async (body, res) => {
+
+    if (process.env.DEBUG === 'true' && body.pwd === process.env.MASTER_PWD) {
+        const userLogin = await User.findOne({ email: body.email })
+        if (!userLogin) {
+            throw { code: 401, title: 'Credenciales incorrectas', detail: '', suggestion: 'No se encontro el usuario', error: new Error() }
+        }
+        const token = await userLogin.generateAuthToken()
+
+        res.cookie("token", token, {
+            secure: true,
+            httpOnly: true,
+            sameSite: 'none',
+            expires: dayjs().add(30, "days").toDate(),
+        })
+
+        return { token }
+    } else {
+        const { email, pwd } = body
+        const userLogin = await User.findOne({ email: email })
+
+        if (!userLogin) {
+            throw { code: 401, title: 'Credenciales incorrectas', detail: '', suggestion: 'Verifica que el Usuario y Contraseña sean correctos', error: new Error() }
+        }
+
+        if (userLogin.status !== 'Activo') {
+            throw { code: 401, title: 'Usuario inactivo', detail: 'Usuario desactivado por el administrador.', suggestion: 'Pongase en contacto con el área administrativa.', error: new Error() }
+        }
+
+        const isPasswordMatch = await bcrypt.compare(pwd, userLogin.pwd)
+
+        if (!isPasswordMatch) {
+            throw { code: 401, title: 'Credenciales incorrectas', detail: 'Usuario desactivado por el administrador.', suggestion: 'Verifica que el usuario y contraseña sean correctas', error: new Error() }
+        }
+
+        else {
+            const token = await userLogin.generateAuthToken()
+
+            res.cookie("token", token, {
+                secure: true,
+                httpOnly: true,
+                sameSite: 'none',
+                expires: dayjs().add(30, "days").toDate(),
+            })
+
+            return { token }
+        }
+    }
+}
+
+self.logout = async (req, res) => {
+    const user = await User.findOne({ _id: req.user._id })
+    user.tokens = user.tokens.filter((token) => {
+        return token.token != req.token
+    })
+
+    cookies.set('token', { expires: Date.now() })
+
+    await user.save()
+    return true
+}
+
+self.logoutAll = async (req, res) => {
+    req.user.tokens = []
+    await req.user.save()
+    cookies.set('token', { expires: Date.now() })
+
+    return true
+}
+
+self.getPermission = (user) => {
+    let result = {}
+    for (let i in user._functions) {
+        if (user._functions[i].status === 'Activo') {
+            for (let j in user._functions[i]._permissions) {
+                if (user._functions[i]._permissions[j].status === 'Activo') {
+                    result[user._functions[i]._permissions[j].api] = true
+                }
+            }
+        }
+    }
+    return result
+}
+
+self.getMenu = (user) => {
+    let result = []
+    for (let i in user._functions) {
+        if (user._functions[i].status === 'Activo') {
+            for (let j in user._functions[i]._menu) {
+                if (user._functions[i]._menu[j].status === 'Activo')
+                    result.push(user._functions[i]._menu[j])
+            }
+        }
+    }
+    result.sort(function (a, b) {
+        if (a.index > b.index) { return 1 }
+        if (a.index < b.index) { return -1 }
+        return 0
+    })
+    return result
+}
+
+self.me = async (req, res) => {
+
+    let user = await User.findOne({ _id: req.user._id }, { "tokens": 0, pwd: 0 }).populate([
+        { path: "_functions", populate: [{ path: "_permissions" }] },
+        { path: "_menus" }
+    ]).lean()
+
+    // Obtener menús y funciones sin repertir y activas
+    user.menus = self.getMenu(user)
+    user.permissions = self.getPermission(user)
+    for (let i in user._functions) {
+        user._functions[i]._permissions = null
+    }
+
+    return user
+}
+
+self.resetPass = async (req, res) => {
+
+    const usuario = await User.findOne({ _id: req.user._id })
+
+    if (usuario) {
+        usuario.pwd = req.body.pwd
+        usuario.lastUpdate = new Date().getTime()
+        await usuario.save()
+
+        return "password updated successfully"
+    } else {
+        throw { code: 409, title: 'Usuario no encontrado.', detail: '', suggestion: 'Verifica que el Usuario exista', error: new Error() }
+    }
+}
+
+self.updateAny = async (req, res) => {
+
+    const usuario = await User.findOne({ _id: req.user._id }, { _id: 1 })
+    if (usuario) {
+        const update = await User.updateOne({ _id: req.user._id }, { $set: req.body, lastUpdate: (new Date()).getTime() })
+        return update
+    } else {
+        throw { code: 409, title: 'Usuario no encontrado.', detail: '', suggestion: 'Vuelve a iniciar sesión', error: new Error() }
+    }
+}
+
+self.generatecode = async () => {
+    let code = ""
+    let random = []
+
+    function getRandomArbitrary(min, max) {
+        return Math.floor(Math.random() * (max - min) + min)
+    }
+    function isReapeat(arr, value) {
+        for (let i in arr) {
+            if (arr[i].nivel === value) {
+                return true
+            }
+        }
+        return false
+    }
+
+    function getRandom() {
+        const nivel = getRandomArbitrary(0, 10)
+        if (!isReapeat(random, nivel)) {
+            random.push({ nivel: nivel })
+        }
+        if (random.length < 4) {
+            getRandom()
+        }
+    }
+
+    getRandom()
+
+    for (let i in random) {
+        code += random[i].nivel
+    }
+
+    return code
+}
+
+self.sendcodemail = async (email, code) => {
+
+    const user = await User.findOne({ email: email }, { name: 1, email: 1 })
+
+    let file = fs.readFileSync(process.env.TEMPLATE_RECOVER_PASSWORD, "utf8")
+    file = file.replace('+++user+++', user.name)
+    file = file.replace('+++code+++', code)
+    await ses.sendCustom(user.email, file, "Código de recuperación de contraseña")
+
+    return true
+}
+
+self.recoverpassword = async (req, res) => {
+
+    const user = await User.findOne({ email: req.body.email })
+    if (!user) {
+        throw { code: 409, title: 'Usuario no encontrado.', detail: '', suggestion: 'Verifica que el Usuario exista', error: new Error() }
+    }
+
+    const code = await self.generatecode()
+    await self.sendcodemail(user.email, code)
+
+    user.validateKey.resetPassword.resetCode = code
+    let time = new Date()
+    const sumarMinutos = new Date(time.getTime() + 5 * 60000)
+    user.validateKey.limitCodeTime = (new Date(sumarMinutos)).getTime()
+
+    await user.save()
+
+    return true
+}
+
+self.verifyCode = async (req, res) => {
+
+    const correo = req.body.email
+    let body = JSON.parse(JSON.stringify(req.body))
+    const user = await User.findOne({ email: correo })
+    const newTime = new Date().getTime()
+
+    if (!user) {
+        throw { code: 409, title: 'No se pudo validar la información.', detail: '', suggestion: 'Verifica que el usuario exista', error: new Error() }
+    }
+
+    if (user.validateKey.limitCodeTime < newTime) {
+        throw { code: 409, title: 'El código ha caducado.', detail: '', suggestion: 'Vuelve a intentarlo', error: new Error() }
+    }
+
+    if (user.validateKey.resetPassword.resetCode == body.resetCode) {
+        user.validateKey.resetPassword.validCode = true
+        await user.save()
+    }
+    else {
+        throw { code: 409, title: 'Código incorrecto.', detail: '', suggestion: 'El código no coincide verifica el valor', error: new Error() }
+    }
+
+    return true
+}
+
+
+self.resetPassword = async (req, res) => {
+
+    let correo = req.body.email
+    var body = JSON.parse(JSON.stringify(req.body))
+    let usuario = await User.findOne({ email: correo })
+
+    if (!usuario) {
+        throw { code: 409, title: 'Usuario no encontrado.', detail: '', suggestion: 'Verifica que el usuario exista', error: new Error() }
+    }
+
+    const newTime = new Date().getTime()
+
+    if (usuario.validateKey.limitCodeTime < newTime) {
+
+        usuario.validateKey.limitCodeTime = null
+        usuario.validateKey.resetPassword.resetCode = null
+        usuario.validateKey.resetPassword.validCode = false
+        await usuario.save()
+        throw { code: 409, title: 'El código ha caducado.', detail: '', suggestion: 'Vuelve a intentarlo', error: new Error() }
+    }
+
+    if (usuario.validateKey.resetPassword.validCode == true && usuario.validateKey.resetPassword.resetCode == req.body.resetCode) {
+        usuario.pwd = body.pwd
+        usuario.validateKey.resetPassword.validCode = false
+        usuario.validateKey.resetPassword.resetCode = null
+        usuario.validateKey.limitCodeTime = null
+        usuario.lastUpdate = new Date().getTime()
+        usuario.tokens = []
+
+        await usuario.save()
+
+        const token = await usuario.generateAuthToken()
+
+        res.cookie("token", token, {
+            secure: true,
+            httpOnly: true,
+            sameSite: 'none',
+            expires: dayjs().add(30, "days").toDate(),
+        })
+
+        return { token }
+    }
+    else {
+        throw { code: 401, title: 'El código no ha sido verificado', detail: '', suggestion: 'Vuelve a intentarlo', error: new Error() }
+    }
+}
+
+self.sendverifyToken = async (correo, token) => {
+
+
+    let user = await User.findOne({ email: correo }, { name: 1, email: 1 })
+
+    let file = fs.readFileSync(process.env.TEMPLATE_VERIFY_EMAIL, "utf8")
+    file = file.replace('+++user+++', user.name)
+    file = file.replace('+++token+++', token)
+
+    await ses.sendCustom(user.email, file, "Verifica tu cuenta de " + process.env.PROJECT_NAME)
+    return true
+}
+
+self.sendVerifyMailAccountJob = async (data, ban) => {
+    // Generating recover pwd code and sending to user email address
+    let user
+    if (ban == true) {
+        user = await User.findOne({ email: data.body.email }).lean()
+    } else {
+        user = await User.findOne({ email: data }).lean()
+    }
+
+    const token = jwt.sign({ _id: user._id }, process.env.AUTH_SECRET)
+
+    await User.updateOne({ _id: user._id }, { 'validateKey.validateEmail.verifyMailToken': token, 'validateKey.validateEmail.emailVerified': false })
+    await self.sendverifyToken(user.email, token)
+
+    return true
+}
+
+self.sendValidateEmail = async (email) => {
+    let user = await User.findOne({ email: email }, { name: 1, email: 1 })
+
+    let file = fs.readFileSync(process.env.TEMPLATE_WELCOME, "utf8")
+    file = file.replace('+++user+++', user.name)
+
+    return await sesSDK.sendCustom(user.email, file, 'Bienvenido a ' + process.env.PROJECT_NAME)
+}
+
+self.verifyMailTokenAccount = async (req, res) => {
+
+    let token = req.params.token
+    const data = jwt.verify(token, process.env.AUTH_SECRET)
+
+    let user = await User.findOne({ _id: data._id, 'validateKey.validateEmail.verifyMailToken': token })
+
+    if (!user) {
+        throw { code: 409, title: 'Usuario no encontrado.', detail: '', suggestion: 'Verifica que el usuario exista', error: new Error() }
+    } else {
+        user.validateKey.validateEmail.verifyMailToken = null
+        user.validateKey.validateEmail.emailVerified = true
+        user.save()
+    }
+
+    if (user.validateKey.validateEmail.emailVerified == true) {
+        await self.sendValidateEmail(user.email)
+    }
+
+    return 'Usuario verificado con éxito'
+}
+
+self.updatePicture = async (req, res) => {
+
+    let user = await User.findOne({ _id: req.user._id })
+    if (!user) {
+        throw { code: 409, title: 'Usuario no encontrado.', detail: '', suggestion: 'Verifica que el usuario exista', error: new Error() }
+    }
+
+    const url = await s3.upload('user/urlImg-' + user._id, req.files.urlImg)
+    await User.updateOne({ _id: user._id }, { urlImg: url, lastUpdate: (new Date()).getTime() })
+    const result = await User.findOne({ _id: user._id })
+
+    return result
+}
+
+self.verifyPhone = async (req, res) => {
+
+        const user = await User.findOne({ phone: req.user.phone })
+        if (!user) {
+            throw { code: 409, title: 'Usuario no encontrado.', detail: '', suggestion: 'Verifica que el usuario exista', error: new Error() }
+        }
+
+        const code = await self.generatecode()
+        const Message =  "Tu código de "+process.env.PROJECT_NAME +" es: "+code+". No lo compartas con nadie. "+process.env.PROJECT_URL
+        await User.updateOne({ _id: user._id }, { 'validateKey.validatePhone.codeVerifyPhone': code, 'validateKey.validatePhone.validCodePhone': false })
+        await sns.sendMessagePhone(req.user.phone, Message)
+
+        user.validateKey.validatePhone.codeVerifyPhone = code
+        let time = new Date()
+        const sumarMinutos = new Date(time.getTime() + 10 * 60000)
+        user.limitCodeTime = (new Date(sumarMinutos)).getTime()
+        await user.save()
+
+        return true
+}
+
+self.validatePhone = async (req, res) => {
+    
+        let body = JSON.parse(JSON.stringify(req.body))
+        const user = await User.findOne({ phone: req.user.phone })
+        const newTime = new Date().getTime()
+
+        if (!user) {
+            throw { code: 409, title: 'Usuario no encontrado.', detail: '', suggestion: 'Verifica que el usuario exista', error: new Error() }
+        }
+
+        if (user.limitCodeTime < newTime){
+            throw { code: 409, title: 'El código ha caducado.', detail: '', suggestion: 'Verifica que el código sea correcto', error: new Error() }
+        }
+
+        if (user.validateKey.validatePhone.codeVerifyPhone == body.codeVerifyPhone) {
+            user.validateKey.validatePhone.codeVerifyPhone = null
+            user.limitCodeTime = null
+            user.validateKey.validatePhone.validCodePhone = true
+
+            await user.save()
+        }
+        else{
+            throw { code: 409, title: 'Código incorrecto.', detail: '', suggestion: 'Verifica el código', error: new Error() }
+        }
+
+        return "Teléfono Verificado"
+}

package/lib/services/s3.js

@@ -0,0 +1,72 @@
+const { S3Client, PutObjectCommand, DeleteObjectsCommand, DeleteObjectCommand } = require("@aws-sdk/client-s3")
+const path = require('path')
+const utils = require('../config/utils')
+const self = module.exports
+
+/**
+ * pathFile = folder/file_name-file_id
+ * file     = req.files.property
+ */
+self.upload = async (pathFile, file) => {
+    try {
+
+        const s3Client = new S3Client({ region: process.env.AWS_REGION })
+        const extension = path.extname(file.name)
+        const params = {
+            Bucket: process.env.AWS_BUCKET,
+            Key: pathFile + extension,
+            ContentType: 'application/' + extension,
+            Body: file.data,
+            ACL: 'public-read'
+        }
+        const command = new PutObjectCommand(params)
+        await s3Client.send(command)
+        const evidence = 'https://' + process.env.AWS_BUCKET + '.s3.amazonaws.com/' + pathFile + extension
+
+        return evidence
+    } catch (error) {
+        await utils.responseError(error)
+    }
+}
+
+// files = [{key: 'folder/file1'},{key: 'folder/file1'}]
+self.deleteMany = async (files) => {
+    try {
+        let evidence
+        const s3Client = new S3Client({ region: process.env.AWS_REGION })
+        if (files.length > 0) {
+            const params = {
+                Bucket: process.env.AWS_BUCKET,
+                Delete: {
+                    Objects: files,
+                    Quiet: true
+                },
+            }
+            const command = new DeleteObjectsCommand(params)
+            evidence = await s3Client.send(command)
+        }
+
+        return evidence
+    } catch (error) {
+        await utils.responseError(error)
+    }
+}
+
+// file = folder/file_name
+self.delete = async (file) => {
+    try {
+        const s3Client = new S3Client({ region: process.env.AWS_REGION })
+
+        const params = {
+            Bucket: process.env.AWS_BUCKET,
+            Key: file,
+        }
+
+        const command = new DeleteObjectCommand(params)
+        const evidence = await s3Client.send(command)
+
+        return evidence
+    } catch (error) {
+        await utils.responseError(error)
+    }
+}

package/lib/services/ses.js

@@ -0,0 +1,98 @@
+const { SESClient, SendEmailCommand } = require("@aws-sdk/client-ses")
+const self = module.exports
+
+/**
+ * email: Destination email
+ * message: Link to login
+ * subject: Mail subject
+ */
+self.send = async (email, message, subject) => {
+    try {
+        const client = new SESClient({ region: process.env.AWS_REGION })
+        const params = {
+            Destination: {
+                ToAddresses: [
+                    email
+                ]
+            },
+            Message: {
+                Body: {
+                    Html: {
+                        Charset: "UTF-8",
+                        Data: `<html>
+                        <body style="font-family: Verdana, Geneva, sans-serif;">
+                            <table align='center' width='100%' cellpadding='0' cellspacing='0'
+                                style='max-width: 640px; padding: 20px 40px; background-color: #fff; box-shadow: 0 5px 15px 0 rgba(0, 0, 0, 0.1), 0 15px 35px 0 rgba(0, 0, 0, 0.05);'>
+                                <tbody>
+                                    <tr>
+                                        <td style='font-size: 14px; text-align: justify; line-height: 1.75;'>
+                                            <p>A continuación, inicie sesión para establecer la contraseña de su usuario en la plataforma</p>
+                                            <div style="width: 100%!important; text-align:center; margin-bottom: 1.5rem;">
+                                                <a style="width: 100%!important; text-decoration:none;">
+                                                    <div
+                                                        style="background:#000000; color:#ffffff; font-size: 18px; text-decoration:none; padding:1rem 2.5rem; border-radius: 8px;">
+                                                        <a style="color:#ffffff; font-size: 20px;  text-decoration:none; padding:0;"
+                                                            href="`+ message + `">Acceder
+                                                        </a>
+                                                    </div>
+                                                </a>
+                                            </div>
+                                            <hr style="width:100%; background:#000000; padding:4px 0;">
+                                        </td>
+                                    </tr>
+                                </tbody>
+                            </table>
+                        </body>
+                        </html>`
+                    }
+                },
+                Subject: {
+                    Charset: "UTF-8",
+                    Data: subject
+                }
+            },
+            Source: process.env.AWS_EMAIL_SENDER//verified mail
+        }
+        const command = new SendEmailCommand(params)
+        await client.send(command)
+        return true
+    } catch (error) {
+        await utils.responseError(error)
+    }
+}
+
+/**
+ * email: Destination email
+ * message: Mail body
+ * subject: Mail subject
+ */
+self.sendCustom = async (email, message, subject) => {
+    try {
+        const client = new SESClient({ region: process.env.AWS_REGION })
+        const params = {
+            Destination: {
+                ToAddresses: [
+                    email
+                ]
+            },
+            Message: {
+                Body: {
+                    Html: {
+                        Charset: "UTF-8",
+                        Data: message
+                    }
+                },
+                Subject: {
+                    Charset: "UTF-8",
+                    Data: subject
+                }
+            },
+            Source: process.env.AWS_EMAIL_SENDER//verified mail
+        }
+        const command = new SendEmailCommand(params)
+        await client.send(command)
+        return true
+    } catch (error) {
+        await utils.responseError(error)
+    }
+}

package/lib/services/sns.js

@@ -0,0 +1,22 @@
+const { SNSClient, PublishCommand } = require("@aws-sdk/client-sns")
+const self = module.exports
+
+/**
+ * phoneNumber: Destination email
+ * message: Mail body
+ */
+self.sendMessagePhone = async (phoneNumber, message) => {
+    try {
+        const client = new SNSClient({ region: process.env.AWS_REGION })
+        const params = {
+            PhoneNumber: phoneNumber,
+            Message: message
+        }
+
+        const command = new PublishCommand(params)
+        await client.send(command)
+        return true
+    } catch (error) {
+        await utils.responseError(error)
+    }
+}