add:partner module

src/users/supplier/supplier.service.spec.ts

@@ -0,0 +1,18 @@
+import { Test, TestingModule } from '@nestjs/testing';
+import { SupplierService } from './supplier.service';
+
+describe('PartnerService', () => {
+  let service: SupplierService;
+
+  beforeEach(async () => {
+    const module: TestingModule = await Test.createTestingModule({
+      providers: [SupplierService],
+    }).compile();
+
+    service = module.get<SupplierService>(SupplierService);
+  });
+
+  it('should be defined', () => {
+    expect(service).toBeDefined();
+  });
+});

src/users/supplier/supplier.service.ts

@@ -0,0 +1,116 @@
+import {
+  forwardRef,
+  HttpException,
+  HttpStatus,
+  Inject,
+  Injectable,
+} from '@nestjs/common';
+import { InjectRepository } from '@nestjs/typeorm';
+import { Connection, EntityNotFoundError, Repository } from 'typeorm';
+import { Supplier } from '../entities/supplier.entity';
+import { InputCoaDto } from '../../transaction/dto/input-coa.dto';
+import { balanceType, coaType } from '../../helper/enum-list';
+import { CreateSupplierDto } from '../dto/create-supplier.dto';
+import { CoaService } from '../../transaction/coa.service';
+import * as uuid from 'uuid';
+
+@Injectable()
+export class SupplierService {
+  constructor(
+    @InjectRepository(Supplier)
+    private supplierRepository: Repository<Supplier>,
+    @Inject(
+      forwardRef(() => {
+        return CoaService;
+      }),
+    )
+    private coaService: CoaService,
+    private connection: Connection,
+  ) {}
+
+  async create(createSupplierDto: CreateSupplierDto) {
+    const check = await this.supplierRepository.findOne({
+      code: createSupplierDto.code,
+    });
+
+    if (check) {
+      throw new HttpException(
+        {
+          statusCode: HttpStatus.NOT_ACCEPTABLE,
+          error: 'Supplier Already Exist',
+        },
+        HttpStatus.NOT_FOUND,
+      );
+    }
+
+    const supplierData = new Supplier();
+    supplierData.id = uuid.v4();
+    supplierData.name = createSupplierDto.name;
+    supplierData.code = createSupplierDto.code;
+    supplierData.status = true;
+
+    await this.connection.transaction(async (manager) => {
+      const result = await manager.insert(Supplier, supplierData);
+
+      const dataCoaInventory = new InputCoaDto();
+      dataCoaInventory.supplier = supplierData;
+      dataCoaInventory.balanceType = balanceType.DEBIT;
+      dataCoaInventory.type = coaType.INVENTORY;
+      dataCoaInventory.coaEntityManager = manager;
+      await this.coaService.create(dataCoaInventory);
+
+      const dataCoaCostOfSales = new InputCoaDto();
+      dataCoaCostOfSales.supplier = supplierData;
+      dataCoaCostOfSales.balanceType = balanceType.DEBIT;
+      dataCoaCostOfSales.type = coaType.COST_OF_SALES;
+      dataCoaCostOfSales.coaEntityManager = manager;
+      await this.coaService.create(dataCoaCostOfSales);
+
+      const dataCoaBudget = new InputCoaDto();
+      dataCoaBudget.supplier = supplierData;
+      dataCoaBudget.balanceType = balanceType.DEBIT;
+      dataCoaBudget.type = coaType.BUDGET;
+      dataCoaBudget.coaEntityManager = manager;
+      await this.coaService.create(dataCoaBudget);
+
+      const dataCoaContraBudget = new InputCoaDto();
+      dataCoaContraBudget.supplier = supplierData;
+      dataCoaContraBudget.balanceType = balanceType.CREDIT;
+      dataCoaContraBudget.type = coaType.CONTRA_BUDGET;
+      dataCoaContraBudget.coaEntityManager = manager;
+      await this.coaService.create(dataCoaContraBudget);
+    });
+
+    return supplierData;
+  }
+
+  findAllSupplier(page) {
+    return this.supplierRepository.findAndCount({
+      skip: page * 10,
+      take: 10,
+      order: {
+        version: 'DESC',
+      },
+    });
+  }
+
+  async findByCode(code: string) {
+    try {
+      return await this.supplierRepository.findOneOrFail({
+        code: code,
+      });
+    } catch (e) {
+      if (e instanceof EntityNotFoundError) {
+        throw new HttpException(
+          {
+            statusCode: HttpStatus.NOT_FOUND,
+            error: 'Data not found',
+          },
+          HttpStatus.NOT_FOUND,
+        );
+      } else {
+        throw e;
+      }
+    }
+  }
+}