bex-twn/src/industry-change-application/industry-change-application.service.ts

import {
  BadRequestException,
  Injectable,
  NotFoundException,
} from '@nestjs/common';
import { InjectModel } from '@nestjs/mongoose';
import { instanceToPlain, plainToInstance } from 'class-transformer';
import { Model } from 'mongoose';
import {
  ApplicationStatus,
  ObjectStatus,
  ResidentStatus,
} from 'src/enums/status.enum';
import { TypeOfRegistration } from 'src/enums/type-of-registration.enums';
import { ResidentService } from 'src/resident/resident.service';
import { takeMongoObject, equate, take } from 'src/utility';
import { ListQueryDto } from './dtos/list-query.dto';
import { RegisterIndustryChangeApplicationDto } from './dtos/register-industry-change-application.dto';
import {
  IndustryChangeApplication,
  IndustryChangeApplicationDocument,
} from './schemas/IndustryChangeApplication.schema';

const requestedFields = [
  'industry',
  'willWorkInPhysicalJurisdiction',
  'regulatoryElection',
  'regulatoryElectionSub',
];

@Injectable()
export class IndustryChangeApplicationService {
  constructor(
    @InjectModel(IndustryChangeApplication.name)
    private applicationModel: Model<IndustryChangeApplicationDocument>,
    private resident: ResidentService,
  ) {}

  async getAll(options: ListQueryDto) {
    const getResident = await this.resident.getResidentBySub(
      options.residentSub,
    );

    if (!getResident) {
      throw new NotFoundException('Resident not found');
    }

    return this.applicationModel
      .find({
        residentSub: options.residentSub,
        status: {
          $in: options.statuses || Object.values(ApplicationStatus),
        },
        objectStatus: ObjectStatus.CURRENT,
      })
      .exec();
  }

  async getById(id: string) {
    const find = await this.applicationModel.findById(id).exec();
    if (!find) {
      throw new NotFoundException('The application was not found');
    }

    if (find.objectStatus !== ObjectStatus.CURRENT) {
      throw new BadRequestException('This application has been deleted.');
    }

    return find;
  }

  async create(data: RegisterIndustryChangeApplicationDto, token: string) {
    // This might be possible to turn into a custom validator for class-validator
    if (
      data.willWorkInPhysicalJurisdiction === false &&
      (!!data.industry ||
        !!data.regulatoryElection ||
        !!data.regulatoryElectionSub)
    ) {
      throw new BadRequestException(
        'industry, regulatoryElection and regulatoryElectionSub are not allowed when willWorkInPhysicalJurisdiction is false',
      );
    }

    const getResident = await this.resident.getResidentBySub(data.residentSub);
    if (!getResident) {
      throw new BadRequestException('Resident not found');
    }

    if (getResident.status !== ResidentStatus.ACTIVE) {
      throw new BadRequestException('Resident must be active!');
    }

    if (
      ![TypeOfRegistration.E_RESIDENCY, TypeOfRegistration.RESIDENCY].includes(
        getResident.typeOfRegistration,
      )
    ) {
      throw new BadRequestException(
        'Resident must be either an E-resident or a resident',
      );
    }

    if (
      equate(data, getResident, requestedFields).length ===
      requestedFields.length
    ) {
      throw new BadRequestException('Cannot request what is already the case.');
    }

    const status =
      data.willWorkInPhysicalJurisdiction === true
        ? ApplicationStatus.IN_REVIEW
        : ApplicationStatus.APPROVED;

    const newApplication = new this.applicationModel({
      residentSub: getResident.sub,
      current: take(takeMongoObject(getResident), requestedFields),
      requested: take(data, requestedFields),
      status,
      decision:
        status === ApplicationStatus.APPROVED
          ? {
              decidedAt: new Date(),
              decidedBy: 'Automatic',
              rejectionReason: null,
            }
          : undefined,
      submittedAt: new Date(),
      createdBy: token ?? 'no token provided for testing',
    });

    if (status === ApplicationStatus.APPROVED) {
      getResident.willWorkInPhysicalJurisdiction =
        data.willWorkInPhysicalJurisdiction;
      getResident.industry = data.industry ?? null;
      getResident.regulatoryElection = data.regulatoryElection ?? null;
      getResident.regulatoryElectionSub = data.regulatoryElectionSub ?? null;
      await this.resident.save(getResident);
    }

    return newApplication.save();
  }

  async markDeleted(id: string, token: string) {
    const findApplication = await this.applicationModel.findById(id).exec();

    if (!findApplication) {
      throw new NotFoundException('Application was not found');
    }

    if (findApplication.status !== ApplicationStatus.IN_REVIEW) {
      throw new BadRequestException(
        'Only applications which are currently in review can be deleted.',
      );
    }

    if (findApplication.objectStatus === ObjectStatus.DELETED) {
      throw new BadRequestException('The object has already been deleted.');
    }

    findApplication.objectStatus = ObjectStatus.DELETED;
    findApplication.updatedBy = token || 'no token provided for testing';
    return findApplication.save();
  }

  makeReadable(input: IndustryChangeApplication | IndustryChangeApplication[]) {
    if (Array.isArray(input)) {
      return input.map((item) => this.makeReadable(item));
    }

    const response = plainToInstance(
      IndustryChangeApplication,
      (input as IndustryChangeApplicationDocument).toJSON(),
    );
    return instanceToPlain(response);
  }
}