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

package/template-admin-server/src/middleware/helper.middleware.ts

@@ -0,0 +1,28 @@
+/*
+ * @Author: zhangyang
+ * @Date: 2022-12-27 15:10:18
+ * @LastEditTime: 2022-12-27 16:12:42
+ * @Description:
+ */
+import { IMiddleware } from '@midwayjs/core';
+import { Middleware } from '@midwayjs/decorator';
+import { NextFunction, Context } from '@midwayjs/koa';
+import { fail, success } from '../types';
+
+@Middleware()
+export class HelperMiddleware implements IMiddleware<Context, NextFunction> {
+  resolve() {
+    return async (ctx: Context, next: NextFunction) => {
+      ctx.helper = {
+        success,
+        fail,
+      };
+
+      return next();
+    };
+  }
+
+  static getName(): string {
+    return 'helper';
+  }
+}

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

@@ -0,0 +1,9 @@
+/*
+ * @Author: zhangyang
+ * @Date: 2022-12-27 15:20:37
+ * @LastEditTime: 2022-12-27 16:06:27
+ * @Description:
+ */
+export * from './helper.middleware';
+export * from './report.middleware';
+export * from './jwt.middleware';

package/template-admin-server/src/middleware/jwt.middleware.ts

@@ -0,0 +1,32 @@
+/*
+ * @Author: zhangyang
+ * @Date: 2022-12-27 16:05:38
+ * @LastEditTime: 2023-01-09 10:16:46
+ * @Description:
+ */
+import { Middleware } from '@midwayjs/decorator';
+import { PassportMiddleware, AuthenticateOptions } from '@midwayjs/passport';
+import { JwtStrategy } from '../strategy/jwt.strategy';
+import { Context } from '@midwayjs/koa';
+@Middleware()
+export class JwtPassportMiddleware extends PassportMiddleware(JwtStrategy) {
+  getAuthenticateOptions(): Promise<AuthenticateOptions> | AuthenticateOptions {
+    return {};
+  }
+
+  /**
+   * 免验 jwt 的白名单
+   */
+  ignore(ctx: Context) {
+    ctx.logger.info(ctx.path);
+    return [
+      '/api/base/login',
+      // 初始化后台数据表，仅供开发使用
+      // '/api/admin/init',
+    ].includes(ctx.path);
+  }
+
+  static getName(): string {
+    return 'jwt';
+  }
+}

package/template-admin-server/src/middleware/report.middleware.ts

@@ -0,0 +1,26 @@
+import { IMiddleware } from '@midwayjs/core';
+import { Middleware } from '@midwayjs/decorator';
+import { NextFunction, Context } from '@midwayjs/koa';
+
+@Middleware()
+export class ReportMiddleware implements IMiddleware<Context, NextFunction> {
+  resolve() {
+    return async (ctx: Context, next: NextFunction) => {
+      // 控制器前执行的逻辑
+      const startTime = Date.now();
+      // 执行下一个 Web 中间件，最后执行到控制器
+      // 这里可以拿到下一个中间件或者控制器的返回值
+      const result = await next();
+      // 控制器之后执行的逻辑
+      ctx.logger.info(
+        `Report in "src/middleware/report.middleware.ts", rt = ${Date.now() - startTime}ms`,
+      );
+      // 返回给上一个中间件的结果
+      return result;
+    };
+  }
+
+  static getName(): string {
+    return 'report';
+  }
+}

package/template-admin-server/src/service/api.service.ts

