@things-factory/warehouse-base 4.0.9 → 4.0.13

package/server/service/inventory-history/inventory-history-query.ts

@@ -117,6 +117,7 @@ export class InventoryHistoryQuery {
           qb.where('Lower(prd.sku) LIKE :productInfo', { productInfo: productFilterValue })
             .orWhere('Lower(prd.name) LIKE :productInfo', { productInfo: productFilterValue })
             .orWhere('Lower(prd.description) LIKE :productInfo', { productInfo: productFilterValue })
+            .orWhere('Lower(prd.brand) LIKE :productInfo', { productInfo: productFilterValue })
         })
       )
 
@@ -384,7 +385,7 @@ export class InventoryHistoryQuery {
           uomValue: item.uom_value,
           openingQty: item.opening_qty,
           openingUomValue: item.opening_uom_value,
-          orderName: item.order_name,
+          orderNo: item.order_name,
           orderRefNo: item.ref_no,
           createdAt: item.created_at
         }
@@ -944,7 +945,8 @@ export class InventoryHistoryQuery {
     @Arg('filters', type => [Filter], { nullable: true }) filters?: Filter[],
     @Arg('pagination', type => Pagination, { nullable: true }) pagination?: Pagination,
     @Arg('sortings', type => [Sorting], { nullable: true }) sortings?: Sorting[],
-    @Arg('locationSortingRules', type => [Sorting], { nullable: true }) locationSortingRules?: Sorting[]
+    @Arg('locationSortingRules', type => [Sorting], { nullable: true }) locationSortingRules?: Sorting[],
+    @Arg('setPagination', type => Boolean, { defaultValue: true }) setPagination?: Boolean
   ): Promise<InventoryList> {
     const { domain, user, tx }: { domain: Domain; user: User; tx: EntityManager } = context.state
 
@@ -1017,7 +1019,8 @@ export class InventoryHistoryQuery {
             )
             and (lower(prd.name) like any(array[${products}])
             or lower(prd.description) like any(array[${products}])
-            or lower(prd.sku) like any(array[${products}]))
+            or lower(prd.sku) like any(array[${products}])
+            or lower(prd.brand) like any(array[${products}]))
             and prd.id = rih.product_id
             group by prd.id
         )`
@@ -1076,14 +1079,14 @@ export class InventoryHistoryQuery {
 
     // query the results
     await tx.query(`
