technique_service/src/controller/system/role.controller.ts

import { Body, Controller, Del, Get, Inject, Param, Post, Query } from '@midwayjs/decorator';
import { BaseController } from 'free-midway-component';
import { RoleService } from '../../service/system/role.service';
import { CDTO_role, CVO_role, FVO_role, QDTO_role, QVO_role, UDTO_role, UVAO_role } from '../../interface/system/role.interface';
import { ApiResponse, ApiTags, ApiQuery } from '@midwayjs/swagger';
import { Validate } from '@midwayjs/validate';
import { MenusService } from '../../service/system/menus.service';
import { verifyToken } from '../../decorator/verifyToken.decorator';
import { checkPermissionCode } from '../../decorator/checkPermissionCode';
import { dataRecord } from '../../decorator/dataRecord';
@ApiTags(['角色表'])
@Controller('/role')
export class RoleController extends BaseController {
  @Inject()
  service: RoleService;
  @Inject()
  menusService: MenusService;

  @Post('/')
  @verifyToken()
  @Validate()
  @ApiResponse({ type: CVO_role })
  @dataRecord()
  async create(@Body() data: CDTO_role) {
    const dbData = await this.service.create(data);
    const result = new CVO_role(dbData);
    return result;
  }
  @Get('/')
  @verifyToken()
  @checkPermissionCode({ roleCode: 'system_role' })
  @ApiQuery({ name: 'query' })
  @ApiResponse({ type: QVO_role })
  async query(@Query() filter: QDTO_role, @Query('skip') skip: number, @Query('limit') limit: number) {
    const list = await this.service.query(filter, { skip, limit });
    const data = [];
    for (const i of list) {
      const newData = new QVO_role(i);
      data.push(newData);
    }
    const total = await this.service.count(filter);
    return { data, total };
  }

  @Get('/:id')
  @verifyToken()
  @ApiResponse({ type: FVO_role })
  async fetch(@Param('id') id: string) {
    const data = await this.service.fetch(id);
    const result = new FVO_role(data);
    return result;
  }

  @Post('/:id')
  @verifyToken()
  @checkPermissionCode({ roleCode: 'system_role.update' })
  @Validate()
  @ApiResponse({ type: UVAO_role })
  @dataRecord()
  async update(@Param('id') id: string, @Body() body: UDTO_role) {
    const result = await this.service.updateOne(id, body);
    return result;
  }

  @Del('/:id')
  @verifyToken()
  @Validate()
  @dataRecord()
  async delete(@Param('id') id: string) {
    await this.service.delete(id);
    return 'ok';
  }
  async createMany(...args: any[]) {
    throw new Error('Method not implemented.');
  }

  async updateMany(...args: any[]) {
    throw new Error('Method not implemented.');
  }

  async deleteMany(...args: any[]) {
    throw new Error('Method not implemented.');
  }
}