@@ -0,0 +1,174 @@
+/*
+ * @Author: zhangyang
+ * @Date: 2022-12-27 14:31:57
+ * @LastEditTime: 2022-12-27 15:19:51
+ * @Description:
+ */
+import { Provide } from '@midwayjs/decorator';
+import { InjectEntityModel } from '@midwayjs/typeorm';
+import type { Repository } from 'typeorm';
+import { Api, Role } from '../entities';
+import { BasicService } from './basic';
+
+export type CreateApiItem = Partial<Api> & { rids?: number[] };
+
+@Provide()
+export class ApiService extends BasicService<Api, CreateApiItem> {
+  @InjectEntityModel(Api)
+  repo: Repository<Api>;
+
+  async create(item: CreateApiItem) {
+    const api = new Api();
+    for (const [key, value] of Object.entries(item)) {
+      if (key === 'rids' && Array.isArray(value)) {
+        const roles: Role[] = [];
+        for (const id of value) {
+          const role = await this.dataSource.getRepository(Role).findOne({
+            where: {
+              id: id as number,
+            },
+          });
+          if (role) {
+            roles.push(role);
+          } else {
+            throw new Error(`roleId: ${value} doesn't exsist`);
+          }
+        }
+        api.roles = roles;
+      } else {
+        api[key] = value;
+      }
+    }
+    await this.repo.save(api);
+  }
+
+  async getAllTree() {
+    const apis = await this.repo.find({
+      where: {
+        status: 1,
+      },
+      order: {
+        id: 'ASC',
+      },
+    });
+    const res: Record<string, Api[]> = {};
+    for (const api of apis) {
+      api.id = Number(api.id);
+      const group = api.category;
+      if (res[group]) {
+        res[group].push(api);
+      } else {
+        res[group] = [api];
+      }
+    }
+    return Object.entries(res).map(([key, value]) => {
+      return {
+        category: key,
+        desc: key,
+        title: `${key}分组`,
+        id: value[0].id,
+        children: value,
+      };
+    });
+  }
+
+  async findAll(item: CreateApiItem & Paginition) {
+    const query = this.repo.createQueryBuilder();
+    query.select('*');
+
+    const { noPagination, pageNum, pageSize, path } = item;
+
+    if (path) {
+      query.andWhere(`path like '%${path}%'`);
+    }
+
+    const page = Number(pageNum) || 1;
+    const size = Number(pageSize) || 10;
+
+    if (!item.noPagination) {
+      const skip = (page - 1) * size;
+
+      query.skip(skip);
+      query.take(size);
+    }
+
+    const total = await query.getCount();
+    const list = await query.getRawMany();
+
+    for (const api of list) {
+      api.id = Number(api.id);
+    }
+
+    return {
+      pageNum: page,
+      pageSize: size,
+      total,
+      noPagination,
+      list,
+    };
+  }
+
+  async getById(id: number) {
+    const api = await this.repo.findOne({
+      where: { id },
+      relations: ['roles'],
+    });
+    if (!api) {
+      throw new Error(`apiId: ${id} 不存在`);
+    }
+    return api;
+  }
+
+  async deleteBatch(ids: number[]) {
+    const queryRunner = this.dataSource.createQueryRunner();
+    let res: any = true;
+
+    await queryRunner.connect();
+    await queryRunner.startTransaction();
+    try {
+      for (const id of ids) {
+        const api = await this.getById(id);
+        api.roles = [];
+        await this.repo.save(api);
+        await this.delete(id);
+      }
+      await queryRunner.commitTransaction();
+    } catch (error) {
+      await queryRunner.rollbackTransaction();
+      res = error;
+    } finally {
+      await queryRunner.release();
+    }
+
+    if (res !== true) {
+      throw res;
+    }
+  }
+
+  async update(id: number, item: CreateApiItem) {
+    const m = await this.getById(id);
+    for (const [key, value] of Object.entries(item)) {
+      if (value !== undefined && value !== null) {
+        if (key === 'rids' && Array.isArray(value)) {
+          const roles: Role[] = [];
+          for (const id of value) {
+            const role = await this.dataSource.getRepository(Role).findOne({
+              where: {
+                id: id as number,
+              },
+            });
+            if (role) {
+              roles.push(role);
+            } else {
+              throw new Error(`roleId: ${value} doesn't exsist`);
+            }
+          }
+          m.roles = [...new Set([...(m?.roles ?? []), ...roles])];
+        } else {
+          m[key] = value;
+        }
+      }
+    }
+    await this.repo.save(m);
+  }
+}

