feat(nestjs): migrate to NestJS

packages/server/src/modules/Branches/subscribers/Validators/BillBranchSubscriber.ts

@@ -0,0 +1,39 @@
+import { Injectable } from '@nestjs/common';
+import { OnEvent } from '@nestjs/event-emitter';
+import { events } from '@/common/events/events';
+import { ValidateBranchExistance } from '../../Integrations/ValidateBranchExistance';
+import {
+  IBillCreatingPayload,
+  IBillEditingPayload,
+} from '@/modules/Bills/Bills.types';
+
+@Injectable()
+export class BillBranchValidateSubscriber {
+  constructor(
+    private readonly validateBranchExistance: ValidateBranchExistance,
+  ) {}
+
+  /**
+   * Validate branch existance on bill creating.
+   * @param {IBillCreatingPayload} payload
+   */
+  @OnEvent(events.bill.onCreating)
+  async validateBranchExistanceOnBillCreating({
+    billDTO,
+  }: IBillCreatingPayload) {
+    await this.validateBranchExistance.validateTransactionBranchWhenActive(
+      billDTO.branchId,
+    );
+  }
+
+  /**
+   * Validate branch existance once bill editing.
+   * @param {IBillEditingPayload} payload
+   */
+  @OnEvent(events.bill.onEditing)
+  async validateBranchExistanceOnBillEditing({ billDTO }: IBillEditingPayload) {
+    await this.validateBranchExistance.validateTransactionBranchWhenActive(
+      billDTO.branchId,
+    );
+  }
+}

packages/server/src/modules/Branches/subscribers/Validators/CashflowBranchDTOValidatorSubscriber.ts

@@ -0,0 +1,25 @@
+import { Injectable } from '@nestjs/common';
+import { OnEvent } from '@nestjs/event-emitter';
+import { events } from '@/common/events/events';
+import { ValidateBranchExistance } from '../../Integrations/ValidateBranchExistance';
+import { ICommandCashflowCreatingPayload } from '@/modules/BankingTransactions/types/BankingTransactions.types';
+
+@Injectable()
+export class CashflowBranchDTOValidatorSubscriber {
+  constructor(
+    private readonly validateBranchExistance: ValidateBranchExistance,
+  ) {}
+
+  /**
+   * Validate branch existance once cashflow transaction creating.
+   * @param {ICommandCashflowCreatingPayload} payload
+   */
+  @OnEvent(events.cashflow.onTransactionCreating)
+  async validateBranchExistanceOnCashflowTransactionCreating({
+    newTransactionDTO,
+  }: ICommandCashflowCreatingPayload) {
+    await this.validateBranchExistance.validateTransactionBranchWhenActive(
+      newTransactionDTO.branchId,
+    );
+  }
+}

packages/server/src/modules/Branches/subscribers/Validators/ContactOpeningBalanceBranchSubscriber.ts

