fairnesscoop / permacoop

import {CommandHandler} from '@nestjs/cqrs';

import {Inject} from '@nestjs/common';

import {AddEventCommand} from './AddEventCommand';

import {ITaskRepository} from 'src/Domain/Task/Repository/ITaskRepository';

import {IProjectRepository} from 'src/Domain/Project/Repository/IProjectRepository';

import {IEventRepository} from 'src/Domain/FairCalendar/Repository/IEventRepository';

import {ProjectNotFoundException} from 'src/Domain/Project/Exception/ProjectNotFoundException';

import {TaskNotFoundException} from 'src/Domain/Task/Exception/TaskNotFoundException';

import {IsMaximumTimeSpentReached} from 'src/Domain/FairCalendar/Specification/IsMaximumTimeSpentReached';

import {Event, EventType} from 'src/Domain/FairCalendar/Event.entity';

import {MaximumEventReachedException} from 'src/Domain/FairCalendar/Exception/MaximumEventReachedException';

import {IDateUtils} from 'src/Application/IDateUtils';

import {Task} from 'src/Domain/Task/Task.entity';

import {Project} from 'src/Domain/Project/Project.entity';

import {ProjectOrTaskMissingException} from 'src/Domain/FairCalendar/Exception/ProjectOrTaskMissingException';

@CommandHandler(AddEventCommand)

export class AddEventCommandHandler {

  constructor(

    @Inject('ITaskRepository')

    private readonly taskRepository: ITaskRepository,

    @Inject('IProjectRepository')

    private readonly projectRepository: IProjectRepository,

    @Inject('IEventRepository')

    private readonly eventRepository: IEventRepository,

    @Inject('IDateUtils')

    private readonly dateUtils: IDateUtils,

    private readonly isMaximumTimeSpentReached: IsMaximumTimeSpentReached

  ) {}

  public async execute(command: AddEventCommand): Promise<string> {

    const {type, date, projectId, taskId, summary, time, user} = command;

    if (type === EventType.MISSION && (!projectId || !taskId)) {

      throw new ProjectOrTaskMissingException();

    }

    const project = await this.getProject(projectId);

    const task = await this.getTask(taskId);

    const event = new Event(

      type,

      user,

      time,

      this.dateUtils.format(date, 'y-MM-dd'),

      project,

      task,

      summary

    );

    if (true === (await this.isMaximumTimeSpentReached.isSatisfiedBy(event))) {

      throw new MaximumEventReachedException();

    }

    const savedEvent = await this.eventRepository.save(event);

    return savedEvent.getId();

  }

  private async getTask(taskId?: string): Promise<Task | null> {

    if (!taskId) {

      return null;

    }

    const task = await this.taskRepository.findOneById(taskId);

    if (!task) {

      throw new TaskNotFoundException();

    }

    return task;

  }

  private async getProject(projectId?: string): Promise<Project | null> {

    if (!projectId) {

      return null;

    }

    const project = await this.projectRepository.findOneById(projectId);

    if (!project) {

      throw new ProjectNotFoundException();

    }

    return project;

  }

}