@kne/fastify-account 1.0.0-alpha.9 → 2.0.0-alpha.1

package/index.js

@@ -1,29 +1,39 @@
 const fp = require('fastify-plugin');
-const packageJson = require('./package.json');
-const path = require('path');
-const merge = require('lodash/merge');
-const { Unauthorized } = require('http-errors');
+const path = require('node:path');
+const {merge } = require('lodash');
+const jwt = require('@fastify/jwt');
+const namespace = require('@kne/fastify-namespace');
+const httpErrors = require('http-errors');
 
-module.exports = fp(
+const { Unauthorized } = httpErrors;
+
+const user = fp(
   async function (fastify, options) {
-    await fastify.sequelize.addModels(path.resolve(__dirname, './models'));
     options = merge(
       {
-        prefix: `/api/v${packageJson.version.split('.')[0]}/account`, //如果为true，发送邮件和短信将不调用，验证码随response返回
+        name: 'account',
+        version: '1.0.0',
         dbTableNamePrefix: 't_account_',
         isTest: false,
         jwt: {
-          secret: 'super-secret'
+          secret: 'super-secret',
+          expires: null,
+          verify: {
+            extractToken: request => request.headers['x-user-token']
+          }
         },
-        defaultPassword: 'Aa000000!'
+        defaultPassword: 'Aa000000!',
+        sendMessage: async () => {}
       },
       options
     );
-    fastify.register(require('fastify-ip'));
-    fastify.register(require('@fastify/jwt'), options.jwt);
-    fastify.register(require('@kne/fastify-namespace'), {
+    if (!options.prefix) {
+      options.prefix = `/api/${options.name}/v${options.version}`;
+    }
+    fastify.register(jwt, options.jwt);
+    fastify.register(namespace, {
       options,
-      name: 'account',
+      name: options.name,
       modules: [
         [
           'models',
@@ -37,17 +47,19 @@ module.exports = fp(
           'authenticate',
           {
             user: async request => {
+              const { services } = fastify[options.name];
               const info = await request.jwtVerify();
               //这里判断失效时间
-              //info.iat
+              if (options.jwt.expires && Date.now() - info.iat * 1000 > options.jwt.expires) {
+                throw Unauthorized('身份认证超时');
+              }
               request.authenticatePayload = info.payload;
-              request.userInfo = await fastify.account.services.user.getUser(request.authenticatePayload);
-            },
-            tenant: async request => {
-              request.tenantInfo = await fastify.account.services.tenantUser.getTenantUserByUserId(request.userInfo);
+              request.userInfo = await services.user.getUser(request.authenticatePayload);
+              request.appName = request.headers['x-app-name'];
             },
             admin: async request => {
-              if (!(await fastify.account.services.admin.checkIsSuperAdmin(request.userInfo))) {
+              const { services } = fastify[options.name];
+              if (!(await services.admin.checkIsSuperAdmin(request.userInfo))) {
                 throw Unauthorized('不能执行该操作，需要超级管理员权限');
               }
             }
@@ -57,7 +69,8 @@ module.exports = fp(
     });
   },
   {
-    name: 'fastify-account',
-    dependencies: ['fastify-sequelize']
+    name: 'fastify-user'
   }
 );
+
+module.exports = user;

package/libs/controllers/account.js

@@ -1,190 +1,263 @@
 const fp = require('fastify-plugin');
-module.exports = fp(async (fastify, options) => {
-  const { services } = fastify.account;
-  fastify.post(
-    `${options.prefix}/sendEmailCode`,
-    {
-      schema: {
-        body: {
-          type: 'object',
-          required: ['email'],
-          properties: {
-            email: { type: 'string', description: '邮箱' }
-          }
-        },
-        response: {
-          200: {
-            content: {
-              'application/json': {
-                schema: {
-                  type: 'object',
-                  properties: {
-                    code: { type: 'number' },
-                    data: {
-                      type: 'object',
-                      properties: {
-                        code: { type: 'string', description: '验证码' }
-                      }
-                    },
-                    msg: { type: 'string' }
-                  }
+
+const accountController = fp(async (fastify, options) => {
+    const {services} = fastify[options.name];
+    fastify.post(`${options.prefix}/account/sendEmailCode`, {
+        schema: {
+            tags: ['账号'], summary: '发送登录邮箱验证码', body: {
+                type: 'object', required: ['email'], properties: {
+                    email: {type: 'string', description: '邮箱'}
+                }
+            }, response: {
+                200: {
+                    content: {
+                        'application/json': {
+                            schema: {
+                                type: 'object', properties: {
+                                    code: {type: 'string', description: '验证码'}
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }, async request => {
+        const {email} = request.body;
+        const code = await services.account.sendVerificationCode({name: email, type: 0});
+        return options.isTest ? {code} : {};
+    });
+
+    fastify.post(`${options.prefix}/account/sendSMSCode`, {
+        schema: {
+            tags: ['账号'], summary: '发送登录短信验证码', body: {
+                type: 'object', required: ['phone'], properties: {
+                    phone: {type: 'string', description: '电话'}
+                }
+            }, response: {
+                200: {
+                    content: {
+                        'application/json': {
+                            schema: {
+                                type: 'object', properties: {
+                                    code: {type: 'string', description: '验证码'}
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }, async request => {
+        const {phone} = request.body;
+        const code = await services.account.sendVerificationCode({name: phone, type: 0});
+        return options.isTest ? {code} : {};
+    });
+
+    fastify.post(`${options.prefix}/account/validateCode`, {
+        schema: {
+            tags: ['账号'], summary: '验证码验证', body: {
+                type: 'object', required: ['name', 'type', 'code'], properties: {
+                    name: {type: 'string', description: '被验证的账号，手机或邮箱'},
+                    type: {type: 'number', description: '0:注册,2:登录,4:验证租户管理员,5:忘记密码'},
+                    code: {type: 'string', description: '接受到的验证码'}
+                }
+            }, response: {
+                200: {
+                    content: {
+                        'application/json': {
+                            schema: {}
+                        }
+                    }
+                }
+            }
+        }
+    }, async request => {
+        const {name, type, code} = request.body;
+        const isPass = await services.account.verificationCodeValidate({
+            name, type, code
+        });
+        if (!isPass) {
+            throw new Error('验证码错误');
+        }
+        return {};
+    });
+
+    fastify.post(`${options.prefix}/account/accountIsExists`, {
+        schema: {
+            tags: ['账号'], summary: '账号是否已存在', body: {
+                oneOf: [{
+                    type: 'object', required: ['phone'], properties: {
+                        phone: {type: 'string', description: '电话'}
+                    }
+                }, {
+                    type: 'object', required: ['email'], properties: {
+                        email: {type: 'string', description: '邮箱'}
+                    }
+                }]
+            }, response: {
+                200: {
+                    content: {
+                        'application/json': {
+                            schema: {
+                                type: 'object', properties: {
+                                    isExists: {type: 'boolean', description: 'true已存在，false不存在'}
+                                }
+                            }
+                        }
+                    }
                 }
-              }
             }
-          }
         }
-      }
-    },
-    async request => {
-      const { email } = request.body;
-      const code = await services.account.sendEmailCode({ email });
-      return options.isTest ? { code } : {};
-    }
-  );
+    }, async request => {
+        const {phone, email} = request.body;
+        return {isExists: await services.user.accountIsExists({phone, email})};
+    });
 
-  fastify.post(
-    `${options.prefix}/sendSMSCode`,
-    {
-      schema: {
-        body: {
-          type: 'object',
-          required: ['phone'],
-          properties: {
-            phone: { type: 'string', description: '电话' }
-          }
+    fastify.post(`${options.prefix}/account/register`, {
+        schema: {
+            tags: ['账号'], summary: '注册账号', body: {
+                oneOf: [{
+                    type: 'object', required: ['phone', 'password', 'code'], properties: {
+                        avatar: {type: 'string', description: '头像图片id'},
+                        phone: {type: 'string', description: '电话'},
+                        code: {type: 'string', description: '验证码'},
+                        password: {type: 'string', description: '密码（需要md5加密）'},
+                        invitationCode: {type: 'string', description: '邀请码，用来默认加入租户'},
+                        nickname: {type: 'string', description: '昵称'},
+                        gender: {type: 'string', description: '性别'},
+                        birthday: {type: 'string', format: 'date', description: '出生日期'},
+                        description: {type: 'string', description: '个人简介'}
+                    }
+                }, {
+                    type: 'object', required: ['email', 'password', 'code'], properties: {
+                        avatar: {type: 'string', description: '头像图片id'},
+                        email: {type: 'string', description: '邮箱'},
+                        code: {type: 'string', description: '验证码'},
+                        password: {type: 'string', description: '密码（需要md5加密）'},
+                        invitationCode: {type: 'string', description: '邀请码，用来默认加入租户'},
+                        nickname: {type: 'string', description: '昵称'},
+                        gender: {type: 'string', description: '性别'},
+                        birthday: {type: 'string', format: 'date', description: '出生日期'},
+                        description: {type: 'string', description: '个人简介'}
+                    }
+                }]
+            }, response: {
+                200: {
+                    content: {
+                        'application/json': {
+                            schema: {}
+                        }
+                    }
+                }
+            }
         }
-      }
-    },
-    async request => {
-      const { phone } = request.body;
-      const code = await services.account.sendSMSCode({ phone });
-      return options.isTest ? { code } : {};
-    }
-  );
+    }, async request => {
+        const account = request.body;
+        return await services.account.register(account);
+    });
 
-  fastify.post(
-    `${options.prefix}/validateCode`,
-    {
-      schema: {
-        body: {
-          type: 'object',
-          required: ['name', 'type', 'code'],
-          properties: {
-            name: { type: 'string', description: '被验证的账号，手机或邮箱' },
-            type: { type: 'number', description: '0:手机注册,1:邮箱注册,2:手机登录,3:邮箱登录,4:验证租户管理员' },
-            code: { type: 'string', description: '接受到的验证码' }
-          }
+    fastify.post(`${options.prefix}/account/login`, {
+        schema: {
+            tags: ['账号'], summary: '登录', body: {
+                type: 'object', required: ['password'], properties: {
+                    type: {type: 'string', default: 'email', description: '登录类型'},
+                    email: {type: 'string', description: '邮箱'},
+                    phone: {type: 'string', description: '手机号'},
+                    password: {type: 'string', description: '密码'}
+                }
+            }, response: {
+                200: {
+                    content: {
+                        'application/json': {
+                            schema: {
+                                type: 'object', properties: {
+                                    token: {type: 'string', description: '用户token'},
+                                    currentTenantId: {type: 'string', description: '当前租户id'}
+                                }
+                            }
+                        }
+                    }
+                }
+            }
         }
-      }
-    },
-    async request => {
-      const { name, type, code } = request.body;
-      const isPass = await services.account.verificationCodeValidate({
-        name,
-        type,
-        code
-      });
-      if (!isPass) {
-        throw new Error('验证码错误');
-      }
-      return {};
-    }
-  );
+    }, async request => {
+        const appName = request.headers['x-app-name'];
+        const {token, user} = await services.account.login(Object.assign({}, request.body, {appName}));
+        return {token, currentTenantId: user.currentTenantId};
+    });
 
-  fastify.post(
-    `${options.prefix}/accountIsExists`,
-    {
-      schema: {
-        body: {
-          oneOf: [
-            {
-              type: 'object',
-              required: ['phone'],
-              properties: {
-                phone: { type: 'string' }
-              }
-            },
-            {
-              type: 'object',
-              required: ['email'],
-              properties: {
-                email: { type: 'string' }
-              }
+    fastify.post(`${options.prefix}/account/modifyPassword`, {
+        schema: {
+            tags: ['账号'], summary: '新用户重置新密码', body: {
+                oneOf: [{
+                    type: 'object', required: ['email', 'newPwd', 'oldPwd'], properties: {
+                        email: {type: 'string', description: '邮箱'},
+                        newPwd: {type: 'string', description: '新密码'},
+                        oldPwd: {type: 'string', description: '原密码'}
+                    }
+                }, {
+                    type: 'object', required: ['phone', 'newPwd', 'oldPwd'], properties: {
+                        phone: {type: 'string', description: '手机号'},
+                        newPwd: {type: 'string', description: '新密码'},
+                        oldPwd: {type: 'string', description: '原密码'}
+                    }
+                }]
             }
-          ]
         }
-      }
-    },
-    async request => {
-      const { phone, email } = request.body;
-      return { isExists: await services.user.accountIsExists({ phone, email }) };
-    }
-  );
+    }, async request => {
+        await services.account.modifyPassword(request.body);
+        return {};
+    });
 
-  fastify.post(
-    `${options.prefix}/register`,
-    {
-      schema: {
-        body: {
-          oneOf: [
-            {
-              type: 'object',
-              required: ['phone', 'password', 'code'],
-              properties: {
-                avatar: { type: 'string' },
-                phone: { type: 'string' },
-                code: { type: 'string' },
-                password: { type: 'string' },
-                invitationCode: { type: 'string' },
-                nickname: { type: 'string' },
-                gender: { type: 'string' },
-                birthday: { type: 'string', format: 'date' },
-                description: { type: 'string' }
-              }
-            },
-            {
-              type: 'object',
-              required: ['email', 'password', 'code'],
-              properties: {
-                avatar: { type: 'string' },
-                email: { type: 'string' },
-                code: { type: 'string' },
-                password: { type: 'string' },
-                invitationCode: { type: 'string' },
-                nickname: { type: 'string' },
-                gender: { type: 'string' },
-                birthday: { type: 'string', format: 'date' },
-                description: { type: 'string' }
-              }
+    fastify.post(`${options.prefix}/account/resetPassword`, {
+        schema: {
+            tags: ['账号'], summary: '用户重置密码', body: {
+                type: 'object', required: ['newPwd', 'token'], properties: {
+                    newPwd: {type: 'string', description: '新密码'}, token: {type: 'string', description: '验证token'}
+                }
             }
-          ]
         }
-      }
-    },
-    async request => {
-      const account = request.body;
-      return await services.account.register(account);
-    }
-  );
+    }, async request => {
+        await services.account.resetPasswordByToken({
+            password: request.body.newPwd, token: request.body.token
+        });
 
-  fastify.post(
-    `${options.prefix}/login`,
-    {
-      schema: {
-        body: {
-          type: 'object',
-          required: ['username', 'password'],
-          properties: {
-            username: { type: 'string' },
-            password: { type: 'string' }
-          }
+        return {};
+    });
+
+    fastify.post(`${options.prefix}/account/forgetPwd`, {
+        schema: {
+            tags: ['账号'], summary: '忘记密码', body: {
+                oneOf: [{
+                    type: 'object', required: ['email'], properties: {
+                        email: {type: 'string', description: '邮箱'}
+                    }
+                }, {
+                    type: 'object', required: ['phone'], properties: {
+                        phone: {type: 'string', description: '手机号'}
+                    }
+                }]
+            }
         }
-      }
-    },
-    async request => {
-      const { username, password } = request.body;
-      const { token, user } = await services.account.login({ username, password, ip: request.ip });
-      return { token, currentTenantId: user.currentTenantId };
-    }
-  );
+    }, async request => {
+        const name = request.body.email || request.body.phone;
+        const token = await services.account.sendJWTVerificationCode({name, type: 5});
+        return options.isTest ? {token} : {};
+    });
+
+    fastify.post(`${options.prefix}/account/parseResetToken`, {
+        schema: {
+            tags: ['账号'], summary: '通过token获取name', body: {
+                type: 'object', required: ['token'], properties: {
+                    token: {type: 'string'}
+                }
+            }
+        }
+    }, async request => {
+        const {name} = await services.account.verificationJWTCodeValidate(request.body);
+        return {name};
+    });
 });
+
+module.exports = accountController;

package/libs/controllers/admin-user.js

@@ -0,0 +1,110 @@
+const fp = require('fastify-plugin');
+
+const adminUserController = fp(async (fastify, options) => {
+    const {services, authenticate} = fastify[options.name];
+    fastify.get(`${options.prefix}/admin/getUserList`, {
+        onRequest: [authenticate.user, authenticate.admin], schema: {
+            tags: ['管理后台'], summary: '获取用户列表', query: {
+                type: 'object', properties: {
+                    perPage: {type: 'number'}, currentPage: {type: 'number'}
+                }
+            }
+        }
+    }, async request => {
+        const {filter, perPage, currentPage} = Object.assign({
+            perPage: 20, currentPage: 1
+        }, request.query);
+        return await services.user.getUserList({
+            filter, perPage, currentPage
+        });
+    });
+
+    fastify.post(`${options.prefix}/admin/resetUserPassword`, {
+        onRequest: [authenticate.user, authenticate.admin], schema: {
+            tags: ['管理后台'], summary: '重置用户账号密码', body: {
+                type: 'object', required: ['userId', 'password'], properties: {
+                    password: {type: 'string'}, userId: {type: 'string'}
+                }
+            }
+        }
+    }, async request => {
+        await services.account.resetPassword(request.body);
+        return {};
+    });
+
+    fastify.post(`${options.prefix}/admin/addUser`, {
+        onRequest: [authenticate.user, authenticate.admin], schema: {
+            tags: ['管理后台'], summary: '添加用户', body: {}
+        }
+    }, async request => {
+        const userInfo = request.body;
+        await services.user.addUser(Object.assign({}, userInfo, {
+            status: 10, password: services.account.md5(options.defaultPassword)
+        }));
+        return {};
+    });
+
+    fastify.post(`${options.prefix}/admin/saveUser`, {
+        onRequest: [authenticate.user, authenticate.admin], schema: {
+            tags: ['管理后台'], summary: '修改用户信息', body: {
+                type: 'object', required: ['id'], properties: {
+                    id: {type: 'string'},
+                    avatar: {type: 'string'},
+                    nickname: {type: 'string'},
+                    phone: {type: 'string'},
+                    email: {type: 'string'},
+                    description: {type: 'string'}
+                }
+            }
+        }
+    }, async request => {
+        const user = request.body;
+        await services.user.saveUser(user);
+        return {};
+    });
+
+    fastify.post(`${options.prefix}/admin/setSuperAdmin`, {
+        onRequest: [authenticate.user, authenticate.admin], schema: {
+            tags: ['管理后台'], summary: '设置用户为超级管理员', body: {
+                type: 'object', required: ['status', 'userId'], properties: {
+                    status: {type: 'boolean', description: 'true:将用户设置为超级管理员,false:取消用户超级管理员'},
+                    userId: {type: 'string', description: '用户id'}
+                }
+            }
+        }
+    }, async request => {
+        const {status, userId} = request.body;
+        await services.user.setSuperAdmin({userId, status});
+        return {};
+    });
+
+    fastify.post(`${options.prefix}/admin/setUserClose`, {
+        onRequest: [authenticate.user, authenticate.admin], schema: {
+            tags: ['管理后台'], summary: '关闭用户', body: {
+                type: 'object', required: ['id'], properties: {
+                    id: {type: 'string'}
+                }
+            }
+        }
+    }, async request => {
+        const {id} = request.body;
+        await services.user.setUserStatus({userId: id, status: 12});
+        return {};
+    });
+
+    fastify.post(`${options.prefix}/admin/setUserNormal`, {
+        onRequest: [authenticate.user, authenticate.admin], schema: {
+            tags: ['管理后台'], summary: '设置用户状态为正常', body: {
+                type: 'object', required: ['id'], properties: {
+                    id: {type: 'string'}
+                }
+            }
+        }
+    }, async request => {
+        const {id} = request.body;
+        await services.user.setUserStatus({userId: id, status: 0});
+        return {};
+    });
+});
+
+module.exports = adminUserController;