create-young-proj 1.0.0 → 1.1.0-alpha.0

package/template-admin-server/src/controller/dto/role.ts

@@ -0,0 +1,41 @@
+/*
+ * @Author: zhangyang
+ * @Date: 2022-12-28 16:13:54
+ * @LastEditTime: 2022-12-28 16:44:28
+ * @Description:
+ */
+import { Rule, RuleType } from '@midwayjs/validate';
+import { QueryDTO } from '.';
+
+export class RoleQueryDTO extends QueryDTO {
+  @Rule(RuleType.string().optional().allow(''))
+  name: string;
+
+  @Rule(RuleType.string().optional().allow(''))
+  keyword: string;
+}
+
+export class RoleCreateDTO {
+  @Rule(RuleType.string().required())
+  name: string;
+
+  @Rule(RuleType.string().required())
+  keyword: string;
+
+  @Rule(RuleType.string().optional().allow(''))
+  desc: string;
+
+  @Rule(RuleType.number().default(1).optional().allow(''))
+  status: number;
+
+  @Rule(RuleType.number().default(0).optional().allow(''))
+  sort: number;
+}
+
+export class RoleUpdateDTO extends RoleCreateDTO {
+  @Rule(RuleType.string().optional().allow(''))
+  name: string;
+
+  @Rule(RuleType.string().optional().allow(''))
+  keyword: string;
+}

package/template-admin-server/src/controller/dto/user.ts

@@ -0,0 +1,52 @@
+/*
+ * @Author: zhangyang
+ * @Date: 2022-12-27 14:53:51
+ * @LastEditTime: 2023-01-09 14:15:20
+ * @Description:
+ */
+import { OmitDto, Rule, RuleType } from '@midwayjs/validate';
+import { QueryDTO } from '.';
+
+export class UserLoginDTO {
+  @Rule(RuleType.string().required())
+  username: string;
+
+  @Rule(RuleType.string().required())
+  password: string;
+}
+
+export class UserCreateDTO {
+  @Rule(RuleType.number().required())
+  roleId: number;
+
+  @Rule(RuleType.string().required())
+  username: string;
+
+  @Rule(RuleType.string().optional().allow(''))
+  nickname: string;
+
+  @Rule(RuleType.string().required())
+  initPassword: string;
+
+  @Rule(RuleType.string().length(11).required())
+  mobile: string;
+}
+
+export class UserUpdateDTO extends OmitDto(UserCreateDTO, ['initPassword']) {
+  @Rule(RuleType.number().optional().allow(''))
+  roleId: number;
+
+  @Rule(RuleType.string().optional().allow(''))
+  newPassword: string;
+
+  @Rule(RuleType.number().optional().allow(''))
+  status: number;
+}
+
+export class UserQueryDTO extends QueryDTO {
+  @Rule(RuleType.string().optional().allow(''))
+  username: string;
+
+  @Rule(RuleType.string().optional().allow(''))
+  mobile: string;
+}

package/template-admin-server/src/controller/menu.controller.ts

