21.服务端实战用户服务开发下

import { Body, Controller, Post } from '@nestjs/common';
import { ApiOperation, ApiTags } from '@nestjs/swagger';
import { BusinessException } from '@app/common';
import {
  CreateSystemDto,
  DeleteSystemDto,
  UpdateSystemDto,
} from './system.dto';
import { SystemService } from './system.service';
import { PayloadUser } from '@app/common';

@ApiTags('系统')
@Controller('system')
export class SystemController {
  constructor(private readonly systemService: SystemService) { }

  @ApiOperation({
    summary: '创建新系统',
  })
  @Post('create')
  create(@Body() dto: CreateSystemDto, @PayloadUser() user: Payload) {
    return this.systemService.create({
      ...dto,
      creatorName: user.name,
      creatorId: user.userId,
      updateName: user.name,
      updateId: user.userId,
    });
  }

  @ApiOperation({
    summary: '修改系统信息',
  })
  @Post('update')
  async update(@Body() dto: UpdateSystemDto, @PayloadUser() user: Payload) {
    const foundSystem = await this.systemService.findById(dto.id);

    if (!foundSystem) {
      throw new BusinessException('未找到系统');
    }

    return await this.systemService.update({
      ...foundSystem,
      ...dto,
      updateName: user.name,
      updateId: user.userId,
    });
  }

  @ApiOperation({
    summary: '删除系统',
  })
  @Post('/delete')
  async delete(@Body() dto: DeleteSystemDto) {
    return await this.systemService.delete(dto.id);
  }

  @ApiOperation({
    summary: '所有系统列表',
  })
  @Post('/list')
  async list() {
    return await this.systemService.list();
  }
}

import { Body, Controller, Post } from '@nestjs/common';
import { ApiOperation, ApiTags } from '@nestjs/swagger';
import { BusinessException } from '@app/common';
import {
  CreateResourceDto,
  DeleteResourceDto,
  ListBySystemIdDto,
  ListWithPaginationDto,
  UpdateResourceDto,
} from './resource.dto';
import { ResourceService } from './resource.service';
import { SystemService } from '../system/system.service';
import { PrivilegeService } from '../privilege/privilege.service';

@Controller('resource')
@ApiTags('资源')
export class ResourceController {
  constructor(
    private readonly resourceService: ResourceService,
    private readonly systemService: SystemService,
    private readonly privilegeService: PrivilegeService,
  ) { }

  @ApiOperation({
    summary: '创建新资源',
  })
  @Post('create')
  async create(@Body() dto: CreateResourceDto) {
    const foundResource = await this.resourceService.findByKey(dto.key);

    if (foundResource) {
      throw new BusinessException('资源 Key 已存在');
    }

    return await this.resourceService.create(dto);
  }

  @ApiOperation({
    summary: '修改资源信息',
  })
  @Post('update')
  async update(@Body() dto: UpdateResourceDto) {
    const foundResource = await this.resourceService.findById(dto.id);

    if (!foundResource) {
      throw new BusinessException('未找到资源');
    }
    const allowUpdateFields = {
      name: dto.name,
      description: dto.description,
    };

    return await this.resourceService.update({
      ...foundResource,
      ...allowUpdateFields,
    });
  }

  @ApiOperation({
    summary: '删除资源',
    description: '',
  })
  @Post('/delete')
  async delete(@Body() dto: DeleteResourceDto) {
    return await this.resourceService.delete(dto.id);
  }

  @ApiOperation({
    summary: '资源列表',
    description: '根据角色名称查询',
  })
  @Post('/list/paginate')
  async list(@Body() dto: ListWithPaginationDto) {
    const { page, ...searchParams } = dto;
    const rourceData = await this.resourceService.paginate(searchParams, page);
    const systemIds = rourceData.items.map((role) => role.systemId);
    const systemList = await this.systemService.findByIds(systemIds);
    const systemMap = {};
    systemList.forEach((system) => (systemMap[system.id] = system));
    const newRource = rourceData.items.map((role) => {
      role['systemName'] = systemMap[role.systemId].name;
      return role;
    });
    return { ...rourceData, items: newRource };
  }

  @ApiOperation({
    summary: '资源列表',
    description: '根据系统 id 查询',
  })
  @Post('/listBySystemId')
  async listBySystemId(@Body() dto: ListBySystemIdDto) {
    const resourceList = await this.resourceService.listBySystemId(
      dto.systemId,
    );
    const newResource = [];

    for (const resource of resourceList) {
      const privileges = await this.privilegeService.listByResourceKey(
        resource.key,
      );
      newResource.push({
        ...resource,
        privileges,
      });
    }
    return newResource;
  }
}

