add server to monorepo.

packages/server/src/services/FinancialStatements/SalesByItems/SalesByItems.ts

@@ -0,0 +1,174 @@
+import { get, sumBy } from 'lodash';
+import * as R from 'ramda';
+import FinancialSheet from '../FinancialSheet';
+import { allPassedConditionsPass, transformToMap } from 'utils';
+import {
+  ISalesByItemsReportQuery,
+  IAccountTransaction,
+  ISalesByItemsItem,
+  ISalesByItemsTotal,
+  ISalesByItemsSheetStatement,
+  IItem,
+} from '@/interfaces';
+
+export default class SalesByItemsReport extends FinancialSheet {
+  readonly baseCurrency: string;
+  readonly items: IItem[];
+  readonly itemsTransactions: Map<number, IAccountTransaction>;
+  readonly query: ISalesByItemsReportQuery;
+
+  /**
+   * Constructor method.
+   * @param {ISalesByItemsReportQuery} query
+   * @param {IItem[]} items
+   * @param {IAccountTransaction[]} itemsTransactions
+   * @param {string} baseCurrency
+   */
+  constructor(
+    query: ISalesByItemsReportQuery,
+    items: IItem[],
+    itemsTransactions: IAccountTransaction[],
+    baseCurrency: string
+  ) {
+    super();
+
+    this.baseCurrency = baseCurrency;
+    this.items = items;
+    this.itemsTransactions = transformToMap(itemsTransactions, 'itemId');
+    this.query = query;
+    this.numberFormat = this.query.numberFormat;
+  }
+
+  /**
+   * Retrieve the item purchase item, cost and average cost price.
+   * @param {number} itemId - Item id.
+   */
+  getItemTransaction(itemId: number): {
+    quantity: number;
+    cost: number;
+    average: number;
+  } {
+    const transaction = this.itemsTransactions.get(itemId);
+
+    const quantity = get(transaction, 'quantity', 0);
+    const cost = get(transaction, 'cost', 0);
+
+    const average = cost / quantity;
+
+    return { quantity, cost, average };
+  }
+
+  /**
+   * Mapping the given item section.
+   * @param {ISalesByItemsItem} item
+   * @returns
+   */
+  private itemSectionMapper = (item: IItem): ISalesByItemsItem => {
+    const meta = this.getItemTransaction(item.id);
+
+    return {
+      id: item.id,
+      name: item.name,
+      code: item.code,
+      quantitySold: meta.quantity,
+      soldCost: meta.cost,
+      averageSellPrice: meta.average,
+      quantitySoldFormatted: this.formatNumber(meta.quantity, {
+        money: false,
+      }),
+      soldCostFormatted: this.formatNumber(meta.cost),
+      averageSellPriceFormatted: this.formatNumber(meta.average),
+      currencyCode: this.baseCurrency,
+    };
+  };
+
+  /**
+   * Detarmines whether the given sale node is has transactions.
+   * @param {ISalesByItemsItem} node -
+   * @returns {boolean}
+   */
+  private filterSaleNoneTransactions = (node: ISalesByItemsItem) => {
+    return this.itemsTransactions.get(node.id);
+  };
+
+  /**
+   * Detarmines whether the given sale by item node is active.
+   * @param {ISalesByItemsItem} node
+   * @returns {boolean}
+   */
+  private filterSaleOnlyActive = (node: ISalesByItemsItem): boolean => {
+    return node.quantitySold !== 0 || node.soldCost !== 0;
+  };
+
+  /**
+   * Filters sales by items nodes based on the report query.
+   * @param {ISalesByItemsItem} saleItem -
+   * @return {boolean}
+   */
+  private itemSaleFilter = (saleItem: ISalesByItemsItem): boolean => {
+    const { noneTransactions, onlyActive } = this.query;
+
+    const conditions = [
+      [noneTransactions, this.filterSaleNoneTransactions],
+      [onlyActive, this.filterSaleOnlyActive],
+    ];
+    return allPassedConditionsPass(conditions)(saleItem);
+  };
+
+  /**
+   * Mappes the given items to sales by items nodes.
+   * @param {IItem[]} items -
+   * @returns {ISalesByItemsItem[]}
+   */
+  private itemsMapper = (items: IItem[]): ISalesByItemsItem[] => {
+    return items.map(this.itemSectionMapper);
+  };
+
+  /**
+   * Filters sales by items sections.
+   * @param items
+   * @returns
+   */
+  private itemsFilters = (nodes: ISalesByItemsItem[]): ISalesByItemsItem[] => {
+    return nodes.filter(this.itemSaleFilter);
+  };
+
+  /**
+   * Retrieve the items sections.
+   * @returns {ISalesByItemsItem[]}
+   */
+  private itemsSection(): ISalesByItemsItem[] {
+    return R.compose(this.itemsFilters, this.itemsMapper)(this.items);
+  }
+
+  /**
+   * Retrieve the total section of the sheet.
+   * @param {IInventoryValuationItem[]} items
+   * @returns {IInventoryValuationTotal}
+   */
+  totalSection(items: ISalesByItemsItem[]): ISalesByItemsTotal {
+    const quantitySold = sumBy(items, (item) => item.quantitySold);
+    const soldCost = sumBy(items, (item) => item.soldCost);
+
+    return {
+      quantitySold,
+      soldCost,
+      quantitySoldFormatted: this.formatTotalNumber(quantitySold, {
+        money: false,
+      }),
+      soldCostFormatted: this.formatTotalNumber(soldCost),
+      currencyCode: this.baseCurrency,
+    };
+  }
+
+  /**
+   * Retrieve the sheet data.
+   * @returns {ISalesByItemsSheetStatement}
+   */
+  reportData(): ISalesByItemsSheetStatement {
+    const items = this.itemsSection();
+    const total = this.totalSection(items);
+
+    return items.length > 0 ? { items, total } : {};
+  }
+}