package/template-admin-server/src/service/basic.ts

@@ -0,0 +1,118 @@
+/*
+ * @Author: zhangyang
+ * @Date: 2022-12-27 14:06:30
+ * @LastEditTime: 2022-12-27 14:21:40
+ * @Description:
+ */
+import { Logger } from '@midwayjs/decorator';
+import type { ILogger } from '@midwayjs/logger';
+import type { BaseCreate } from '../entities/BaseCreate';
+import type { Repository, DataSource } from 'typeorm';
+import { InjectDataSource } from '@midwayjs/typeorm';
+
+export class BasicService<U extends BaseCreate, T extends Partial<U> = Partial<U>> {
+  @Logger()
+  logger: ILogger;
+
+  @InjectDataSource()
+  dataSource: DataSource;
+
+  repo: Repository<U>;
+
+  async create(item: T) {
+    this.logger.error('create method must be implement ---', item);
+  }
+
+  async createBatch(items: T[]) {
+    let res: any = true;
+
+    const queryRunner = this.dataSource.createQueryRunner();
+    await queryRunner.connect();
+    await queryRunner.startTransaction();
+    try {
+      for (const item of items) {
+        await this.create(item);
+      }
+      await queryRunner.commitTransaction();
+    } catch (error) {
+      await queryRunner.rollbackTransaction();
+      res = error;
+    } finally {
+      await queryRunner.release();
+    }
+
+    if (res !== true) {
+      throw res;
+    }
+  }
+
+  async findOne(item: Partial<U>) {
+    const query = this.repo.createQueryBuilder();
+    query.select('*');
+    for (const [key, value] of Object.entries(item)) {
+      if (value) {
+        query.andWhere(`${key} = :value`, { value });
+      }
+    }
+    return query.getRawOne() as Promise<U | null>;
+  }
+
+  async findAll(item: Partial<U> & Paginition) {
+    const query = this.repo.createQueryBuilder();
+    query.select('*');
+    for (const [key, value] of Object.entries(item)) {
+      if (value) {
+        query.andWhere(`${key} = :value`, { value });
+      }
+    }
+    const pageNum = Number(item.pageNum) || 1;
+    const pageSize = Number(item.pageSize) || 10;
+    if (!item.noPagination) {
+      const page = pageNum;
+      const size = pageSize;
+
+      const skip = (page - 1) * size;
+
+      query.skip(skip);
+      query.take(size);
+    }
+
+    const total = await query.getCount();
+    const list = await query.getRawMany();
+
+    return {
+      pageNum,
+      pageSize,
+      total,
+      list,
+      noPagination: item.noPagination,
+    };
+  }
+
+  async delete(id: number) {
+    await this.repo.delete(id);
+  }
+
+  async deleteBatch(ids: number[]) {
+    const queryRunner = this.dataSource.createQueryRunner();
+    let res: any = true;
+
+    await queryRunner.connect();
+    await queryRunner.startTransaction();
+    try {
+      for (const id of ids) {
+        await this.delete(id);
+      }
+      await queryRunner.commitTransaction();
+    } catch (error) {
+      await queryRunner.rollbackTransaction();
+      res = error;
+    } finally {
+      await queryRunner.release();
+    }
+
+    if (res !== true) {
+      throw res;
+    }
+  }
+}

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

@@ -0,0 +1,10 @@
+/*
+ * @Author: zhangyang
+ * @Date: 2022-12-27 14:35:02
+ * @LastEditTime: 2022-12-27 14:35:02
+ * @Description:
+ */
+export * from './api.service';
+export * from './menu.service';
+export * from './role.service';
+export * from './user.service';

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