@@ -0,0 +1,81 @@
+import { Injectable } from '@nestjs/common';
+import { OnEvent } from '@nestjs/event-emitter';
+import { events } from '@/common/events/events';
+import { ValidateBranchExistance } from '../../Integrations/ValidateBranchExistance';
+import {
+  ICustomerOpeningBalanceEditingPayload,
+  ICustomerEventCreatingPayload,
+} from '@/modules/Customers/types/Customers.types';
+import {
+  IVendorEventCreatingPayload,
+  IVendorOpeningBalanceEditingPayload,
+} from '@/modules/Vendors/types/Vendors.types';
+
+@Injectable()
+export class ContactBranchValidateSubscriber {
+  constructor(
+    private readonly validateBranchExistance: ValidateBranchExistance,
+  ) {}
+
+  /**
+   * Validate branch existance on customer creating.
+   * @param {ICustomerEventCreatingPayload} payload
+   */
+  @OnEvent(events.customers.onCreating)
+  async validateBranchExistanceOnCustomerCreating({
+    customerDTO,
+  }: ICustomerEventCreatingPayload) {
+    // Can't continue if the customer opening balance is zero.
+    if (!customerDTO.openingBalance) return;
+
+    await this.validateBranchExistance.validateTransactionBranchWhenActive(
+      customerDTO.openingBalanceBranchId,
+    );
+  }
+
+  /**
+   * Validate branch existance once customer opening balance editing.
+   * @param {ICustomerOpeningBalanceEditingPayload} payload
+   */
+  @OnEvent(events.customers.onOpeningBalanceChanging)
+  async validateBranchExistanceOnCustomerOpeningBalanceEditing({
+    openingBalanceEditDTO,
+  }: ICustomerOpeningBalanceEditingPayload) {
+    if (!openingBalanceEditDTO.openingBalance) return;
+
+    await this.validateBranchExistance.validateTransactionBranchWhenActive(
+      openingBalanceEditDTO.openingBalanceBranchId,
+    );
+  }
+
+  /**
+   * Validates the branch existance on vendor creating.
+   * @param {IVendorEventCreatingPayload} payload
+   */
+  @OnEvent(events.vendors.onCreating)
+  async validateBranchExistanceonVendorCreating({
+    vendorDTO,
+  }: IVendorEventCreatingPayload) {
+    // Can't continue if the customer opening balance is zero.
+    if (!vendorDTO.openingBalance) return;
+
+    await this.validateBranchExistance.validateTransactionBranchWhenActive(
+      vendorDTO.openingBalanceBranchId,
+    );
+  }
+
+  /**
+   * Validate branch existance once the vendor opening balance editing.
+   * @param {IVendorOpeningBalanceEditingPayload} payload
+   */
+  @OnEvent(events.vendors.onOpeningBalanceChanging)
+  async validateBranchExistanceOnVendorOpeningBalanceEditing({
+    openingBalanceEditDTO,
+  }: IVendorOpeningBalanceEditingPayload) {
+    if (!openingBalanceEditDTO.openingBalance) return;
+
+    await this.validateBranchExistance.validateTransactionBranchWhenActive(
+      openingBalanceEditDTO.openingBalanceBranchId,
+    );
+  }
+}

packages/server/src/modules/Branches/subscribers/Validators/CreditNoteBranchesSubscriber.ts

@@ -0,0 +1,39 @@
+import { Injectable } from '@nestjs/common';
+import { OnEvent } from '@nestjs/event-emitter';
+import { events } from '@/common/events/events';
+import { ValidateBranchExistance } from '../../Integrations/ValidateBranchExistance';
+import { ICreditNoteEditingPayload } from '@/modules/CreditNotes/types/CreditNotes.types';
+import { ICreditNoteCreatingPayload } from '@/modules/CreditNotes/types/CreditNotes.types';
+
+@Injectable()
+export class CreditNoteBranchValidateSubscriber {
+  constructor(
+    private readonly validateBranchExistance: ValidateBranchExistance,
+  ) {}
+
+  /**
+   * Validate branch existance on credit note creating.
+   * @param {ICreditNoteCreatingPayload} payload
+   */
+  @OnEvent(events.creditNote.onCreating)
+  async validateBranchExistanceOnCreditCreating({
+    creditNoteDTO,
+  }: ICreditNoteCreatingPayload) {
+    await this.validateBranchExistance.validateTransactionBranchWhenActive(
+      creditNoteDTO.branchId,
+    );
+  }
+
+  /**
+   * Validate branch existance once credit note editing.
+   * @param {ICreditNoteEditingPayload} payload
+   */
+  @OnEvent(events.creditNote.onEditing)
+  async validateBranchExistanceOnCreditEditing({
+    creditNoteEditDTO,
+  }: ICreditNoteEditingPayload) {
+    await this.validateBranchExistance.validateTransactionBranchWhenActive(
+      creditNoteEditDTO.branchId,
+    );
+  }
+}

packages/server/src/modules/Branches/subscribers/Validators/CreditNoteRefundBranchSubscriber.ts

@@ -0,0 +1,25 @@
+import { Injectable } from '@nestjs/common';
+import { OnEvent } from '@nestjs/event-emitter';
+import { ValidateBranchExistance } from '../../Integrations/ValidateBranchExistance';
+import { events } from '@/common/events/events';
+import { IRefundCreditNoteCreatingPayload } from '@/modules/CreditNoteRefunds/types/CreditNoteRefunds.types';
+
+@Injectable()
+export class CreditNoteRefundBranchValidateSubscriber {
+  constructor(
+    private readonly validateBranchExistance: ValidateBranchExistance
+  ) {}
+
+  /**
+   * Validate branch existance on refund credit note creating.
+   * @param {IRefundCreditNoteCreatingPayload} payload
+   */
+  @OnEvent(events.creditNote.onRefundCreating)
+  async validateBranchExistanceOnCreditRefundCreating({
+    newCreditNoteDTO,
+  }: IRefundCreditNoteCreatingPayload) {
+    await this.validateBranchExistance.validateTransactionBranchWhenActive(
+      newCreditNoteDTO.branchId
+    );
+  }
+}