@@ -0,0 +1,138 @@
+/*
+ * @Author: zhangyang
+ * @Date: 2022-12-29 11:10:38
+ * @LastEditTime: 2023-01-06 16:53:43
+ * @Description:
+ */
+import { Inject, Controller, Get, Post, Body, Patch, Del, Param } from '@midwayjs/decorator';
+import { Context } from '@midwayjs/koa';
+import { Validate } from '@midwayjs/validate';
+import { MenuService, RoleService, UserService } from '../service';
+import * as dayjs from 'dayjs';
+import { MenuCreateDTO, MenuUpdateDTO } from './dto';
+import { CacheManager } from '@midwayjs/cache';
+import { Menu } from '../entities/index';
+
+@Controller('/menu')
+export class MenuController {
+  @Inject()
+  ctx: Context;
+
+  @Inject()
+  cacheManager: CacheManager;
+
+  @Inject()
+  menuService: MenuService;
+
+  @Inject()
+  userService: UserService;
+
+  @Inject()
+  roleService: RoleService;
+
+  @Get('/list')
+  @Validate()
+  async getMenuTree() {
+    const data = await this.menuService.getAllTree();
+    return this.ctx.helper.success({ data });
+  }
+
+  @Post('/create')
+  @Validate()
+  async createMenu(@Body() form: MenuCreateDTO) {
+    const { parentId: pid = 0, name = '', title = '', icon = 'store', sort = 0, component } = form;
+
+    if (component && !component.startsWith('/')) {
+      return this.ctx.helper.fail({ msg: '路径不合法' });
+    }
+
+    const { username, nickname } = this.ctx.state.user;
+
+    try {
+      await this.menuService.create({
+        name,
+        title,
+        icon,
+        sort,
+        component,
+        pid: Number(pid),
+        creator: nickname || username,
+      });
+      return this.ctx.helper.success();
+    } catch (error) {
+      return this.ctx.helper.fail({ msg: (error as Error).message });
+    }
+  }
+
+  @Get('/tree')
+  async getSelfMenuTree() {
+    const { username } = this.ctx.state.user;
+    const cacheKey = `${username}.menu.tree`;
+
+    const menus = await this.cacheManager.cache.get<Menu[]>(cacheKey);
+    if (menus) {
+      return this.ctx.helper.success({ data: menus });
+    }
+
+    const user = await this.userService.findOne({ username });
+    if (user) {
+      // @ts-expect-error
+      const id = user.roleId;
+      const role = await this.roleService.findOne({ id });
+      if (role) {
+        const menus = await this.roleService.getAccessMenusTree(role.id);
+        // 设置 1 分钟缓存
+        await this.cacheManager.set(cacheKey, menus, { ttl: 60 });
+        return this.ctx.helper.success({ data: menus });
+      } else {
+        return this.ctx.helper.fail({ msg: '角色不存在！' });
+      }
+    } else {
+      return this.ctx.helper.fail({ msg: '用户不存在！' });
+    }
+  }
+
+  @Patch('/update/:menuId')
+  async update(@Param('menuId') id: string, @Body() form: MenuUpdateDTO) {
+    const { parentId: pid, name, title, icon, sort, status, component, visible } = form;
+
+    try {
+      await this.menuService.update(Number(id), {
+        name,
+        title,
+        icon,
+        sort,
+        status,
+        component,
+        pid,
+        visible,
+        updateAt: dayjs(Date.now()).format('YYYY-MM-DD HH:mm:ss'),
+      });
+      return this.ctx.helper.success();
+    } catch (error) {
+      return this.ctx.helper.fail({ msg: (error as Error).message });
+    }
+  }
+
+  @Del('/delete/batch')
+  async del(@Body('ids') ids: string) {
+    try {
+      await this.menuService.deleteBatch(ids.split(',').map((i: string) => Number(i)));
+      return this.ctx.helper.success();
+    } catch (error) {
+      return this.ctx.helper.fail({ msg: (error as Error).message });
+    }
+  }
+
+  @Get('/all/:roleId')
+  async getRoleAccessMenus(@Param('roleId') roleId: number) {
+    const apis = await this.roleService.getAccessMenus(roleId);
+    const list = await this.menuService.getAllTree();
+    return this.ctx.helper.success({
+      data: {
+        accessIds: apis.map((i) => Number(i.id)),
+        list,
+      },
+    });
+  }
+}

package/template-admin-server/src/controller/role.controller.ts

