organizations.service.ts

import { Injectable, Logger, InternalServerErrorException, NotFoundException, ForbiddenException } from '@nestjs/common';
import { Organization } from './organization.entity';
import { InjectRepository } from '@nestjs/typeorm';
import { LinksService } from '../links/links.service';
import { OrganizationsRO, OrganizationDTO } from './organization.dto';
import { OrganizationRepository } from './organization.repository';
import * as uuidv4 from 'uuid/v4';
import { ConfigService } from '../configuration/config.service';

@Injectable()
export class OrganizationsService {

  private logger: Logger;

  constructor(
    @InjectRepository(Organization)
    private organizationRepository: OrganizationRepository,
    private linksService: LinksService,
    private _configService: ConfigService,
  ) {
    this.logger = new Logger(OrganizationsService.name);
  }

  async findAll(userGroups, query): Promise<OrganizationsRO> {
    try {
      this.logger.log('Entering function', `${OrganizationsService.name} - ${this.findAll.name}`);

      const qb = await this.organizationRepository
        .createQueryBuilder('organization')
        .leftJoinAndSelect('organization.links', 'links');

      const [key, value] = query.q ? query.q.split(':') : [null, null];

      // Only admin can see drafts
      if (!userGroups || !userGroups.includes(this._configService.config.groupNames.admin)) {
        qb.where(`organization.published = true`);
        key && value ? qb.andWhere(`organization.${key} = :value`, { value }) : null;
      } else {
        key && value ? qb.where(`organization.${key} = :value`, { value }) : null;
      }

      // Sorting
      if ('sort_by' in query) {
        const sort = query.sort_by ? query.sort_by.split('.') : ['name', 'ASC'];
        sort[1] = sort[1].toUpperCase();
        qb.orderBy('organization.' + sort[0], sort[1]);
      }

      const organizationsCount = await qb.getCount().catch((error) => {
        this.logger.error(`Error while getting the count of organizations.`, `${error}`, `${OrganizationsService.name} - ${this.findAll.name}`);
        throw new InternalServerErrorException({ error, message: 'Error while getting the count of organizations.' });
      });

      if ('limit' in query) {
        qb.limit(query.limit);
      }

      if ('offset' in query) {
        qb.offset(query.offset);
      }

      const organizations = await qb.getMany().catch((error) => {
        this.logger.error(`Error while getting the list of organizations.`, `${error}`, `${OrganizationsService.name} - ${this.findAll.name}`);
        throw new InternalServerErrorException({ error, message: 'Error while getting the list of organizations.' });
      });

      return { organizations, organizationsCount };
    } catch (error) {
      throw error;
    }
  }

  async findOne(userGroups, id) {
    try {
      this.logger.log('Entering function', `${OrganizationsService.name} - ${this.findOne.name}`);

      const organization = await this.organizationRepository.findOne(id).catch((error) => {
        this.logger.error(`Error while looking the organization with id ${id}.`, `${error}`, `${OrganizationsService.name} - ${this.findOne.name}`);
        throw new InternalServerErrorException({ error, message: 'Error while looking the organization with id ${id}.' });
      });

      if (!organization) {
        throw new NotFoundException({ message: 'No organization with such id have been found' });
      }

      // Only admin can see an unpublished data producer
      if ((!userGroups || !userGroups.includes(this._configService.config.groupNames.admin)) && organization.published === false) {
        throw new ForbiddenException({ message: 'You don\'t have access to this data producer' });
      }

      return organization;
    } catch (error) {
      throw error;
    }
  }

  async findLinks(userGroups, id) {
    try {
      this.logger.log('Entering function', `${OrganizationsService.name} - ${this.findLinks.name}`);

      const organization = await this.organizationRepository.findOne(id).catch((error) => {
        this.logger.error(
          `Error while looking for the link of the organization with id ${id}.`, `${error}`, `${OrganizationsService.name} - ${this.findLinks.name}`,
        );
        throw new InternalServerErrorException({ error, message: 'Error while looking for the link of the organization with id ${id}.' });
      });

      if (!organization) {
        throw new NotFoundException({ message: 'No organization with such id have been found' });
      }

      // Only admin can see an unpublished data producer
      if ((!userGroups || !userGroups.includes(this._configService.config.groupNames.admin)) && organization.published === false) {
        throw new ForbiddenException({ message: 'You don\'t have access to this data producer' });
      }

      return organization.links;
    } catch (error) {
      throw error;
    }
  }

  async create(organization: OrganizationDTO) {
    try {
      this.logger.log('Entering function', `${OrganizationsService.name} - ${this.create.name}`);

      // cf https://github.com/typeorm/typeorm/issues/2924#issuecomment-430265476
      const organizationEntity = Object.assign(new Organization(), organization);
      organizationEntity.id = uuidv4();

      organizationEntity.links.forEach((link) => {
        if (!link.id) {
          link.id = uuidv4();
        }
      });

      const organizationCreated = await this.organizationRepository.save(organizationEntity).catch((error) => {
        this.logger.error(`Error saving the organization into the database.`, `${error}`, `${OrganizationsService.name} - ${this.create.name}`);
        throw new InternalServerErrorException({ error, message: 'Error saving the organization into the database.' });
      });

      this.logger.log('Organization created:', `${OrganizationsService.name} - ${this.findAll.name}`);
      this.logger.log(organizationCreated, `${OrganizationsService.name} - ${this.findAll.name}`);

      return organizationCreated;
    } catch (error) {
      this.logger.error('Failed to create the organization.', `${error}`, `${OrganizationsService.name} - ${this.create.name}`);
      throw error;
    }
  }

  async update(id, organization: OrganizationDTO) {
    try {
      this.logger.log('Entering function', `${OrganizationsService.name} - ${this.update.name}`);

      const toUpdate = await this.organizationRepository.findOne(id).catch((error) => {
        this.logger.error(`Error while looking for the organization with the id ${id}.`, `${error}`, `${OrganizationsService.name} - ${this.update.name}`);
        throw new InternalServerErrorException({ error, message: 'Error while looking for the organization.' });
      });

      if (!toUpdate) {
        throw new NotFoundException({ message: 'No item exists with the given id' });
      }

      const updated = Object.assign(toUpdate, organization);
      updated.links.forEach((link) => {
        if (!link.id) {
          link.id = uuidv4();
        }
      });

      const saved = await this.organizationRepository.save(updated).catch((error) => {
        this.logger.error(`Error while updating the organization.`, `${error}`, `${OrganizationsService.name} - ${this.update.name}`);
        throw new InternalServerErrorException({ error, message: 'Error while updating the organization.' });
      });

      this.linksService.deleteOrphans();

      return saved;
    } catch (error) {
      throw error;
    }
  }

  async delete(id): Promise<any> {
    try {
      this.logger.log('Entering function', `${OrganizationsService.name} - ${this.delete.name}`);

      const toDelete = await this.organizationRepository.findOne(id).catch((error) => {
        this.logger.error(`Error while looking the organization with id ${id}.`, `${error}`, `${OrganizationsService.name} - ${this.delete.name}`);
        throw new InternalServerErrorException({ error, message: 'Error while looking the organization with id ${id}.' });
      });

      if (!toDelete) {
        throw new NotFoundException({ message: 'No organization exists with the given id' });
      }

      return await this.organizationRepository.delete(id).catch((error) => {
        this.logger.error(`Error while deleting the organization with id ${id}.`, `${error}`, `${OrganizationsService.name} - ${this.delete.name}`);
        throw new InternalServerErrorException({ error, message: 'Error while deleting the organization with id ${id}.' });
      });
    } catch (error) {
      throw error;
    }
  }
}