packages/server/src/modules/Branches/subscribers/Validators/ExpenseBranchSubscriber.ts

@@ -0,0 +1,40 @@
+import { Injectable } from '@nestjs/common';
+import { OnEvent } from '@nestjs/event-emitter';
+import { events } from '@/common/events/events';
+import { ValidateBranchExistance } from '../../Integrations/ValidateBranchExistance';
+import {
+  IExpenseCreatingPayload,
+  IExpenseEventEditingPayload,
+} from '@/modules/Expenses/Expenses.types';
+@Injectable()
+export class ExpenseBranchValidateSubscriber {
+  constructor(
+    private readonly validateBranchExistance: ValidateBranchExistance,
+  ) {}
+
+  /**
+   * Validate branch existance once expense transaction creating.
+   * @param {IExpenseCreatingPayload} payload
+   */
+  @OnEvent(events.expenses.onCreating)
+  async validateBranchExistanceOnExpenseCreating({
+    expenseDTO,
+  }: IExpenseCreatingPayload) {
+    await this.validateBranchExistance.validateTransactionBranchWhenActive(
+      expenseDTO.branchId,
+    );
+  }
+
+  /**
+   * Validate branch existance once expense transaction editing.
+   * @param {IExpenseEventEditingPayload} payload
+   */
+  @OnEvent(events.expenses.onEditing)
+  async validateBranchExistanceOnExpenseEditing({
+    expenseDTO,
+  }: IExpenseEventEditingPayload) {
+    await this.validateBranchExistance.validateTransactionBranchWhenActive(
+      expenseDTO.branchId,
+    );
+  }
+}

packages/server/src/modules/Branches/subscribers/Validators/InventoryAdjustmentBranchValidatorSubscriber.ts

@@ -0,0 +1,25 @@
+import { Injectable } from '@nestjs/common';
+import { OnEvent } from '@nestjs/event-emitter';
+import { events } from '@/common/events/events';
+import { ValidateBranchExistance } from '../../Integrations/ValidateBranchExistance';
+import { IInventoryAdjustmentCreatingPayload } from '@/modules/InventoryAdjutments/types/InventoryAdjustments.types';
+
+@Injectable()
+export class InventoryAdjustmentBranchValidateSubscriber {
+  constructor(
+    private readonly validateBranchExistance: ValidateBranchExistance,
+  ) {}
+
+  /**
+   * Validate branch existance on inventory adjustment creating.
+   * @param {IInventoryAdjustmentCreatingPayload} payload
+   */
+  @OnEvent(events.inventoryAdjustment.onQuickCreating)
+  async validateBranchExistanceOnInventoryCreating({
+    quickAdjustmentDTO,
+  }: IInventoryAdjustmentCreatingPayload) {
+    await this.validateBranchExistance.validateTransactionBranchWhenActive(
+      quickAdjustmentDTO.branchId,
+    );
+  }
+}

packages/server/src/modules/Branches/subscribers/Validators/InvoiceBranchValidatorSubscriber.ts

@@ -0,0 +1,41 @@
+import { Injectable } from '@nestjs/common';
+import { OnEvent } from '@nestjs/event-emitter';
+import { events } from '@/common/events/events';
+import { ValidateBranchExistance } from '../../Integrations/ValidateBranchExistance';
+import {
+  ISaleInvoiceCreatingPaylaod,
+  ISaleInvoiceEditingPayload,
+} from '@/modules/SaleInvoices/SaleInvoice.types';
+
+@Injectable()
+export class InvoiceBranchValidateSubscriber {
+  constructor(
+    private readonly validateBranchExistance: ValidateBranchExistance,
+  ) {}
+
+  /**
+   * Validate branch existance on invoice creating.
+   * @param {ISaleInvoiceCreatingPayload} payload
+   */
+  @OnEvent(events.saleInvoice.onCreating)
+  async validateBranchExistanceOnInvoiceCreating({
+    saleInvoiceDTO,
+  }: ISaleInvoiceCreatingPaylaod) {
+    await this.validateBranchExistance.validateTransactionBranchWhenActive(
+      saleInvoiceDTO.branchId,
+    );
+  }
+
+  /**
+   * Validate branch existance once invoice editing.
+   * @param {ISaleInvoiceEditingPayload} payload
+   */
+  @OnEvent(events.saleInvoice.onEditing)
+  async validateBranchExistanceOnInvoiceEditing({
+    saleInvoiceDTO,
+  }: ISaleInvoiceEditingPayload) {
+    await this.validateBranchExistance.validateTransactionBranchWhenActive(
+      saleInvoiceDTO.branchId,
+    );
+  }
+}

