aloux-iam 0.0.20 → 0.0.21

package/lib/middleware.js

@@ -1,91 +1,91 @@
-const jwt = require('jsonwebtoken')
-const User = require('./models/User')
-const Permission = require('./models/Permission')
-
-const getAccess = (user, resource) => {
-    for(let i in user._functions){
-        for(let j in user._functions[i]._permissions){
-            if(user._functions[i]._permissions[j].status === 'Activo'){
-                const permissionBack = user._functions[i]._permissions[j].method + ' ' + user._functions[i]._permissions[j].endpoint
-                if(permissionBack === resource.method + ' ' + resource.endpoint){
-                    return true
-                }
-            }
-        }
-    }
-    return false
-}
-
-const auth = async(req, res, next) => {
-
-    try {
-        
-        let token = req.header('Authorization') || req.cookies && req.cookies.token 
-
-        if (!token) {
-            throw {
-                code: 401,
-                title: 'Error de autenticación',
-                detail: 'Endpoint requiere token',
-                suggestion: 'Vuelve a iniciar sesion',
-                error: new Error()
-              }
-        }
-
-        token = token.replace('Bearer ', '')
-
-        const data = jwt.verify(token, process.env.AUTH_SECRET)
-        const user = await User.findOne({ _id: data._id, 'tokens.token': token, status: 'Activo' }, {"tokens":0,pwd:0}).populate({ path: "_functions", populate: [{ path: "_permissions"}] }).lean()
-        
-        if (!user) {
-            throw {
-                code: 401,
-                title: 'Error de autenticación',
-                detail: 'No se encontró el usuario',
-                suggestion: 'Vuelve a iniciar sesion',
-                error: new Error()
-              }
-        }
-
-        const resource = await Permission.findOne({ method: req.originalMethod, endpoint: req.route.path }).lean()
-        if(!resource){
-            throw {
-                code: 403,
-                title: 'Error de recurso',
-                detail: 'No se encontro  dado de alta el privilegio del endpoint: [' + req.route.path + ']',
-                suggestion: 'Contacta con el administrador',
-                error: new Error()
-              }
-        }
-
-        if(resource.auth){
-            const access = getAccess(user, resource)
-            if (!access) {
-                throw {
-                    code: 403,
-                    title: 'Error de permisos',
-                    detail: 'No cuentas con permisos para el recurso [' + resource.api +'] que: ' + (resource ? resource.description : 'Recurso indefinido' ),
-                    suggestion: 'Contacta con el administrador',
-                    error: new Error()
-                  }
-            }
-        }
-
-        req.user = user
-        req.token = token
-        next()
-    } catch (error) {
-        let obj = error
-        if(!error.code){
-            obj = {
-                code: 401,
-                title: 'Error de autenticación',
-                detail: error.message,
-                suggestion: 'Vuelve a iniciar sesion'
-            }
-        }
-        res.status(obj.code).send(obj)
-    }
-}
-
+const jwt = require('jsonwebtoken')
+const User = require('./models/User')
+const Permission = require('./models/Permission')
+
+const getAccess = (user, resource) => {
+    for(let i in user._functions){
+        for(let j in user._functions[i]._permissions){
+            if(user._functions[i]._permissions[j].status === 'Activo'){
+                const permissionBack = user._functions[i]._permissions[j].method + ' ' + user._functions[i]._permissions[j].endpoint
+                if(permissionBack === resource.method + ' ' + resource.endpoint){
+                    return true
+                }
+            }
+        }
+    }
+    return false
+}
+
+const auth = async(req, res, next) => {
+
+    try {
+        
+        let token = req.header('Authorization') || req.cookies && req.cookies.token 
+
+        if (!token) {
+            throw {
+                code: 401,
+                title: 'Error de autenticación',
+                detail: 'Endpoint requiere token',
+                suggestion: 'Vuelve a iniciar sesion',
+                error: new Error()
+              }
+        }
+
+        token = token.replace('Bearer ', '')
+
+        const data = jwt.verify(token, process.env.AUTH_SECRET)
+        const user = await User.findOne({ _id: data._id, 'tokens.token': token, status: 'Activo' }, {"tokens":0,pwd:0}).populate({ path: "_functions", populate: [{ path: "_permissions"}] }).lean()
+        
+        if (!user) {
+            throw {
+                code: 401,
+                title: 'Error de autenticación',
+                detail: 'No se encontró el usuario',
+                suggestion: 'Vuelve a iniciar sesion',
+                error: new Error()
+              }
+        }
+
+        const resource = await Permission.findOne({ method: req.originalMethod, endpoint: req.route.path }).lean()
+        if(!resource){
+            throw {
+                code: 403,
+                title: 'Error de recurso',
+                detail: 'No se encontro  dado de alta el privilegio del endpoint: [' + req.route.path + ']',
+                suggestion: 'Contacta con el administrador',
+                error: new Error()
+              }
+        }
+
+        if(resource.auth){
+            const access = getAccess(user, resource)
+            if (!access) {
+                throw {
+                    code: 403,
+                    title: 'Error de permisos',
+                    detail: 'No cuentas con permisos para el recurso [' + resource.api +'] que: ' + (resource ? resource.description : 'Recurso indefinido' ),
+                    suggestion: 'Contacta con el administrador',
+                    error: new Error()
+                  }
+            }
+        }
+
+        req.user = user
+        req.token = token
+        next()
+    } catch (error) {
+        let obj = error
+        if(!error.code){
+            obj = {
+                code: 401,
+                title: 'Error de autenticación',
+                detail: error.message,
+                suggestion: 'Vuelve a iniciar sesion'
+            }
+        }
+        res.status(obj.code).send(obj)
+    }
+}
+
 module.exports = auth