import { Body, Controller, Post } from '@nestjs/common';
import { ApiOperation, ApiTags } from '@nestjs/swagger';
import { BusinessException, PayloadUser } from '@app/common';
import { PrivilegeService } from '../privilege/privilege.service';
import { RolePrivilegeService } from '../role-privilege/role-privilege.service';
import { SystemService } from '../system/system.service';
import {
  CreateRoleDto,
  DeleteRoleDto,
  GetPrivilegeListByIdDto,
  RoleListDto,
  RoleListWithPaginationDto,
  RolePrivilegeSetDto,
  UpdateRoleDto,
} from './role.dto';
import { RoleService } from './role.service';

@Controller('role')
@ApiTags('角色')
export class RoleController {
  constructor(
    private readonly roleService: RoleService,
    private readonly rolePrivilegeService: RolePrivilegeService,
    private readonly privilegeService: PrivilegeService,
    private readonly systemService: SystemService,
  ) { }

  @ApiOperation({
    summary: '创建新角色',
  })
  @Post('create')
  async create(
    @Body() createRoleDto: CreateRoleDto,
    @PayloadUser() user: Payload,
  ) {
    const system = await this.systemService.findById(createRoleDto.systemId);
    return this.roleService.create({
      ...createRoleDto,
      systemName: system.name,
      creatorName: user.name,
      creatorId: user.userId,
      updateName: user.name,
      updateId: user.userId,
    });
  }

  @ApiOperation({
    summary: '修改角色信息',
  })
  @Post('update')
  async update(@Body() dto: UpdateRoleDto, @PayloadUser() user: Payload) {
    const foundRole = await this.roleService.findById(dto.id);
    if (!foundRole) {
      throw new BusinessException('未找到角色');
    }
    return await this.roleService.update({
      ...foundRole,
      ...dto,
      updateName: user.name,
      updateId: user.userId,
    });
  }

  @ApiOperation({
    summary: '删除角色',
    description:
      '如果发现角色有绑定权限，权限将同步删除 Role - privilege 关系表',
  })
  @Post('/delete')
  async delete(@Body() dto: DeleteRoleDto) {
    return await this.roleService.delete(dto.id);
  }

  @ApiOperation({
    summary: '角色 ID 查权限',
    description: '根据角色 id 查权限列表',
  })
  @Post('/getPrivilegeListById')
  async getPrivilegeListById(@Body() dto: GetPrivilegeListByIdDto) {
    const rolePrivilegeList = await this.rolePrivilegeService.listByRoleIds([
      dto.roleId,
    ]);
    const privilegeList = await this.privilegeService.findByIds(
      rolePrivilegeList.map((rp) => rp.privilegeId),
    );
    return privilegeList;
  }

  @ApiOperation({
    summary: '角色列表（分页）',
    description: '根据角色名称查询',
  })
  @Post('/list/pagination')
  async listWithPagination(@Body() dto: RoleListWithPaginationDto) {
    const { page, ...searchParams } = dto;
    const pageData = await this.roleService.paginate(searchParams, page);
    const systemIds = pageData.items.map((role) => role.systemId);
    const systemList = await this.systemService.findByIds(systemIds);
    const systemMap = {};
    systemList.forEach((system) => (systemMap[system.id] = system));
    const newRoles = pageData.items.map((role) => {
      role['systemName'] = systemMap[role.systemId].name;
      return role;
    });
    return { ...pageData, items: newRoles };
  }

  @ApiOperation({
    summary: 'tree 形状角色列表',
    description: '系统级别树状',
  })
  @Post('/list/withSystem')
  async listWithSys() {
    const newSys = [];
    const systemList = await this.systemService.list();
    for (const sys of systemList) {
      const roles = await this.roleService.listWithSys(sys.id);
      newSys.push({
        ...sys,
        roles,
      });
    }
    return newSys;
  }

  @ApiOperation({
    summary: '角色分配权限',
    description: '',
  })
  @Post('set')
  async set(@Body() dto: RolePrivilegeSetDto) {
    await this.rolePrivilegeService.remove(dto.roleId);
    return await this.rolePrivilegeService.set(
      dto.roleId,
      dto.privilegeIds,
      dto.systemId,
    );
  }
}