packages/server/src/modules/Branches/subscribers/Validators/ManualJournalBranchSubscriber.ts

@@ -0,0 +1,60 @@
+
+import {
+  IManualJournalCreatingPayload,
+  IManualJournalEditingPayload,
+} from '@/modules/ManualJournals/types/ManualJournals.types';
+import { ManualJournalBranchesValidator } from '../../Integrations/ManualJournals/ManualJournalsBranchesValidator';
+import { OnEvent } from '@nestjs/event-emitter';
+import { Injectable } from '@nestjs/common';
+import { events } from '@/common/events/events';
+import { Features } from '@/common/types/Features';
+import { FeaturesManager } from '../../../Features/FeaturesManager';
+
+@Injectable()
+export class ManualJournalBranchValidateSubscriber {
+  constructor(
+    private readonly validateManualJournalBranch: ManualJournalBranchesValidator,
+    private readonly featuresManager: FeaturesManager,
+  ) {}
+
+  /**
+   * Validate branch existance on estimate creating.
+   * @param {IManualJournalCreatingPayload} payload
+   */
+  @OnEvent(events.manualJournals.onCreating)
+  async validateBranchExistanceOnBillCreating({
+    manualJournalDTO,
+  }: IManualJournalCreatingPayload) {
+    // Detarmines whether the multi-branches is accessible by tenant.
+    const isAccessible = await this.featuresManager.accessible(
+      Features.BRANCHES
+    );
+    // Can't continue if the multi-branches feature is inactive.
+    if (!isAccessible) return;
+
+    // Validates the entries whether have branch id.
+    await this.validateManualJournalBranch.validateEntriesHasBranchId(
+      manualJournalDTO
+    );
+  };
+
+  /**
+   * Validate branch existance once estimate editing.
+   * @param {ISaleEstimateEditingPayload} payload
+   */
+  @OnEvent(events.manualJournals.onEditing)
+  async validateBranchExistanceOnBillEditing({
+    manualJournalDTO,
+  }: IManualJournalEditingPayload) {
+    // Detarmines whether the multi-branches is accessible by tenant.
+    const isAccessible = await this.featuresManager.accessible(
+      Features.BRANCHES
+    );
+    // Can't continue if the multi-branches feature is inactive.
+    if (!isAccessible) return;
+
+    await this.validateManualJournalBranch.validateEntriesHasBranchId(
+      manualJournalDTO
+    );
+  };
+}

packages/server/src/modules/Branches/subscribers/Validators/PaymentMadeBranchSubscriber.ts

@@ -0,0 +1,41 @@
+import { OnEvent } from '@nestjs/event-emitter';
+import { Injectable } from '@nestjs/common';
+import {
+  IBillPaymentCreatingPayload,
+  IBillPaymentEditingPayload,
+} from '@/modules/BillPayments/types/BillPayments.types';
+import { ValidateBranchExistance } from '../../Integrations/ValidateBranchExistance';
+import { events } from '@/common/events/events';
+
+@Injectable()
+export class PaymentMadeBranchValidateSubscriber {
+  constructor(
+    private readonly validateBranchExistance: ValidateBranchExistance,
+  ) {}
+
+  /**
+   * Validate branch existance on estimate creating.
+   * @param {ISaleEstimateCreatedPayload} payload
+   */
+  @OnEvent(events.billPayment.onCreating)
+  async validateBranchExistanceOnPaymentCreating({
+    billPaymentDTO,
+  }: IBillPaymentCreatingPayload) {
+    await this.validateBranchExistance.validateTransactionBranchWhenActive(
+      billPaymentDTO.branchId,
+    );
+  }
+
+  /**
+   * Validate branch existance once estimate editing.
+   * @param {ISaleEstimateEditingPayload} payload
+   */
+  @OnEvent(events.billPayment.onEditing)
+  async validateBranchExistanceOnPaymentEditing({
+    billPaymentDTO,
+  }: IBillPaymentEditingPayload) {
+    await this.validateBranchExistance.validateTransactionBranchWhenActive(
+      billPaymentDTO.branchId,
+    );
+  }
+}