package/lib/models/Functions.js

@@ -1,14 +1,14 @@
-const mongoose = require('mongoose')
-
-const functionsSchema = mongoose.Schema({
-    name:           { type: String, required: true, trim: true, unique: true },
-    description:    { type: String, trim: true },
-    _permissions:   [ { type: mongoose.Schema.Types.ObjectId, required: true, ref: 'Permission' } ],
-    _menus:         [ { type: mongoose.Schema.Types.ObjectId, required: true, ref: 'Menu' } ],
-    status:         { type: String },
-    createdAt:      { type: Number },
-    lastUpdate:     { type: Number }
-})
-
-const Functions = mongoose.model("Functions", functionsSchema)
+const mongoose = require('mongoose')
+
+const functionsSchema = mongoose.Schema({
+    name:           { type: String, required: true, trim: true, unique: true },
+    description:    { type: String, trim: true },
+    _permissions:   [ { type: mongoose.Schema.Types.ObjectId, required: true, ref: 'Permission' } ],
+    _menus:         [ { type: mongoose.Schema.Types.ObjectId, required: true, ref: 'Menu' } ],
+    status:         { type: String },
+    createdAt:      { type: Number },
+    lastUpdate:     { type: Number }
+})
+
+const Functions = mongoose.model("Functions", functionsSchema)
 module.exports = Functions

package/lib/models/Menu.js

@@ -1,16 +1,16 @@
-const mongoose = require('mongoose')
-
-const menuSchema = mongoose.Schema({
-    label:          { type: String, required: true, trim: true },
-    path:            { type: String, required: true, trim: true },
-    icon:           { type: String, required: true, trim: true },
-    index:          { type: Number },
-    _menu:          { type: mongoose.Schema.Types.ObjectId, ref: 'Menu' },
-
-    status:         { type: String },
-    createdAt:      { type: Number },
-    lastUpdate:     { type: Number }
-})
-
-const Menu = mongoose.model("Menu", menuSchema)
+const mongoose = require('mongoose')
+
+const menuSchema = mongoose.Schema({
+    label:          { type: String, required: true, trim: true },
+    path:            { type: String, required: true, trim: true },
+    icon:           { type: String, required: true, trim: true },
+    index:          { type: Number },
+    _menu:          { type: mongoose.Schema.Types.ObjectId, ref: 'Menu' },
+
+    status:         { type: String },
+    createdAt:      { type: Number },
+    lastUpdate:     { type: Number }
+})
+
+const Menu = mongoose.model("Menu", menuSchema)
 module.exports = Menu

