feat(server): wip tax rate on sale invoice service

packages/server/src/services/TaxRates/ItemEntriesTaxTransactions.ts

@@ -0,0 +1,22 @@
+import { ItemEntry } from "@/models";
+import { sumBy } from "lodash";
+import { Service } from "typedi";
+
+
+@Service()
+export class ItemEntriesTaxTransactions {
+  /**
+   * 
+   * @param model 
+   * @returns 
+   */
+  public assocTaxAmountWithheldFromEntries(model: any) {
+    const entries = model.entries.map((entry) => ItemEntry.fromJson(entry));
+    const taxAmountWithheld = sumBy(entries, 'taxAmount');
+
+    if (taxAmountWithheld) {
+      model.taxAmountWithheld = taxAmountWithheld;
+    }
+    return model;
+  }
+}

packages/server/src/services/TaxRates/WriteTaxTransactionsItemEntries.ts

@@ -0,0 +1,65 @@
+import { sumBy, chain } from 'lodash';
+import { IItemEntry } from '@/interfaces';
+import HasTenancyService from '../Tenancy/TenancyService';
+import { Inject, Service } from 'typedi';
+
+@Service()
+export class WriteTaxTransactionsItemEntries {
+  @Inject()
+  private tenancy: HasTenancyService;
+
+  /**
+   * Writes the tax transactions from the given item entries.
+   * @param {number} tenantId
+   * @param {IItemEntry[]} itemEntries
+   */
+  public async writeTaxTransactionsFromItemEntries(
+    tenantId: number,
+    itemEntries: IItemEntry[]
+  ) {
+    const { TaxRateTransaction } = this.tenancy.models(tenantId);
+    const aggregatedEntries = this.aggregateItemEntriesByTaxCode(itemEntries);
+
+    const taxTransactions = aggregatedEntries.map((entry) => ({
+      taxName: 'TAX NAME',
+      taxCode: 'TAG_CODE',
+      referenceType: entry.referenceType,
+      referenceId: entry.referenceId,
+      taxAmount: entry.taxAmount,
+    }));
+    await TaxRateTransaction.query().upsertGraph(taxTransactions);
+  }
+
+  /**
+   * 
+   * @param {IItemEntry[]} itemEntries
+   * @returns {}
+   */
+  private aggregateItemEntriesByTaxCode(itemEntries: IItemEntry[]) {
+    return chain(itemEntries.filter((item) => item.taxCode))
+      .groupBy((item) => item.taxCode)
+      .values()
+      .map((group) => ({ ...group[0], amount: sumBy(group, 'amount') }))
+      .value();
+  }
+
+  /**
+   * 
+   * @param itemEntries
+   */
+  private aggregateItemEntriesByReferenceTypeId(itemEntries: IItemEntry) {}
+
+  /**
+   * Removes the tax transactions from the given item entries.
+   * @param tenantId
+   * @param itemEntries
+   */
+  public removeTaxTransactionsFromItemEntries(
+    tenantId: number,
+    itemEntries: IItemEntry[]
+  ) {
+    const { TaxRateTransaction } = this.tenancy.models(tenantId);
+
+    const filteredEntries = itemEntries.filter((item) => item.taxCode);
+  }
+}

packages/server/src/services/TaxRates/subscribers/WriteInvoiceTaxTransactionsSubscriber.ts

@@ -0,0 +1,56 @@
+import { Inject, Service } from 'typedi';
+import {
+  ISaleInvoiceCreatedPayload,
+  ISaleInvoiceDeletedPayload,
+} from '@/interfaces';
+import events from '@/subscribers/events';
+import { WriteTaxTransactionsItemEntries } from '../WriteTaxTransactionsItemEntries';
+
+@Service()
+export class WriteInvoiceTaxTransactionsSubscriber {
+  @Inject()
+  private writeTaxTransactions: WriteTaxTransactionsItemEntries;
+
+  /**
+   * Attaches events with handlers.
+   */
+  public attach(bus) {
+    bus.subscribe(
+      events.saleInvoice.onCreated,
+      this.writeInvoiceTaxTransactionsOnCreated
+    );
+    bus.subscribe(
+      events.saleInvoice.onDeleted,
+      this.removeInvoiceTaxTransactionsOnDeleted
+    );
+    return bus;
+  }
+
+  /**
+   * Validate receipt entries tax rate code existance.
+   * @param {ISaleInvoiceCreatingPaylaod}
+   */
+  private writeInvoiceTaxTransactionsOnCreated = async ({
+    tenantId,
+    saleInvoice,
+  }: ISaleInvoiceCreatedPayload) => {
+    await this.writeTaxTransactions.writeTaxTransactionsFromItemEntries(
+      tenantId,
+      saleInvoice.entries
+    );
+  };
+
+  /**
+   * Removes the invoice tax transactions on invoice deleted.
+   * @param {ISaleInvoiceEditingPayload}
+   */
+  private removeInvoiceTaxTransactionsOnDeleted = async ({
+    tenantId,
+    oldSaleInvoice,
+  }: ISaleInvoiceDeletedPayload) => {
+    await this.writeTaxTransactions.removeTaxTransactionsFromItemEntries(
+      tenantId,
+      oldSaleInvoice.entries
+    );
+  };
+}