packages/server/src/modules/Branches/subscribers/Validators/PaymentReceiveBranchSubscriber.ts

@@ -0,0 +1,41 @@
+import {
+  IPaymentReceivedCreatingPayload,
+  IPaymentReceivedEditingPayload,
+} from '@/modules/PaymentReceived/types/PaymentReceived.types';
+import { ValidateBranchExistance } from '../../Integrations/ValidateBranchExistance';
+import { OnEvent } from '@nestjs/event-emitter';
+import { Injectable } from '@nestjs/common';
+import { events } from '@/common/events/events';
+
+@Injectable()
+export class PaymentReceiveBranchValidateSubscriber {
+  constructor(
+    private readonly validateBranchExistance: ValidateBranchExistance,
+  ) {}
+
+  /**
+   * Validate branch existance on estimate creating.
+   * @param {IPaymentReceivedCreatingPayload} payload
+   */
+  @OnEvent(events.paymentReceive.onCreating)
+  async validateBranchExistanceOnPaymentCreating({
+    paymentReceiveDTO,
+  }: IPaymentReceivedCreatingPayload) {
+    await this.validateBranchExistance.validateTransactionBranchWhenActive(
+      paymentReceiveDTO.branchId,
+    );
+  }
+
+  /**
+   * Validate branch existance once estimate editing.
+   * @param {IPaymentReceivedEditingPayload} payload
+   */
+  @OnEvent(events.paymentReceive.onEditing)
+  async validateBranchExistanceOnPaymentEditing({
+    paymentReceiveDTO,
+  }: IPaymentReceivedEditingPayload) {
+    await this.validateBranchExistance.validateTransactionBranchWhenActive(
+      paymentReceiveDTO.branchId,
+    );
+  }
+}

packages/server/src/modules/Branches/subscribers/Validators/SaleEstimateMultiBranchesSubscriber.ts

@@ -0,0 +1,41 @@
+import { OnEvent } from '@nestjs/event-emitter';
+import { Injectable } from '@nestjs/common';
+import { events } from '@/common/events/events';
+import {
+  ISaleEstimateCreatingPayload,
+  ISaleEstimateEditingPayload,
+} from '@/modules/SaleEstimates/types/SaleEstimates.types';
+import { ValidateBranchExistance } from '../../Integrations/ValidateBranchExistance';
+
+@Injectable()
+export class SaleEstimateBranchValidateSubscriber {
+  constructor(
+    private readonly validateBranchExistance: ValidateBranchExistance,
+  ) {}
+
+  /**
+   * Validate branch existance on estimate creating.
+   * @param {ISaleEstimateCreatedPayload} payload
+   */
+  @OnEvent(events.saleEstimate.onCreating)
+  async validateBranchExistanceOnEstimateCreating({
+    estimateDTO,
+  }: ISaleEstimateCreatingPayload) {
+    await this.validateBranchExistance.validateTransactionBranchWhenActive(
+      estimateDTO.branchId,
+    );
+  }
+
+  /**
+   * Validate branch existance once estimate editing.
+   * @param {ISaleEstimateEditingPayload} payload
+   */
+  @OnEvent(events.saleEstimate.onEditing)
+  async validateBranchExistanceOnEstimateEditing({
+    estimateDTO,
+  }: ISaleEstimateEditingPayload) {
+    await this.validateBranchExistance.validateTransactionBranchWhenActive(
+      estimateDTO.branchId,
+    );
+  }
+}

packages/server/src/modules/Branches/subscribers/Validators/SaleReceiptBranchesSubscriber.ts

