ppob-backend/src/users/partner/partner.service.ts

import {
  forwardRef,
  HttpException,
  HttpStatus,
  Inject,
  Injectable,
} from '@nestjs/common';
import { InjectRepository } from '@nestjs/typeorm';
import { Connection, EntityNotFoundError, Not, Repository } from 'typeorm';
import { CoaService } from '../../transaction/coa.service';
import { CreatePartnerDto } from '../dto/create-partner.dto';
import { Partner } from '../entities/partner.entity';
import * as uuid from 'uuid';
import { UsersService } from '../users.service';
import { CreateUserDto } from '../dto/create-user.dto';
import { UpdatePartnerDto } from '../dto/update-partner.dto';
import { UpdateUserDto } from '../dto/update-user.dto';
import { when } from 'joi';

@Injectable()
export class PartnerService {
  constructor(
    @InjectRepository(Partner)
    private partnerRepository: Repository<Partner>,
    @Inject(
      forwardRef(() => {
        return CoaService;
      }),
    )
    private coaService: CoaService,
    private userService: UsersService,
    private connection: Connection,
  ) {}

  async create(createPartnerDto: CreatePartnerDto, currentUser: any) {
    const check = await this.partnerRepository.findOne({
      npwp: createPartnerDto.npwp,
    });

    if (check) {
      throw new HttpException(
        {
          statusCode: HttpStatus.NOT_ACCEPTABLE,
          error: 'NPWP Already Exist',
        },
        HttpStatus.NOT_FOUND,
      );
    }

    const partnerData = new Partner();

    partnerData.id = uuid.v4();
    partnerData.name = createPartnerDto.name;
    partnerData.npwp = createPartnerDto.npwp;
    partnerData.address = createPartnerDto.address;
    partnerData.code = createPartnerDto.code;
    partnerData.status = true;

    await this.connection.transaction(async (manager) => {
      const result = await manager.insert(Partner, partnerData);
    });

    const dataUser = new CreateUserDto();

    dataUser.username = `admin_${partnerData.code}`;
    dataUser.name = partnerData.name;
    dataUser.phone_number = partnerData.phone_number;
    dataUser.roleId = '21dceea2-416e-4b55-b74c-12605e1f8d1b';
    dataUser.superior = false;
    dataUser.partner = partnerData;
    dataUser.password = createPartnerDto.password_account;
    dataUser.phone_number = createPartnerDto.phone_number;

    await this.userService.create(dataUser, currentUser);

    return partnerData;
  }

  async update(
    id: string,
    updatePartnerDto: UpdatePartnerDto,
    currentUser: any,
  ) {
    const check = await this.partnerRepository.findOne({
      npwp: updatePartnerDto.npwp,
      id: Not(id),
    });

    if (check) {
      throw new HttpException(
        {
          statusCode: HttpStatus.NOT_ACCEPTABLE,
          error: 'NPWP Already Exist',
        },
        HttpStatus.NOT_FOUND,
      );
    }

    const partnerData = new Partner();

    partnerData.id = id;
    partnerData.name = updatePartnerDto.name;
    partnerData.address = updatePartnerDto.address;

    if (updatePartnerDto.npwp) {
      partnerData.npwp = updatePartnerDto.npwp;
    }

    await this.connection.transaction(async (manager) => {
      await manager.update(Partner, { id: id }, partnerData);
    });

    const dataUser = new UpdateUserDto();
    const userData = await this.userService.findOneByPartner(id);

    dataUser.username = `admin_${partnerData.name}`;
    dataUser.partner = partnerData;

    await this.userService.update(userData.id, dataUser, currentUser);

    return partnerData;
  }

  setStatus = async (id: string, type: string) => {
    const partnerData = await this.partnerRepository.findOne({
      id: id,
    });

    if (type === 'active') {
      partnerData.status = true;
    } else {
      partnerData.status = false;
    }

    await this.connection.transaction(async (manager) => {
      await manager.update(Partner, { id: id }, partnerData);
    });

    return partnerData;
  };

  async findOne(code: string) {
    return await this.partnerRepository.findOne({
      where: {
        code: code,
      },
    });
  }

  findAllPartner(page, pageSize?) {
    return this.partnerRepository.findAndCount({
      skip: page * (pageSize || 10),
      take: pageSize || 10,
      order: {
        version: 'DESC',
      },
    });
  }
}