@@ -0,0 +1,116 @@
+/*
+ * @Author: zhangyang
+ * @Date: 2022-12-27 11:23:39
+ * @LastEditTime: 2022-12-28 17:32:48
+ * @Description:
+ */
+import { Inject, Controller, Get, Query, Post, Body, Patch, Del, Param } from '@midwayjs/decorator';
+import { Context } from '@midwayjs/koa';
+import { Validate } from '@midwayjs/validate';
+import { RoleService } from '../service';
+import { DiffDTO, RoleCreateDTO, RoleQueryDTO, RoleUpdateDTO } from './dto';
+import * as dayjs from 'dayjs';
+
+@Controller('/role')
+export class RoleController {
+  @Inject()
+  ctx: Context;
+
+  @Inject()
+  roleService: RoleService;
+
+  @Get('/list')
+  @Validate()
+  async getRoleList(@Query() query: RoleQueryDTO) {
+    const data = await this.roleService.findAll(query);
+    return this.ctx.helper.success({ data });
+  }
+
+  @Post('/create')
+  @Validate()
+  async createRole(@Body() form: RoleCreateDTO) {
+    const { name = '', keyword = '', desc = '', sort = 0, status = 1 } = form;
+
+    try {
+      const { username, nickname } = this.ctx.state.user;
+      await this.roleService.create({
+        name,
+        sort,
+        creator: nickname || username,
+        keyword,
+        status,
+        desc,
+      });
+      return this.ctx.helper.success();
+    } catch (error) {
+      return this.ctx.helper.fail({ msg: (error as Error).message });
+    }
+  }
+
+  @Patch('/update/:roleId')
+  async update(@Param('roleId') id: string, @Body() form: RoleUpdateDTO) {
+    const { name, keyword, desc, sort, status } = form;
+
+    try {
+      await this.roleService.update(Number(id), {
+        name,
+        keyword,
+        desc,
+        sort,
+        status,
+        updateAt: dayjs(Date.now()).format('YYYY-MM-DD HH:mm:ss'),
+      });
+      return this.ctx.helper.success();
+    } catch (error) {
+      return this.ctx.helper.fail({ msg: (error as Error).message });
+    }
+  }
+
+  @Patch('/menus/update/:roleId')
+  @Validate()
+  async changeRoleMenus(@Param('roleId') roleId: number, @Body() form: DiffDTO) {
+    const { create: add = [], delete: del = [] } = form;
+    try {
+      await this.roleService.addMenus(roleId, add);
+      await this.roleService.delMenus(roleId, del);
+      return this.ctx.helper.success({
+        data: {
+          roleId,
+          add,
+          del,
+        },
+      });
+    } catch (error) {
+      return this.ctx.helper.fail({ msg: (error as Error).message });
+    }
+  }
+
+  @Patch('/apis/update/:roleId')
+  @Validate()
+  async changeRoleApis(@Param('roleId') roleId: number, @Body() form: DiffDTO) {
+    const { create: add = [], delete: del = [] } = form;
+    try {
+      await this.roleService.addApis(roleId, add);
+      await this.roleService.delApis(roleId, del);
+      return this.ctx.helper.success({
+        data: {
+          roleId,
+          add,
+          del,
+        },
+      });
+    } catch (error) {
+      return this.ctx.helper.fail({ msg: (error as Error).message });
+    }
+  }
+
+  @Del('/delete/batch')
+  async del(@Body('ids') ids: string) {
+    try {
+      await this.roleService.deleteBatch(ids.split(',').map((i: string) => Number(i)));
+      return this.ctx.helper.success();
+    } catch (error) {
+      return this.ctx.helper.fail({ msg: (error as Error).message });
+    }
+  }
+}

package/template-admin-server/src/controller/user.controller.ts

@@ -0,0 +1,108 @@
+/*
+ * @Author: zhangyang
+ * @Date: 2022-12-27 11:23:39
+ * @LastEditTime: 2022-12-28 16:31:12
+ * @Description:
+ */
+import { Inject, Controller, Get, Query, Post, Body, Patch, Param, Del } from '@midwayjs/decorator';
+import { Context } from '@midwayjs/koa';
+import { Validate } from '@midwayjs/validate';
+import * as dayjs from 'dayjs';
+import * as md5 from 'md5';
+import { type CreateUserItem, UserService } from '../service';
+import { UserCreateDTO, UserQueryDTO, UserUpdateDTO } from './dto';
+
+@Controller('/user')
+export class UserController {
+  @Inject()
+  ctx: Context;
+
+  @Inject()
+  userService: UserService;
+
+  @Get('/list')
+  @Validate()
+  async getUserList(@Query() query: UserQueryDTO) {
+    const data = await this.userService.findAll(query);
+    return this.ctx.helper.success({ data });
+  }
+
+  @Post('/info')
+  async getUserInfo() {
+    const { username } = this.ctx.state.user;
+
+    const user = await this.userService.findOne({ username });
+    if (user) {
+      const data: CreateUserItem = {
+        ...user,
+      };
+      delete data.password;
+      delete data.createdAt;
+      delete data.updateAt;
+      delete data.creator;
+      delete data.status;
+      delete data.sort;
+      // @ts-expect-error
+      delete data.roleId;
+
+      return this.ctx.helper.success({ data });
+    } else {
+      return this.ctx.helper.fail({ msg: '用户不存在！' });
+    }
+  }
+
+  @Post('/create')
+  @Validate()
+  async createUser(@Body() form: UserCreateDTO) {
+    const { roleId: rid, username, nickname = '', initPassword: pwd, mobile = '' } = form;
+
+    const key = this.ctx.app.getConfig('keys');
+
+    try {
+      const { username: u, nickname: n } = this.ctx.state.user;
+      await this.userService.create({
+        username,
+        nickname,
+        creator: n || u,
+        password: md5(`${key}${pwd}`),
+        mobile,
+        rid,
+      });
+      return this.ctx.helper.success();
+    } catch (error) {
+      return this.ctx.helper.fail({ msg: (error as Error).message });
+    }
+  }
+
+  @Patch('/update/:userId')
+  async update(@Param('userId') id: string, @Body() form: UserUpdateDTO) {
+    const { username, nickname, mobile, roleId: rid, status, newPassword } = form;
+
+    const key = this.ctx.app.getConfig('keys');
+
+    try {
+      await this.userService.update(Number(id), {
+        username,
+        nickname,
+        mobile,
+        rid,
+        status,
+        password: newPassword ? md5(`${key}${newPassword}`) : undefined,
+        updateAt: dayjs(Date.now()).format('YYYY-MM-DD HH:mm:ss'),
+      });
+      return this.ctx.helper.success();
+    } catch (error) {
+      return this.ctx.helper.fail({ msg: (error as Error).message });
+    }
+  }
+
+  @Del('/delete/batch')
+  async del(@Body('ids') ids: string) {
+    try {
+      await this.userService.deleteBatch(ids.split(',').map((i: string) => Number(i)));
+      return this.ctx.helper.success();
+    } catch (error) {
+      return this.ctx.helper.fail({ msg: (error as Error).message });
+    }
+  }
+}