package/lib/models/Permission.js

@@ -1,15 +1,15 @@
-const mongoose = require('mongoose')
-
-const permissionSchema = mongoose.Schema({
-    description:    { type: String, required: true, trim: true },
-    method:         { type: String, required: true, unique: true },
-    api:            { type: String, required: true },
-    endpoint:       { type: String, required: true },
-    auth:           { type: Number, required: true, default: 1},
-    status:         { type: String },
-    createdAt:      { type: Number },
-    lastUpdate:     { type: Number }
-})
-
-const Permission = mongoose.model('Permission', permissionSchema)
+const mongoose = require('mongoose')
+
+const permissionSchema = mongoose.Schema({
+    description:    { type: String, required: true, trim: true },
+    method:         { type: String, required: true, unique: true },
+    api:            { type: String, required: true },
+    endpoint:       { type: String, required: true },
+    auth:           { type: Number, required: true, default: 1},
+    status:         { type: String },
+    createdAt:      { type: Number },
+    lastUpdate:     { type: Number }
+})
+
+const Permission = mongoose.model('Permission', permissionSchema)
 module.exports = Permission

package/lib/models/User.js

@@ -1,104 +1,104 @@
-const mongoose = require("mongoose")
-const bcrypt = require("bcryptjs")
-const jwt = require("jsonwebtoken")
-const ObjectId = mongoose.Schema.Types.ObjectId
-
-const adminSchema = mongoose.Schema({
-    name: { type: String, required: true, trim: true },
-    lastName: { type: String, required: false, trim: true },
-    email: { type: String, required: true, trim: true, unique: true, lowercase: true },
-    pwd: { type: String, trim: true, minLength: 8 },
-    phone: { type: String, trim: true, maxLength: 13 },
-    phoneObj: {
-        e164: { type: String, trim: true, maxLength: 13 },
-        input: { type: String, trim: true, maxLength: 10 },
-        international: { type: String, trim: true, maxLength: 20 },
-        national: { type: String, trim: true, maxLength: 13 },
-        rfc3966: { type: String, trim: true, maxLength: 30 },
-        significant: { type: String, trim: true, maxLength: 10 }
-    },
-    urlImg: { type: String },
-    data: { type: Object },
-    validateKey: {
-        limitCodeTime: { type: Number },
-        resetPassword: {
-            resetCode: { type: Number },
-            validCode: { type: Boolean, default: false },
-        },
-        validateEmail: {
-            emailVerified: { type: Boolean, default: false },
-            verifyMailToken: { type: String },
-        },
-        validatePhone: {
-            codeVerifyPhone: { type: Number },
-            validCodePhone: { type: Boolean, default: false },
-        }
-    },
-    _functions: [
-        {
-            type: ObjectId, required: true, ref: 'Functions'
-        }
-    ],
-    _business: [
-        {
-            type: ObjectId, ref: 'Business'
-        }
-    ],
-    _client: [
-        {
-            type: ObjectId, ref: 'Client'
-        }
-    ],
-    tokens: [
-        {
-            token: { type: String, required: true },
-            date: { type: Number }
-        }
-    ],
-
-    status: { type: String },
-    createdAt: { type: Number },
-    lastUpdate: { type: Number }
-})
-
-adminSchema.pre("save", async function (next) {
-    const user = this
-
-    if (user.isModified("pwd")) {
-        user.pwd = await bcrypt.hash(user.pwd, 8)
-    }
-
-    next()
-})
-
-adminSchema.methods.generateAuthToken = async function () {
-    const user = this
-
-    const token = jwt.sign({ _id: user._id }, process.env.AUTH_SECRET)
-    user.tokens = user.tokens.concat({ token })
-
-    await user.save()
-
-    return token
-}
-
-adminSchema.statics.findByCredentials = async (email, pwd) => {
-    try {
-        const user = await User.findOne({ email: email })
-
-        if (!user) {
-            throw new Error({ error: "Invalid login credentials" })
-        }
-
-        const isPasswordMatch = await bcrypt.compare(pwd, user.pwd)
-
-        if (!isPasswordMatch) {
-            throw new Error({ error: "Invalid login credentials" })
-        }
-
-        return user
-    } catch (error) { }
-}
-
-const User = mongoose.model("User", adminSchema)
-module.exports = User
+const mongoose = require("mongoose")
+const bcrypt = require("bcryptjs")
+const jwt = require("jsonwebtoken")
+const ObjectId = mongoose.Schema.Types.ObjectId
+
+const adminSchema = mongoose.Schema({
+    name: { type: String, required: true, trim: true },
+    lastName: { type: String, required: false, trim: true },
+    email: { type: String, required: true, trim: true, unique: true, lowercase: true },
+    pwd: { type: String, trim: true, minLength: 8 },
+    phone: { type: String, trim: true, maxLength: 13 },
+    phoneObj: {
+        e164: { type: String, trim: true, maxLength: 13 },
+        input: { type: String, trim: true, maxLength: 10 },
+        international: { type: String, trim: true, maxLength: 20 },
+        national: { type: String, trim: true, maxLength: 13 },
+        rfc3966: { type: String, trim: true, maxLength: 30 },
+        significant: { type: String, trim: true, maxLength: 10 }
+    },
+    urlImg: { type: String },
+    data: { type: Object },
+    validateKey: {
+        limitCodeTime: { type: Number },
+        resetPassword: {
+            resetCode: { type: Number },
+            validCode: { type: Boolean, default: false },
+        },
+        validateEmail: {
+            emailVerified: { type: Boolean, default: false },
+            verifyMailToken: { type: String },
+        },
+        validatePhone: {
+            codeVerifyPhone: { type: Number },
+            validCodePhone: { type: Boolean, default: false },
+        }
+    },
+    _functions: [
+        {
+            type: ObjectId, required: true, ref: 'Functions'
+        }
+    ],
+    _business: [
+        {
+            type: ObjectId, ref: 'Business'
+        }
+    ],
+    _client: [
+        {
+            type: ObjectId, ref: 'Client'
+        }
+    ],
+    tokens: [
+        {
+            token: { type: String, required: true },
+            date: { type: Number }
+        }
+    ],
+
+    status: { type: String },
+    createdAt: { type: Number },
+    lastUpdate: { type: Number }
+})
+
+adminSchema.pre("save", async function (next) {
+    const user = this
+
+    if (user.isModified("pwd")) {
+        user.pwd = await bcrypt.hash(user.pwd, 8)
+    }
+
+    next()
+})
+
+adminSchema.methods.generateAuthToken = async function () {
+    const user = this
+
+    const token = jwt.sign({ _id: user._id }, process.env.AUTH_SECRET)
+    user.tokens = user.tokens.concat({ token })
+
+    await user.save()
+
+    return token
+}
+
+adminSchema.statics.findByCredentials = async (email, pwd) => {
+    try {
+        const user = await User.findOne({ email: email })
+
+        if (!user) {
+            throw new Error({ error: "Invalid login credentials" })
+        }
+
+        const isPasswordMatch = await bcrypt.compare(pwd, user.pwd)
+
+        if (!isPasswordMatch) {
+            throw new Error({ error: "Invalid login credentials" })
+        }
+
+        return user
+    } catch (error) { }
+}
+
+const User = mongoose.model("User", adminSchema)
+module.exports = User

