src/api/controllers/GroupController.ts - develop - h0tnanny/IotPlatform

src/api/controllers/GroupController.ts
234 строки7 KB
h0tnanny
fix группы пользователей
02 фев 2026, 00:29
02 фев 2026, 00:29fd8c2cf
import { Response } from 'express';
import { GroupRepository } from '../../repositories/GroupRepository';
import { AuthRequest } from '../../middleware/auth';

export class GroupController {
  private readonly groupRepo: GroupRepository;

  constructor() {
    this.groupRepo = new GroupRepository();
  }

  /**
   * POST /groups — создать группу
   */
  create = async (req: AuthRequest, res: Response): Promise<void> => {
    const { name, description, default_share_permission } = req.body;

    if (!name || name.trim().length === 0) {
      res.status(400).json({
        error: { code: 'VALIDATION_ERROR', message: 'Название группы обязательно' },
      });
      return;
    }

    const perm =
      default_share_permission && ['viewer', 'editor'].includes(default_share_permission)
        ? default_share_permission
        : 'viewer';
    const group = await this.groupRepo.create(name, description || null, req.user!.userId, perm);

    res.status(201).json({ data: group });
  };

  /**
   * GET /groups — мои группы
   */
  getAll = async (req: AuthRequest, res: Response): Promise<void> => {
    let groups;
    if (req.user!.role === 'admin') {
      groups = await this.groupRepo.findAll();
    } else {
      groups = await this.groupRepo.findUserGroups(req.user!.userId);
    }

    // Загружаем участников для каждой группы
    const result = await Promise.all(
      groups.map(async (group) => {
        const members = await this.groupRepo.getMembers(group.id);
        return { ...group, members };
      })
    );

    res.json({ data: result });
  };

  /**
   * PUT /groups/:id — обновить группу
   */
  update = async (req: AuthRequest, res: Response): Promise<void> => {
    const { id } = req.params;
    const { name, description, default_share_permission } = req.body;

    const group = await this.groupRepo.findById(id);
    if (!group) {
      res.status(404).json({
        error: { code: 'NOT_FOUND', message: 'Группа не найдена' },
      });
      return;
    }

    if (group.owner_id !== req.user!.userId && req.user!.role !== 'admin') {
      res.status(403).json({
        error: { code: 'FORBIDDEN', message: 'Нет прав для редактирования группы' },
      });
      return;
    }

    const newPerm =
      default_share_permission && ['viewer', 'editor'].includes(default_share_permission)
        ? default_share_permission
        : undefined;
    const updated = await this.groupRepo.update(
      id,
      name ?? group.name,
      description !== undefined ? description : group.description,
      newPerm
    );

    res.json({ data: updated });
  };

  /**
   * DELETE /groups/:id — удалить группу
   */
  delete = async (req: AuthRequest, res: Response): Promise<void> => {
    const { id } = req.params;

    const group = await this.groupRepo.findById(id);
    if (!group) {
      res.status(404).json({
        error: { code: 'NOT_FOUND', message: 'Группа не найдена' },
      });
      return;
    }

    if (group.owner_id !== req.user!.userId && req.user!.role !== 'admin') {
      res.status(403).json({
        error: { code: 'FORBIDDEN', message: 'Нет прав для удаления группы' },
      });
      return;
    }

    await this.groupRepo.delete(id);
    res.json({ data: { message: 'Группа удалена' } });
  };

  /**
   * POST /groups/:id/members — добавить участника
   */
  addMember = async (req: AuthRequest, res: Response): Promise<void> => {
    const { id } = req.params;
    const { userId, role } = req.body;

    if (!userId) {
      res.status(400).json({
        error: { code: 'VALIDATION_ERROR', message: 'userId обязателен' },
      });
      return;
    }

    const group = await this.groupRepo.findById(id);
    if (!group) {
      res.status(404).json({
        error: { code: 'NOT_FOUND', message: 'Группа не найдена' },
      });
      return;
    }

    if (group.owner_id !== req.user!.userId && req.user!.role !== 'admin') {
      res.status(403).json({
        error: { code: 'FORBIDDEN', message: 'Нет прав для управления участниками' },
      });
      return;
    }

    const memberRole = role && ['viewer', 'editor'].includes(role) ? role : 'viewer';
    const member = await this.groupRepo.addMember(id, userId, memberRole);

    res.status(201).json({ data: member });
  };

  /**
   * DELETE /groups/:id/members/:userId — удалить участника
   */
  removeMember = async (req: AuthRequest, res: Response): Promise<void> => {
    const { id, userId } = req.params;

    const group = await this.groupRepo.findById(id);
    if (!group) {
      res.status(404).json({
        error: { code: 'NOT_FOUND', message: 'Группа не найдена' },
      });
      return;
    }

    if (group.owner_id !== req.user!.userId && req.user!.role !== 'admin') {
      res.status(403).json({
        error: { code: 'FORBIDDEN', message: 'Нет прав для управления участниками' },
      });
      return;
    }

    await this.groupRepo.removeMember(id, userId);
    res.json({ data: { message: 'Участник удалён из группы' } });
  };

  /**
   * PUT /groups/:id/members/:userId — изменить роль участника
   */
  updateMemberRole = async (req: AuthRequest, res: Response): Promise<void> => {
    const { id, userId } = req.params;
    const { role } = req.body;

    if (!role || !['viewer', 'editor'].includes(role)) {
      res.status(400).json({
        error: { code: 'VALIDATION_ERROR', message: 'Роль должна быть "viewer" или "editor"' },
      });
      return;
    }

    const group = await this.groupRepo.findById(id);
    if (!group) {
      res.status(404).json({
        error: { code: 'NOT_FOUND', message: 'Группа не найдена' },
      });
      return;
    }

    if (group.owner_id !== req.user!.userId && req.user!.role !== 'admin') {
      res.status(403).json({
        error: { code: 'FORBIDDEN', message: 'Нет прав для управления участниками' },
      });
      return;
    }

    const member = await this.groupRepo.updateMemberRole(id, userId, role);
    if (!member) {
      res.status(404).json({
        error: { code: 'NOT_FOUND', message: 'Участник не найден в группе' },
      });
      return;
    }

    res.json({ data: member });
  };

  /**
   * GET /groups/:id/members — получить участников группы
   */
  getMembers = async (req: AuthRequest, res: Response): Promise<void> => {
    const { id } = req.params;

    const group = await this.groupRepo.findById(id);
    if (!group) {
      res.status(404).json({
        error: { code: 'NOT_FOUND', message: 'Группа не найдена' },
      });
      return;
    }

    const members = await this.groupRepo.getMembers(id);
    res.json({ data: members });
  };
}