@@ -0,0 +1,139 @@
+/*
+ * @Author: zhangyang
+ * @Date: 2022-12-27 14:29:19
+ * @LastEditTime: 2022-12-27 16:49:39
+ * @Description:
+ */
+import { Provide } from '@midwayjs/decorator';
+import { InjectEntityModel } from '@midwayjs/typeorm';
+import type { Repository } from 'typeorm';
+import { Menu } from '../entities';
+import { BasicService } from './basic';
+
+export type CreateMenuItem = Partial<Menu> & { pid?: number };
+
+@Provide()
+export class MenuService extends BasicService<Menu, CreateMenuItem> {
+  @InjectEntityModel(Menu)
+  repo: Repository<Menu>;
+
+  async create(item: CreateMenuItem) {
+    const m = new Menu();
+    for (const [key, value] of Object.entries(item)) {
+      if (key === 'pid') {
+        if (value === 0) {
+          continue;
+        }
+        const p = await this.repo.findOne({ where: { id: value as number } });
+        if (p) {
+          m.parentId = p;
+        } else {
+          throw new Error(`parentId: ${value} doesn't exsist`);
+        }
+      } else {
+        m[key] = value;
+      }
+    }
+    await this.repo.save(m);
+  }
+
+  async update(id: number, item: CreateMenuItem) {
+    const m = await this.getById(id);
+    if (m) {
+      for (const [key, value] of Object.entries(item)) {
+        if (key === 'pid') {
+          if (value === undefined) {
+            continue;
+          }
+          if (value === 0) {
+            m.parentId = null;
+            continue;
+          }
+          const p = await this.repo.findOne({ where: { id: value as number } });
+          if (p) {
+            m.parentId = p;
+          } else {
+            throw new Error(`parentId: ${value} doesn't exsist`);
+          }
+        } else {
+          m[key] = value;
+        }
+      }
+      await this.repo.save(m);
+    } else {
+      throw new Error(`menuId: ${id}, 菜单不存在`);
+    }
+  }
+
+  async deleteBatch(ids: number[]) {
+    const queryRunner = this.dataSource.createQueryRunner();
+    let res: any = true;
+
+    await queryRunner.connect();
+    await queryRunner.startTransaction();
+    try {
+      for (const id of ids) {
+        const menu = await this.getById(id);
+
+        const childrenIds = menu.children?.map((i) => Number(i.id)) ?? [];
+
+        // 删除角色与菜单之间的关联
+        menu.roles = [];
+        menu.parentId = null;
+        // 断开 children 的关联
+        menu.children = [];
+        await this.repo.save(menu);
+
+        // 递归删除子节点
+        await this.deleteBatch(childrenIds);
+
+        await this.delete(id);
+      }
+      await queryRunner.commitTransaction();
+    } catch (error) {
+      await queryRunner.rollbackTransaction();
+      res = error;
+    } finally {
+      await queryRunner.release();
+    }
+
+    if (res !== true) {
+      throw res;
+    }
+  }
+
+  async getById(id: number) {
+    const m = await this.repo.findOne({
+      where: { id },
+      relations: ['roles', 'children', 'parentId'],
+    });
+    if (!m) {
+      throw new Error(`menuId: ${id} 不存在`);
+    }
+    return m;
+  }
+
+  async getAllTree() {
+    // 获取树形结构的数据
+    const menus = await this.dataSource.getTreeRepository(Menu).findTrees({
+      relations: ['children', 'parentId'],
+    });
+
+    // 设置 parentId
+    const setParentId = (item: Menu) => {
+      item.id = Number(item.id);
+      // @ts-expect-error
+      item.parentId = Number(item?.parentId?.id ?? 0);
+      if (item.children?.length) {
+        for (const i of item.children) {
+          setParentId(i);
+        }
+      }
+    };
+    for (const menu of menus) {
+      setParentId(menu);
+    }
+
+    return menus;
+  }
+}