@@ -0,0 +1,41 @@
+import {
+  ISaleReceiptCreatingPayload,
+  ISaleReceiptEditingPayload,
+} from '@/modules/SaleReceipts/types/SaleReceipts.types';
+import { ValidateBranchExistance } from '../../Integrations/ValidateBranchExistance';
+import { OnEvent } from '@nestjs/event-emitter';
+import { Injectable } from '@nestjs/common';
+import { events } from '@/common/events/events';
+
+@Injectable()
+export class SaleReceiptBranchValidateSubscriber {
+  constructor(
+    private readonly validateBranchExistance: ValidateBranchExistance,
+  ) {}
+
+  /**
+   * Validate branch existance on estimate creating.
+   * @param {ISaleReceiptCreatingPayload} payload
+   */
+  @OnEvent(events.saleReceipt.onCreating)
+  async validateBranchExistanceOnInvoiceCreating({
+    saleReceiptDTO,
+  }: ISaleReceiptCreatingPayload) {
+    await this.validateBranchExistance.validateTransactionBranchWhenActive(
+      saleReceiptDTO.branchId,
+    );
+  }
+
+  /**
+   * Validate branch existance once estimate editing.
+   * @param {ISaleReceiptEditingPayload} payload
+   */
+  @OnEvent(events.saleReceipt.onEditing)
+  async validateBranchExistanceOnInvoiceEditing({
+    saleReceiptDTO,
+  }: ISaleReceiptEditingPayload) {
+    await this.validateBranchExistance.validateTransactionBranchWhenActive(
+      saleReceiptDTO.branchId,
+    );
+  }
+}

packages/server/src/modules/Branches/subscribers/Validators/VendorCreditBranchSubscriber.ts

@@ -0,0 +1,41 @@
+import {
+  IVendorCreditCreatingPayload,
+  IVendorCreditEditingPayload,
+} from '@/modules/VendorCredit/types/VendorCredit.types';
+import { ValidateBranchExistance } from '../../Integrations/ValidateBranchExistance';
+import { OnEvent } from '@nestjs/event-emitter';
+import { Injectable } from '@nestjs/common';
+import { events } from '@/common/events/events';
+
+@Injectable()
+export class VendorCreditBranchValidateSubscriber {
+  constructor(
+    private readonly validateBranchExistance: ValidateBranchExistance,
+  ) {}
+
+  /**
+   * Validate branch existance on estimate creating.
+   * @param {ISaleEstimateCreatedPayload} payload
+   */
+  @OnEvent(events.vendorCredit.onCreating)
+  async validateBranchExistanceOnCreditCreating({
+    vendorCreditCreateDTO,
+  }: IVendorCreditCreatingPayload) {
+    await this.validateBranchExistance.validateTransactionBranchWhenActive(
+      vendorCreditCreateDTO.branchId,
+    );
+  }
+
+  /**
+   * Validate branch existance once estimate editing.
+   * @param {ISaleEstimateEditingPayload} payload
+   */
+  @OnEvent(events.vendorCredit.onEditing)
+  async validateBranchExistanceOnCreditEditing({
+    vendorCreditDTO,
+  }: IVendorCreditEditingPayload) {
+    await this.validateBranchExistance.validateTransactionBranchWhenActive(
+      vendorCreditDTO.branchId,
+    );
+  }
+}

packages/server/src/modules/Branches/subscribers/Validators/VendorCreditRefundBranchSubscriber.ts

@@ -0,0 +1,25 @@
+import { ValidateBranchExistance } from '../../Integrations/ValidateBranchExistance';
+import { OnEvent } from '@nestjs/event-emitter';
+import { Injectable } from '@nestjs/common';
+import { events } from '@/common/events/events';
+import { IRefundVendorCreditCreatingPayload } from '@/modules/VendorCreditsRefund/types/VendorCreditRefund.types';
+
+@Injectable()
+export class VendorCreditRefundBranchValidateSubscriber {
+  constructor(
+    private readonly validateBranchExistance: ValidateBranchExistance,
+  ) {}
+
+  /**
+   * Validate branch existance on refund credit note creating.
+   * @param {IRefundVendorCreditCreatingPayload} payload
+   */
+  @OnEvent(events.vendorCredit.onRefundCreating)
+  async validateBranchExistanceOnCreditRefundCreating({
+    refundVendorCreditDTO,
+  }: IRefundVendorCreditCreatingPayload) {
+    await this.validateBranchExistance.validateTransactionBranchWhenActive(
+      refundVendorCreditDTO.branchId,
+    );
+  }
+}