src/core/groups/groups.service.ts - develop - andreas300000/webpinger-backend

src/core/groups/groups.service.ts
154 строки4 KB
ILYA Loginov
Groups: add fields for frontend
16 май 2025, 20:01
16 май 2025, 20:011305e16
import { BadRequestException, Injectable, NotFoundException } from '@nestjs/common';
import { CreateGroupDto } from './dto/create-group.dto';
import { UpdateGroupDto } from './dto/update-group.dto';
import { GroupResponse } from './entities/group.entity';
import { PrismaService } from 'src/database/prisma.service';


@Injectable()
export class GroupsService {
  constructor(private prisma: PrismaService) { }


  async create(createGroupDto: CreateGroupDto) {
    const { name, description, user_id } = createGroupDto
    console.log("user_id=", user_id);

    const existingRights = await this.prisma.groups.findMany({
      where: { id: { in: user_id } }
    })
    if (existingRights.length !== user_id.length) {
      throw new BadRequestException('Invalid Users IDs detected');
    }

    const newGroup = await this.prisma.groups.create({ data: { name, description } })
    const group_id = newGroup.id
    // Работаем со связями только если передан group_id
    if (user_id) {
      console.log("user_id = ", user_id)
      await this.prisma.$transaction([
        // Создаем новые связи (если есть) 
        ...(user_id.length > 0
          ? [this.prisma.usersGroups.createMany({
            data: user_id.map(uid => ({
              group_id: group_id,
              user_id: uid
            })),
            skipDuplicates: true
          })]
          : [])
      ]);
    }
    return newGroup
  }

  // async findAll(): Promise<Group[]> {
  //   const groups = await this.prisma.groups.findMany({ include: { users_groups: true } })
  //   return groups
  // }

  async findAll(): Promise<GroupResponse[]> {
    const groups = await this.prisma.groups.findMany({
      include: {
        users_groups: {
          include: {
            users: {
              select: {
                id: true,
                // Комбинируем ФИО из отдельных полей или используем full_name
                username: true,
                first_name: true,
                family_name: true,
                last_name: true
              }
            }
          }
        }
      }
    });
    return groups.map(group => ({
      id: group.id.toString(),
      name: group.name,
      description: group.description,
      users: group.users_groups.map(ug => ({
        id: ug.users.id.toString(),
        name:
          [ug.users.family_name, ug.users.first_name, ug.users.last_name]
            .filter(Boolean).join(' ') ||
          'Без имени'
      }))
    }));
  }

  async findOne(id: number) {
    const group = await this.prisma.groups.findUnique({
      where: { id },
      include: {
        users_groups: {
          select: {
            user_id: true
          }
        }
      }
    })
    if (!group) {
      throw new NotFoundException(`Group with ID "${id}" not found`)
    }
    return {
      id: group.id,
      name: group.name,
      description: group.description,
      user_id: group.users_groups.map(ug => ug.user_id)
    };
  }

  async update(id: number, updateGroupDto: UpdateGroupDto) {
    // Проверяем существование роли
    await this.findOne(id);

    // Обновляем базовые поля роли
    await this.prisma.groups.update({
      where: { id },
      data: {
        name: updateGroupDto.name,
        description: updateGroupDto.description
      }
    });

    const existingRights = await this.prisma.groups.findMany({
      where: { id: { in: updateGroupDto.user_id } }
    })

    if (existingRights.length !== updateGroupDto.user_id.length) {
      throw new BadRequestException('Invalid Right IDs detected');
    }


    // Работаем со связями только если передан group_id
    if (updateGroupDto.user_id) {
      await this.prisma.$transaction([
        // Удаляем старые связи
        this.prisma.usersGroups.deleteMany({ where: { group_id: id } }),

        // Создаем новые связи (если есть)
        ...(updateGroupDto.user_id.length > 0
          ? [this.prisma.usersGroups.createMany({
            data: updateGroupDto.user_id.map(user_id => ({
              group_id: id,
              user_id: user_id
            })),
            skipDuplicates: true
          })]
          : [])
      ]);
    }

    return this.findOne(id)
  }

  async remove(id: number) {
    const role = await this.findOne(id)
    await this.prisma.groups.delete({ where: { id } })
    return role
  }
}