-      CREATE TEMP TABLE tmp_bizfilter AS (
+      CREATE TEMP TABLE tmp_bizfilter on commit drop AS (
         SELECT bizplace_id::uuid FROM (VALUES ${bizplaces}) AS bizFilter(bizplace_id)
       );
     `)
 
     await tx.query(
       `
-      create temp table tmp_src as (
+      create temp table tmp_src on commit drop as (
         select domain_id, pallet_id, carton_id, seq, qty, uom_value, packing_type, batch_id, batch_id_ref, created_at, status,
         product_id::uuid as product_id, bizplace_id::uuid as bizplace_id, location_id::uuid as location_id 
         from reduced_inventory_histories rih 
@@ -1095,7 +1098,7 @@ export class InventoryHistoryQuery {
 
     await tx.query(
       `          
-        create temp table tmp_data as (
+        create temp table tmp_data on commit drop as (
           select dt.*, rih.carton_id, rih.batch_id, rih.batch_id_ref, rih.product_id, rih.packing_type, rih.bizplace_id, rih.location_id, iv.uom, 
           iv.expiration_date, iv.reusable_pallet_id, iv.remark
           from
@@ -1126,7 +1129,7 @@ export class InventoryHistoryQuery {
           rih.initial_inbound_at as "initialInboundAt",
           case when rih.reusable_pallet_id is not null then concat(rih.batch_id, ' (', plt.name, ')') else rih.batch_id end as "batchId",
           rih.batch_id_ref as "batchIdRef", rih.product_id, rih.packing_type as "packingType", rih.bizplace_id, rih.location_id,
-          prd.id as product_id, prd.name as product_name, prd.sku as product_sku, prd.description as product_description,
+          prd.id as product_id, prd.name as product_name, prd.sku as product_sku, prd.brand as product_brand, prd.description as product_description,
           bz.id as bizplace_id, bz.name as bizplace_name, 
           loc.id as location_id, loc.name as location_name, loc."zone" as location_zone, loc."row" as location_row, loc."column" as location_column, loc.shelf as location_shelf,
           wh.name as warehouse_name, plt.name as reusable_pallet_name,
@@ -1140,15 +1143,10 @@ export class InventoryHistoryQuery {
           inner join warehouses wh on wh.id = loc.warehouse_id
           WHERE 1 = 1
           ${queryOrder}
-          OFFSET $1 LIMIT $2;
-      `,
-      [(pagination.page - 1) * pagination.limit, pagination.limit]
+          ${setPagination ? 'OFFSET ' + (pagination.page - 1) * pagination.limit + ' LIMIT ' + pagination.limit : ''}
+      `
     )
 
-    tx.query(`
-      drop table tmp_src, tmp_data, tmp_bizfilter
-    `)
-
     // map all results
     let items = result.map(itm => {
       return {
@@ -1167,7 +1165,8 @@ export class InventoryHistoryQuery {
           id: itm.product_id,
           name: itm.product_name,
           description: itm.product_description,
-          sku: itm.product_sku
+          sku: itm.product_sku,
+          brand: itm.product_brand
         }
       }
     })
@@ -1204,7 +1203,7 @@ async function massageInventorySummary(tx: EntityManager, params: ListParam, biz
   }
   await tx.query(
     `
-    create temp table temp_inventory_summary as (
+    create temp table temp_inventory_summary ON COMMIT DROP as (
       select src.*,
       opening_qty + adjustment_qty + total_in_qty + total_out_qty as closing_qty
       from (
@@ -1234,10 +1233,6 @@ async function massageInventorySummary(tx: EntityManager, params: ListParam, biz
     [(params.pagination.page - 1) * params.pagination.limit, params.pagination.limit]
   )
 
-  tx.query(`
-    drop table temp_products, temp_inv_history, temp_inventory_summary
-  `)
-
   return [result, total]
 }
 
@@ -1255,7 +1250,7 @@ async function massageInventoryPalletSummary(tx: EntityManager, params: ListPara
   }
   await tx.query(
     `
-    create temp table temp_inventory_pallet_summary as (
+    create temp table temp_inventory_pallet_summary ON COMMIT DROP as (
       select invh.*,
       invh.opening_qty + invh.total_in_qty + invh.total_out_qty + invh.adjustment_qty as closing_qty from (
         select product_sku, product_id, product_name, product_description, product_type,
@@ -1350,16 +1345,13 @@ async function massageInventoryPalletSummary(tx: EntityManager, params: ListPara
     [(params.pagination.page - 1) * params.pagination.limit, params.pagination.limit]
   )
 
-  tx.query(`
-    drop table temp_products, temp_inv_history, temp_inventory_pallet_summary
-  `)
-
   return [result, total]
 }
 
 async function productsQuery(tx: EntityManager, params: ListParam, bizplace: Bizplace) {
   let product = params.filters.find(data => data.name === 'product')
   let productDesc = params.filters.find(data => data.name === 'productDescription')
+  let productType = params.filters.find(data => data.name === 'productType')
 
   let productQuery = ''
   if (product) {
@@ -1379,12 +1371,17 @@ async function productsQuery(tx: EntityManager, params: ListParam, bizplace: Biz
 
   let productDescQuery = ''
   if (productDesc) {
-    productDescQuery = "AND Lower(description) LIKE '%" + productDesc.value.toLowerCase() + "%'"
+    productDescQuery = "AND Lower(prd.description) LIKE '%" + productDesc.value.toLowerCase() + "%'"
+  }
+
+  let productTypeQuery = ''
+  if (productType) {
+    productTypeQuery = "AND prd.type = '" + productType.value + "'"
   }
 
   await tx.query(
     `
-    create temp table temp_products AS
+    create temp table temp_products ON COMMIT DROP AS
     (
       select prd.id, prd.name, prd.sku, prd.description, prd.id::varchar as product_id, prd.type from products prd
       inner join bizplaces b on b.id = prd.bizplace_id 
@@ -1392,6 +1389,8 @@ async function productsQuery(tx: EntityManager, params: ListParam, bizplace: Biz
       inner join bizplaces b2 on b2.company_id = c.id
       where b2.id = $1
       ${productQuery}
+      ${productDescQuery}
+      ${productTypeQuery}
       GROUP BY prd.id, prd.sku, prd.name, prd.description
     )`,
     [bizplace.id]
@@ -1418,7 +1417,7 @@ async function filterInventoryQuery(tx: EntityManager, params: ListParam, bizpla
 
   await tx.query(
     `
-    create temp table temp_inv_history as (
+    create temp table temp_inv_history ON COMMIT DROP as (
       select i2.pallet_id, ih.product_id::uuid, ih.packing_type, i2.packing_size, ih.batch_id,
       ih.id as inventory_history_id, ih.seq, ih.status, ih.transaction_type, ih.qty, ih.opening_qty, ih.created_at
       from inventories i2

package/server/service/inventory-history/inventory-history-types.ts

@@ -18,8 +18,8 @@ export class InventoryHistoryList {
 
 @ObjectType()
 export class InventoryHistoryPalletReportList {
-  @Field(type => [InventoryHistoryPalletReportList], { nullable: true })
-  items?: InventoryHistoryPalletReportList[]
+  @Field(type => [InventoryHistoryPalletReport], { nullable: true })
+  items?: InventoryHistoryPalletReport[]
 
   @Field(type => Int, { nullable: true })
   total?: number

package/server/service/inventory-history/inventory-history.ts

@@ -13,7 +13,7 @@ import {
 import { User } from '@things-factory/auth-base'
 import { Bizplace } from '@things-factory/biz-base'
 import { Product, ProductDetail } from '@things-factory/product-base'
-import { Domain } from '@things-factory/shell'
+import { Domain, ScalarDate } from '@things-factory/shell'
 
 import { Inventory } from '../inventory/inventory'
 import { Location } from '../location/location'
@@ -164,7 +164,7 @@ export class InventoryHistory {
   inventory: Inventory
 
   @Column('date', { nullable: true })
-  @Field({ nullable: true })
+  @Field(type => ScalarDate, { nullable: true })
   expirationDate: Date
 
   @Column('int', { nullable: true })

package/server/service/location/location-query.ts

@@ -31,7 +31,7 @@ export class LocationQuery {
   @Query(returns => LocationOccupancy)
   async locationOccupancies(
     @Arg('warehouse') warehouse: string,
-    @Arg('types', type => [String]) types: string[],
+    @Arg('types', type => [String], { nullable: true }) types: string[],
     @Ctx() context: any
   ): Promise<LocationOccupancy> {
     const { domain }: { domain: Domain } = context.state

package/server/service/location/location-types.ts

@@ -104,6 +104,15 @@ export class LocationPatch {
   @Field({ nullable: true })
   zone?: string
 
+  @Field({ nullable: true })
+  firstDelimiter?: string
+
+  @Field({ nullable: true })
+  secondDelimiter?: string
+
+  @Field({ nullable: true })
+  thirdDelimiter?: string
+
   @Field({ nullable: true })
   row?: string
 
@@ -137,6 +146,15 @@ export class NewLocation {
   @Field()
   zone: string
 
+  @Field({ nullable: true })
+  firstDelimiter?: string
+
+  @Field({ nullable: true })
+  secondDelimiter?: string
+
+  @Field({ nullable: true })
+  thirdDelimiter?: string
+
   @Field()
   row: string
 

package/server/service/location/location.ts

@@ -37,8 +37,8 @@ export class Location {
   @Field(type => Warehouse, { nullable: true })
   warehouse: Warehouse
 
-  @Column()
-  @Field()
+  @Column({ nullable: true })
+  @Field({ nullable: true })
   name: string
 
   @Column({

package/server/utils/datetime-util.ts

@@ -0,0 +1,54 @@
+export class DateGenerator {
+  static generateDate() {
+    const today = new Date()
+    const year = today.getFullYear()
+    const month = today.getMonth()
+    const day = today.getDate()
+
+    const yy = String(year).substr(String(year).length - 2)
+    const mm = String(month + 1).padStart(2, '0')
+    const dd = String(day).padStart(2, '0')
+
+    return yy + mm + dd
+  }
+}
+
+export class DateTimeConverter {
+  static date(dateTime) {
+    let unloadDate = ''
+    if (dateTime) {
+      const unloadDateTime: Date = new Date(dateTime)
+      var year = unloadDateTime.getFullYear()
+
+      var month = (1 + unloadDateTime.getMonth()).toString()
+      month = month.length > 1 ? month : '0' + month
+
+      var day = unloadDateTime.getDate().toString()
+      day = day.length > 1 ? day : '0' + day
+
+      unloadDate = day + '-' + month + '-' + year
+    }
+    return unloadDate
+  }
+
+  static datetime(dateTime, timezone) {
+    let unloadDate = ''
+    if (dateTime) {
+      const datetime = Number(dateTime)
+      const timezoneOffset = timezone * 60000
+      const newUnloadDate = new Date(datetime - timezoneOffset).toISOString().slice(0, -1)
+
+      var dateTimeParts: any = newUnloadDate.split('T')
+
+      //handle date parts
+      var dateParts = dateTimeParts[0].split('-')
+      var newDate = DateTimeConverter.date(dateParts)
+
+      //handle time part
+      var timeParts = dateTimeParts[1].slice(0, -7)
+
+      unloadDate = newDate + ' ' + timeParts
+    }
+    return unloadDate
+  }
+}

package/server/utils/index.ts

@@ -1,2 +1,3 @@
 export * from './inventory-no-generator'
 export * from './inventory-util'
+export * from './datetime-util'

package/server/utils/inventory-util.ts

@@ -5,10 +5,119 @@ import { Bizplace } from '@things-factory/biz-base'
 import { Product } from '@things-factory/product-base'
 import { Domain } from '@things-factory/shell'
 
-import { INVENTORY_STATUS, LOCATION_STATUS } from '../constants'
+import { INVENTORY_STATUS, INVENTORY_TRANSACTION_TYPE, LOCATION_STATUS } from '../constants'
 import { Inventory, InventoryHistory, Location } from '../service'
 import { InventoryNoGenerator } from '../utils'
 
+export class InventoryUtil {
+  protected trxMgr: EntityManager
+  protected domain: Domain
+  protected user: User
+
+  constructor(trxMgr: EntityManager, domain: Domain, user: User) {
+    this.trxMgr = trxMgr
+    this.domain = domain
+    this.user = user
+  }
+
+  public readonly ERROR_MSG = {
+    FIND: {
+      NO_RESULT: (condition: any) => `There's no results matched with condition ${condition}`,
+      NO_CHILD_RESULT: (condition: any) => `There's no child result matched with condition ${condition}`,
+      NOT_MATCH: (source: any, target: any) => `Unable to find matching ${target} using ${source}`
+    },
+    ORDER_ITEM: {
+      NO_MATCHING_RESULT: (condition: any, condition2: any) =>
+        `Current item with ${condition} (${condition2}) not belong to this order`,
+      EXCESS_QTY: (condition: any, condition2: any, condition3: any) =>
+        `Excess qty is scanned for item ${condition}, ${condition2} (${condition3})`
+    },
+    PRODUCT: {
+      NO_MATCHING_RESULT: (condition: any, condition2: any) =>
+        `Order packing type and packing size not match with product master, ${condition} (${condition2})`,
+      BARCODE_NOT_EXIST: (condition: any, condition2: any, condition3: any) =>
+        `Product barcode - ${condition} with ${condition2} ${condition3}, not exist in master data.`
+    },
+    CREATE: {
+      ID_EXISTS: 'Target has ID already',
+      EMPTY_CREATOR: 'Cannot create without creator',
+      EMPTY_UPDATER: 'Cannot create without updater'
+    },
+    UPDATE: {
+      ID_NOT_EXISTS: `Target doesn't have ID`,
+      EMPTY_UPDATER: 'Cannot update without updater'
+    },
+    VALIDITY: {
+      UNEXPECTED_FIELD_VALUE: (field: string, expectedValue: any, actualValue: any) =>
+        `Expected ${field} value is ${expectedValue} but got ${actualValue}`,
+      DUPLICATED: (field: string, value: any) => `There is duplicated ${field} value (${value})`,
+      CANT_PROCEED_STEP_BY: (step: string, reason: string) => `Can't proceed to ${step} because ${reason}`
+    }
+  }
+
+  async createInventory(inventory: Partial<Inventory>): Promise<Inventory> {
+    inventory = this.setStamp(inventory)
+    return await this.trxMgr.getRepository(Inventory).save(inventory)
+  }
+
+  /**
+   * @summary Update inventory record
+   * @description It will update inventory after set a stamp (domain, updater)
+   * The special point of this function is that this changes won't generate inventory history
+   * If you want to generate inventory history automatically you would better to use transactionInventory function
+   */
+  async updateInventory(inventory: Partial<Inventory>): Promise<Inventory> {
+    if (!inventory.id) throw new Error(this.ERROR_MSG.UPDATE.ID_NOT_EXISTS)
+    inventory = this.setStamp(inventory)
+    return await this.trxMgr.getRepository(Inventory).save(inventory)
+  }
+
+  /**
+   * @summary Do transaction on inventory record
+   * @description It will update inventory after set a temp (domain, updater)
+   * and then generate inventory history based on current changes
+   */
+  async transactionInventory(
+    inventory: Inventory,
+    refOrder: any,
+    changedQty: number,
+    changedUom: number,
+    transactionType: string
+  ): Promise<Inventory> {
+    if (inventory.id) {
+      inventory = await this.updateInventory(inventory)
+    } else {
+      inventory = await this.createInventory(inventory)
+    }
+
+    await generateInventoryHistory(
+      inventory,
+      refOrder,
+      transactionType,
+      changedQty,
+      changedUom,
+      this.user,
+      this.trxMgr
+    )
+
+    return inventory
+  }
+
+  /**
+   * @summary set common stamp like domain, creator, updater
+   * @description Set common stamp to passed record
+   * If it doesn't have id it will handle it as creating one
+   * If it has id it will handle it as updating one
+   */
+  setStamp(record: Record<string, any>): Record<string, any> {
+    if (!record.domain) record.domain = this.domain
+    if (!record.id && !record.creator) record.creator = this.user
+    if (!record.updater) record.updater = this.user
+
+    return record
+  }
+}
+
 /**
  * @description It will insert new record into inventory histories table.
  * seq will be calculated based on number of records for one specific pallet id (provided by inventory object)
@@ -49,58 +158,72 @@ export async function generateInventoryHistory(
 
   if (seq) {
     const lastInvHistory: InventoryHistory = await invHistoryRepo.findOne({
-      domain: inventory.domain,
-      palletId: inventory.palletId,
-      seq: seq - 1
+      where: {
+        domain: inventory.domain,
+        palletId: inventory.palletId,
+      },
+      order: {
+        seq: 'DESC'
+      },
     })
     openingQty = lastInvHistory.openingQty + lastInvHistory.qty
     openingUomValue = lastInvHistory.openingUomValue + lastInvHistory.uomValue
   }
 
-  let inventoryHistory: InventoryHistory = new InventoryHistory()
-  inventoryHistory.name = InventoryNoGenerator.inventoryHistoryName()
-  inventoryHistory.description = inventory.description
-  inventoryHistory.seq = seq
-  inventoryHistory.palletId = inventory.palletId
-  inventoryHistory.cartonId = inventory.cartonId
-  inventoryHistory.batchId = inventory.batchId
-  inventoryHistory.batchIdRef = inventory.batchIdRef
-  inventoryHistory.status = inventory.status
-  inventoryHistory.transactionType = transactionType
-  inventoryHistory.refOrderId = refOrder?.id || null
-  inventoryHistory.orderNo = refOrder?.name || null
-  inventoryHistory.orderRefNo = refOrder?.refNo || null
-  inventoryHistory.inventory = inventory
-  inventoryHistory.product = inventory.product
-  inventoryHistory.reusablePallet = inventory.reusablePallet
-  inventoryHistory.zone = inventory.zone
-  inventoryHistory.warehouse = inventory.warehouse
-  inventoryHistory.location = inventory.location
-  inventoryHistory.expirationDate = inventory.expirationDate
-  inventoryHistory.packingType = inventory.packingType
-  inventoryHistory.uom = inventory.uom
-  inventoryHistory.qty = qty
-  inventoryHistory.openingQty = openingQty
-  inventoryHistory.uomValue = uomValue
-  inventoryHistory.openingUomValue = openingUomValue
-  inventoryHistory.unitCost = inventory.unitCost
-  inventoryHistory.domain = inventory.domain
-  inventoryHistory.bizplace = inventory.bizplace
-  inventoryHistory.creator = user
-  inventoryHistory.updater = user
-
-  inventoryHistory = await invHistoryRepo.save(inventoryHistory)
+  let remainQty = ((openingQty || 0) + (qty || 0))
+
+  let inventoryHistory: Partial<InventoryHistory> = new InventoryHistory()
+
+  inventoryHistory = {
+    ...inventory,
+    name: InventoryNoGenerator.inventoryHistoryName(),
+    inventory,
+    seq: seq - 1,
+    status: remainQty == 0 ? INVENTORY_STATUS.TERMINATED : inventory.status,
+    transactionType,
+    refOrderId: refOrder?.id || null,
+    orderNo: refOrder?.name || null,
+    orderRefNo: refOrder?.refNo || null,
+    qty,
+    openingQty,
+    uomValue,
+    openingUomValue: openingUomValue,
+    creator: user,
+    updater: user
+  }
+
+  let newInventoryHistory = await invHistoryRepo.save(inventoryHistory)
+
+  if (remainQty == 0) {
+    let terminatedHistory = {
+      ...newInventoryHistory,
+      name: InventoryNoGenerator.inventoryHistoryName(),
+      seq: seq + 1,
+      status: INVENTORY_STATUS.TERMINATED,
+      transactionType: INVENTORY_TRANSACTION_TYPE.TERMINATED,
+      uom: inventory.uom,
+      qty: 0,
+      openingQty: 0,
+      uomValue: 0,
+      openingUomValue: 0
+    }
+
+    delete terminatedHistory.id
+
+    newInventoryHistory = await invHistoryRepo.save(terminatedHistory)
+    inventory.status = INVENTORY_STATUS.TERMINATED
+  }
 
   if (inventory.lastSeq !== seq) {
     await invRepo.save({
       ...inventory,
-      lastSeq: inventoryHistory.seq,
+      lastSeq: newInventoryHistory.seq,
       updater: user
     })
   }
 
   await switchLocationStatus(domain, location, user, trxMgr)
-  return inventoryHistory
+  return newInventoryHistory
 }
 
 /**