packages/server/src/services/FinancialStatements/SalesByItems/SalesByItemsService.ts

@@ -0,0 +1,132 @@
+import { Service, Inject } from 'typedi';
+import moment from 'moment';
+import {
+  ISalesByItemsReportQuery,
+  ISalesByItemsSheetStatement,
+  ISalesByItemsSheetMeta
+} from '@/interfaces';
+import TenancyService from '@/services/Tenancy/TenancyService';
+import SalesByItems from './SalesByItems';
+import { Tenant } from '@/system/models';
+
+@Service()
+export default class SalesByItemsReportService {
+  @Inject()
+  tenancy: TenancyService;
+
+  @Inject('logger')
+  logger: any;
+
+  /**
+   * Defaults balance sheet filter query.
+   * @return {IBalanceSheetQuery}
+   */
+  get defaultQuery(): ISalesByItemsReportQuery {
+    return {
+      fromDate: moment().startOf('year').format('YYYY-MM-DD'),
+      toDate: moment().endOf('year').format('YYYY-MM-DD'),
+      itemsIds: [],
+      numberFormat: {
+        precision: 2,
+        divideOn1000: false,
+        showZero: false,
+        formatMoney: 'always',
+        negativeFormat: 'mines',
+      },
+      noneTransactions: true,
+      onlyActive: false,
+    };
+  }
+
+  /**
+   * Retrieve the balance sheet meta.
+   * @param {number} tenantId -
+   * @returns {IBalanceSheetMeta}
+   */
+  reportMetadata(tenantId: number): ISalesByItemsSheetMeta {
+    const settings = this.tenancy.settings(tenantId);
+
+    const organizationName = settings.get({
+      group: 'organization',
+      key: 'name',
+    });
+    const baseCurrency = settings.get({
+      group: 'organization',
+      key: 'base_currency',
+    });
+
+    return {
+      organizationName,
+      baseCurrency,
+    };
+  }
+
+  /**
+   * Retrieve balance sheet statement.
+   * -------------
+   * @param {number} tenantId
+   * @param {IBalanceSheetQuery} query
+   *
+   * @return {IBalanceSheetStatement}
+   */
+  public async salesByItems(
+    tenantId: number,
+    query: ISalesByItemsReportQuery
+  ): Promise<{
+    data: ISalesByItemsSheetStatement,
+    query: ISalesByItemsReportQuery,
+    meta: ISalesByItemsSheetMeta,
+  }> {
+    const { Item, InventoryTransaction } = this.tenancy.models(tenantId);
+
+    const tenant = await Tenant.query()
+      .findById(tenantId)
+      .withGraphFetched('metadata');
+
+    const filter = {
+      ...this.defaultQuery,
+      ...query,
+    };
+    this.logger.info('[sales_by_items] trying to calculate the report.', {
+      filter,
+      tenantId,
+    });
+    // Inventory items for sales report.
+    const inventoryItems = await Item.query().onBuild((q) => {
+      q.where('type', 'inventory');
+
+      if (filter.itemsIds.length > 0) {
+        q.whereIn('id', filter.itemsIds);
+      }
+    });
+    const inventoryItemsIds = inventoryItems.map((item) => item.id);
+
+    // Calculates the total inventory total quantity and rate `IN` transactions.
+    const inventoryTransactions = await InventoryTransaction.query().onBuild(
+      (builder: any) => {
+        builder.modify('itemsTotals');
+        builder.modify('OUTDirection');
+
+        // Filter the inventory items only.
+        builder.whereIn('itemId', inventoryItemsIds);
+
+        // Filter the date range of the sheet.
+        builder.modify('filterDateRange', filter.fromDate, filter.toDate)
+      }
+    );
+
+    const purchasesByItemsInstance = new SalesByItems(
+      filter,
+      inventoryItems,
+      inventoryTransactions,
+      tenant.metadata.baseCurrency,
+    );
+    const purchasesByItemsData = purchasesByItemsInstance.reportData();
+
+    return {
+      data: purchasesByItemsData,
+      query: filter,
+      meta: this.reportMetadata(tenantId),
+    };
+  }
+}