package/template-admin-server/src/entities/Api.ts

@@ -0,0 +1,29 @@
+/*
+ * @Author: zhangyang
+ * @Date: 2022-12-26 14:02:31
+ * @LastEditTime: 2022-12-28 17:57:36
+ * @Description:
+ */
+import { Column, Entity, ManyToMany } from 'typeorm';
+import { BaseCreate } from './BaseCreate';
+import { Role } from './Role';
+
+@Entity({
+  engine: 'InnoDB',
+})
+export class Api extends BaseCreate {
+  @Column({ length: '20' })
+  category!: string;
+
+  @Column({ length: '30', unique: true })
+  path!: string;
+
+  @Column({ length: '10' })
+  method!: string;
+
+  @Column({ length: '20', default: '' })
+  desc?: string;
+
+  @ManyToMany(() => Role, role => role.apis)
+  roles?: Role[];
+}

package/template-admin-server/src/entities/BaseCreate.ts

@@ -0,0 +1,30 @@
+/*
+ * @Author: zhangyang
+ * @Date: 2022-12-26 14:05:04
+ * @LastEditTime: 2023-01-06 17:16:52
+ * @Description:
+ */
+import { Column, PrimaryGeneratedColumn } from 'typeorm';
+
+/**
+ * 基础表结构
+ */
+export abstract class BaseCreate {
+  @PrimaryGeneratedColumn({ type: 'bigint' })
+  id!: number;
+
+  @Column({ update: false, type: 'datetime', default: () => 'NOW()' })
+  createdAt?: string;
+
+  @Column({ type: 'datetime', default: () => 'NOW()' })
+  updateAt?: string;
+
+  @Column({ length: '20', default: '' })
+  creator?: string;
+
+  @Column({ type: 'tinyint', default: 1 })
+  status?: number | '';
+
+  @Column({ default: 0 })
+  sort?: number;
+}

package/template-admin-server/src/entities/Menu.ts

@@ -0,0 +1,39 @@
+/*
+ * @Author: zhangyang
+ * @Date: 2022-12-26 14:12:16
+ * @LastEditTime: 2022-12-27 11:43:21
+ * @Description:
+ */
+import { Column, Entity, ManyToMany, Tree, TreeChildren, TreeParent } from 'typeorm';
+import { BaseCreate } from './BaseCreate';
+import { Role } from './Role';
+
+@Entity({
+  engine: 'InnoDB',
+})
+@Tree('closure-table')
+export class Menu extends BaseCreate {
+  @Column({ length: '20' })
+  name!: string;
+
+  @Column({ length: '20' })
+  title!: string;
+
+  @Column({ length: '30' })
+  component!: string;
+
+  @Column({ default: '' })
+  icon?: string;
+
+  @Column({ type: 'tinyint', default: 1 })
+  visible?: number;
+
+  @TreeParent()
+  parentId?: Menu;
+
+  @TreeChildren()
+  children?: Menu[];
+
+  @ManyToMany(() => Role, role => role.menus)
+  roles?: Role[];
+}