package/lib/router.js

@@ -1,73 +1,73 @@
-const express = require('express')
-const middleware = require('./middleware.js')
-const router = express.Router()
-
-const auth           = require('./controllers/auth')
-const user           = require('./controllers/user')
-const menu           = require('./controllers/menu')
-const permission     = require('./controllers/permission')
-const functions      = require('./controllers/functions')
-
-// User / user self (no auth)
-router.post('/iam/auth/email',                     auth.email)
-router.post('/iam/auth/login',                     auth.login)
-router.post('/iam/auth/forgot/password',           auth.recoverpassword) 
-router.post('/iam/auth/validate/code',             auth.verifyCode) 
-router.post('/iam/auth/verify/mail',               auth.sendVerifyMailAccount)
-router.get('/iam/auth/verify/mail/token/:token',   auth.verifyMailTokenAccount)
-router.post('/iam/auth/reset/password',            auth.resetPassword)
-router.post('/iam/auth/signup',                    auth.createCustomer)
-
-// User / user self
-router.get('/iam/auth/me',                          middleware, auth.me)
-router.put('/iam/auth/profile',                     middleware, auth.updateAny)
-router.put('/iam/auth/profile/pictura',             middleware, auth.updatePicture)
-router.put('/iam/auth/reset/password',              middleware, auth.resetPass)
-router.post('/iam/auth/send/verify/phone',          middleware, auth.verifyPhone)
-router.post('/iam/auth/verify/phone',               middleware, auth.validatePhone)
-router.post('/iam/auth/logout',                     middleware, auth.logout)
-
-
-// IAM / User
-router.post('/iam/user',                            middleware, user.create)
-router.get('/iam/user',                             middleware, user.retrieve)
-router.get('/iam/user/:USER_ID',                    middleware, user.get)
-router.patch('/iam/user/:USER_ID',                  middleware, user.update)
-router.put('/iam/user/:USER_ID/status',             middleware, user.status)
-router.put('/iam/user/password/:USER_ID',           middleware, user.updatepassword)
-router.delete('/iam/user/:USER_ID',                 middleware, user.delete)
-router.get('/iam/user/count/all',                   middleware, user.count)
-
-
-// IAM / Function
-router.post('/iam/functions',                       middleware, functions.create)     
-router.patch('/iam/functions/:FUNCTION_ID',         middleware, functions.update)
-router.put('/iam/functions/:FUNCTION_ID/status',    middleware, functions.status)
-router.get('/iam/functions',                        middleware, functions.retrieve)
-router.get('/iam/functions/:FUNCTION_ID',           middleware, functions.get)
-router.delete('/iam/functions/:FUNCTION_ID',        middleware, functions.delete)
-router.get('/iam/functions/count/all',              middleware, functions.count)
-
-
-// IAM / Permission
-router.post('/iam/permission',                      middleware, permission.create)     
-router.patch('/iam/permission/:PERMISSION_ID',      middleware, permission.update)
-router.put('/iam/permission/:PERMISSION_ID/status', middleware, permission.status)
-router.get('/iam/permission',                       middleware, permission.retrieve)
-router.get('/iam/permission/:PERMISSION_ID',        middleware, permission.get)
-router.delete('/iam/permission/:PERMISSION_ID',     middleware, permission.delete)
-router.get('/iam/permission/count/all',             middleware, permission.count)
-
-
-// IAM / Menu
-router.post('/iam/menu',                            middleware, menu.create)     
-router.patch('/iam/menu/:MENU_ID',                  middleware, menu.update)
-router.put('/iam/menu/:MENU_ID/status',             middleware, menu.status)
-router.get('/iam/menu',                             middleware, menu.retrieve)
-router.get('/iam/menu/:MENU_ID',                    middleware, menu.get)
-router.delete('/iam/menu/:MENU_ID',                 middleware, menu.delete)
-router.post('/iam/menu/order',                      middleware, menu.order)
-router.get('/iam/menu/count/all',                   middleware, menu.count)
-
-
+const express = require('express')
+const middleware = require('./middleware.js')
+const router = express.Router()
+
+const auth           = require('./controllers/auth')
+const user           = require('./controllers/user')
+const menu           = require('./controllers/menu')
+const permission     = require('./controllers/permission')
+const functions      = require('./controllers/functions')
+
+// User / user self (no auth)
+router.post('/iam/auth/email',                     auth.email)
+router.post('/iam/auth/login',                     auth.login)
+router.post('/iam/auth/forgot/password',           auth.recoverpassword) 
+router.post('/iam/auth/validate/code',             auth.verifyCode) 
+router.post('/iam/auth/verify/mail',               auth.sendVerifyMailAccount)
+router.get('/iam/auth/verify/mail/token/:token',   auth.verifyMailTokenAccount)
+router.post('/iam/auth/reset/password',            auth.resetPassword)
+router.post('/iam/auth/signup',                    auth.createCustomer)
+
+// User / user self
+router.get('/iam/auth/me',                          middleware, auth.me)
+router.put('/iam/auth/profile',                     middleware, auth.updateAny)
+router.put('/iam/auth/profile/pictura',             middleware, auth.updatePicture)
+router.put('/iam/auth/reset/password',              middleware, auth.resetPass)
+router.post('/iam/auth/send/verify/phone',          middleware, auth.verifyPhone)
+router.post('/iam/auth/verify/phone',               middleware, auth.validatePhone)
+router.post('/iam/auth/logout',                     middleware, auth.logout)
+
+
+// IAM / User
+router.post('/iam/user',                            middleware, user.create)
+router.get('/iam/user',                             middleware, user.retrieve)
+router.get('/iam/user/:USER_ID',                    middleware, user.get)
+router.patch('/iam/user/:USER_ID',                  middleware, user.update)
+router.put('/iam/user/:USER_ID/status',             middleware, user.status)
+router.put('/iam/user/password/:USER_ID',           middleware, user.updatepassword)
+router.delete('/iam/user/:USER_ID',                 middleware, user.delete)
+router.get('/iam/user/count/all',                   middleware, user.count)
+
+
+// IAM / Function
+router.post('/iam/functions',                       middleware, functions.create)     
+router.patch('/iam/functions/:FUNCTION_ID',         middleware, functions.update)
+router.put('/iam/functions/:FUNCTION_ID/status',    middleware, functions.status)
+router.get('/iam/functions',                        middleware, functions.retrieve)
+router.get('/iam/functions/:FUNCTION_ID',           middleware, functions.get)
+router.delete('/iam/functions/:FUNCTION_ID',        middleware, functions.delete)
+router.get('/iam/functions/count/all',              middleware, functions.count)
+
+
+// IAM / Permission
+router.post('/iam/permission',                      middleware, permission.create)     
+router.patch('/iam/permission/:PERMISSION_ID',      middleware, permission.update)
+router.put('/iam/permission/:PERMISSION_ID/status', middleware, permission.status)
+router.get('/iam/permission',                       middleware, permission.retrieve)
+router.get('/iam/permission/:PERMISSION_ID',        middleware, permission.get)
+router.delete('/iam/permission/:PERMISSION_ID',     middleware, permission.delete)
+router.get('/iam/permission/count/all',             middleware, permission.count)
+
+
+// IAM / Menu
+router.post('/iam/menu',                            middleware, menu.create)     
+router.patch('/iam/menu/:MENU_ID',                  middleware, menu.update)
+router.put('/iam/menu/:MENU_ID/status',             middleware, menu.status)
+router.get('/iam/menu',                             middleware, menu.retrieve)
+router.get('/iam/menu/:MENU_ID',                    middleware, menu.get)
+router.delete('/iam/menu/:MENU_ID',                 middleware, menu.delete)
+router.post('/iam/menu/order',                      middleware, menu.order)
+router.get('/iam/menu/count/all',                   middleware, menu.count)
+
+
 module.exports = router