keyvault/api/src/modules/system/system.service.ts

import { HttpException, HttpStatus, Injectable } from '@nestjs/common';
import { CreateSystemDto } from './dto/create-system.dto';
import { UpdateSystemDto } from './dto/update-system.dto';
import { KeySystemRepository, UserRepository } from 'src/model/repositories';
import { User } from 'src/model/entitites';
import { MailService } from '../mail/mail.service';
import { ConfigService } from '@nestjs/config';
import { ActivityHelperService } from 'src/shared/service/activity.logger.service';
import { IsNull, Not } from 'typeorm';

@Injectable()
export class SystemService {
  constructor(
    private systemRepo: KeySystemRepository,
    private userRepo: UserRepository,
    private mailService: MailService,
    private readonly configService: ConfigService,
    private readonly activityService: ActivityHelperService
    ) {}
  
  get isDevelopMode(): boolean {
    return (this.configService.get('DEVELOP_MODE') || '').toLowerCase() == 'true';
  }

  async create(user: User, createSystemDto: CreateSystemDto) {
    const sys = this.systemRepo.create(createSystemDto);
    sys.managers = [user];
    try {
      const res = await this.systemRepo.save(sys);      
      return res;
    } catch (e) {
      throw new HttpException(e.code, HttpStatus.UNPROCESSABLE_ENTITY);
    }
  }

  async findAll(user: User) {
    let systems = await this.systemRepo.find({
      where: { managers: { id: user.id } },
      order: { name: { direction: 'ASC' } },
      relations: ['cylinders']
    });

    if (this.isDevelopMode) {
      systems = systems.filter(s => s.name.toLocaleLowerCase().includes('develop'));
    }

    return systems;
  }

  async findDeleted(user: User) {
    let systems = await this.systemRepo.find({
      where: { managers: { id: user.id }, deletedAt: Not(IsNull()) },
      order: { name: { direction: 'ASC' } },
      withDeleted: true,
    });

    if (this.isDevelopMode) {
      systems = systems.filter(s => s.name.toLocaleLowerCase().includes('develop'));
    }

    return systems;
  }

  findOne(id: string) {
    return this.systemRepo.findOne({ where: { id: id } });
  }

  async update(user: User, updateSystemDto: UpdateSystemDto) {
    if (!user || !user.id || !updateSystemDto.id) { throw new HttpException('forbidden', HttpStatus.FORBIDDEN); }
    const system = await this.systemRepo.findOne({ where: { id: updateSystemDto.id, managers: { id: user.id } }, withDeleted: true });

    if (!system) { throw new HttpException('forbidden', HttpStatus.FORBIDDEN); }


    if (system.name !== updateSystemDto.name) {
      await this.activityService.logSystemRenamed({ system, newName: updateSystemDto.name, user })
      system.name = updateSystemDto.name;
      
    }

    return true;
  }

  async remove(id: string) {
    const system = await this.systemRepo.findOne({ where: { id } });
    return this.systemRepo.softRemove(system);
  }

  async getManagers(id: string) {
    const system = await this.systemRepo.findOne({
      where: { id: id },
      relations: ['managers']
    });

    return system.managers;
  }

  async manageManagers(systemID: string, manageObject: { email: string, action: 'add' | 'remove'}) {
    const sys = await this.systemRepo.findOne({
      where: { id: systemID },
      relations: ['managers']
    });

    if (!sys) {
      throw new HttpException('Das System wurde nicht im System gefunden', HttpStatus.NOT_FOUND);
    }

    if (manageObject.action == 'remove') {
      sys.managers = sys.managers.filter( m => m.username != manageObject.email);

      await this.systemRepo.save(sys);
      const user = await this.userRepo.findOne({
        where: { username: manageObject.email.trim() },
        relations: ['settings']
      });
      if (user.settings.sendSystemAccessMails) {
        this.mailService.sendAccessRemovedMail({to: user, system: sys})
      }
      return sys.managers;
    }

    if (sys.managers.some(m => m.username == manageObject.email)) {
      return sys.managers;
    }

    const user = await this.userRepo.findOne({
      where: { username: manageObject.email.trim() },
      relations: ['settings']
    });
    if (!user) {
      throw new HttpException('Es wurde kein User mit dieser Emailadresse gefunden. Bitte prüfe die Emailadresse und versuche es erneut.', HttpStatus.NOT_FOUND);
    }

    sys.managers.push(user);
    await this.systemRepo.save(sys);
    if (user.settings.sendSystemAccessMails) {
      this.mailService.sendAccessGrantedMail({to: user, system: sys})
    }
    return sys.managers;

  }

  async restore(user: User, id: string) {
    const key = await this.systemRepo.findOneOrFail({
      where: { id: id, managers: { id: user.id } },
      withDeleted: true,
    });
    key.deletedAt = null;
    // await this.activityService.logKeyRestored(user, key);
    // await this.helper.deleteKeyArchiveCache();
    return this.systemRepo.save(key);
  }
}