package/template-admin-server/src/entities/Role.ts

@@ -0,0 +1,36 @@
+/*
+ * @Author: zhangyang
+ * @Date: 2022-12-26 14:11:44
+ * @LastEditTime: 2022-12-28 16:36:23
+ * @Description:
+ */
+import { Column, Entity, OneToMany, ManyToMany, JoinTable } from 'typeorm';
+import { Api } from './Api';
+import { BaseCreate } from './BaseCreate';
+import { Menu } from './Menu';
+import { User } from './User';
+
+@Entity({
+  engine: 'InnoDB',
+})
+export class Role extends BaseCreate {
+  @Column({ length: '20' })
+  name!: string;
+
+  @Column({ length: '20', unique: true })
+  keyword!: string;
+
+  @Column({ default: '' })
+  desc?: string;
+
+  @OneToMany(() => User, user => user.role)
+  users?: User[];
+
+  @ManyToMany(() => Api, api => api.roles)
+  @JoinTable()
+  apis?: Api[];
+
+  @ManyToMany(() => Menu, menu => menu.roles)
+  @JoinTable()
+  menus?: Menu[];
+}

package/template-admin-server/src/entities/User.ts

@@ -0,0 +1,35 @@
+/*
+ * @Author: zhangyang
+ * @Date: 2022-12-26 14:11:58
+ * @LastEditTime: 2022-12-28 15:51:23
+ * @Description:
+ */
+import { Column, Entity, ManyToOne } from 'typeorm';
+import { BaseCreate } from './BaseCreate';
+import { Role } from './Role';
+
+@Entity({
+  engine: 'InnoDB',
+})
+export class User extends BaseCreate {
+  @Column({ length: '20', unique: true })
+  username!: string;
+
+  @Column({ length: '11' })
+  mobile!: string;
+
+  @Column({ length: '20', default: '' })
+  nickname?: string;
+
+  @Column({ default: '' })
+  avatar?: string;
+
+  @Column({ length: '50', default: '' })
+  introduction?: string;
+
+  @Column({ select: false })
+  password!: string;
+
+  @ManyToOne(() => Role, role => role.users, { cascade: true })
+  role!: Role;
+}

package/template-admin-server/src/entities/index.ts

@@ -0,0 +1,10 @@
+/*
+ * @Author: zhangyang
+ * @Date: 2022-12-27 12:22:57
+ * @LastEditTime: 2022-12-27 16:07:00
+ * @Description:
+ */
+export * from './User';
+export * from './Api';
+export * from './Menu';
+export * from './Role';

package/template-admin-server/src/filter/default.filter.ts

@@ -0,0 +1,22 @@
+/*
+ * @Author: zhangyang
+ * @Date: 2022-12-27 11:18:26
+ * @LastEditTime: 2022-12-27 11:18:27
+ * @Description:
+ */
+import { Catch } from '@midwayjs/decorator';
+import { Context } from '@midwayjs/koa';
+import { Code } from '../types';
+
+@Catch()
+export class DefaultErrorFilter {
+  async catch(err: Error, ctx: Context) {
+    // 所有的未分类错误会到这里
+    ctx.status = 500;
+    return {
+      code: Code.fail,
+      msg: err.message,
+      data: null,
+    } as ResponseMsg;
+  }
+}

package/template-admin-server/src/filter/notfound.filter.ts

@@ -0,0 +1,23 @@
+/*
+ * @Author: zhangyang
+ * @Date: 2022-12-27 11:06:11
+ * @LastEditTime: 2022-12-27 11:14:48
+ * @Description:
+ */
+import { Catch } from '@midwayjs/decorator';
+import { httpError, MidwayHttpError } from '@midwayjs/core';
+import { Context } from '@midwayjs/koa';
+import { Code } from '../types';
+
+@Catch(httpError.NotFoundError)
+export class NotFoundFilter {
+  async catch(err: MidwayHttpError, ctx: Context) {
+    // 404 错误会到这里
+    ctx.status = 404;
+    return {
+      code: Code.fail,
+      msg: '404, ' + ctx.path,
+      data: null,
+    } as ResponseMsg;
+  }
+}