@things-factory/warehouse-base 8.0.3 → 8.0.6

package/server/service/warehouse/warehouse.ts

@@ -1,95 +0,0 @@
-import { Field, ID, ObjectType } from 'type-graphql'
-import {
-  Column,
-  CreateDateColumn,
-  Entity,
-  Index,
-  ManyToOne,
-  OneToMany,
-  PrimaryGeneratedColumn,
-  RelationId,
-  UpdateDateColumn
-} from 'typeorm'
-
-import { User } from '@things-factory/auth-base'
-import { Bizplace } from '@things-factory/biz-base'
-import { Domain } from '@things-factory/shell'
-
-import { Location } from '../location/location'
-
-@Entity()
-@Index('ix_warehouse_0', (warehouse: Warehouse) => [warehouse.domain, warehouse.name], { unique: true })
-@Index('ix_warehouse_1', (warehouse: Warehouse) => [warehouse.domain, warehouse.id], { unique: true })
-@ObjectType()
-export class Warehouse {
-  @PrimaryGeneratedColumn('uuid')
-  @Field(type => ID)
-  id: string
-
-  @ManyToOne(type => Domain)
-  @Field(type => Domain)
-  domain: Domain
-
-  @RelationId((warehouse: Warehouse) => warehouse.domain)
-  domainId: string
-
-  @ManyToOne(type => Bizplace)
-  @Field()
-  bizplace: Bizplace
-
-  @Column()
-  @Field()
-  name: string
-
-  @OneToMany(type => Location, location => location.warehouse)
-  @Field(type => [Location])
-  locations: Location[]
-
-  @Column()
-  @Field()
-  type: string
-
-  @Column({
-    nullable: true
-  })
-  @Field({ nullable: true })
-  description: string
-
-  @ManyToOne(type => User, {
-    nullable: true
-  })
-  @Field({ nullable: true })
-  creator: User
-
-  @RelationId((warehouse: Warehouse) => warehouse.creator)
-  creatorId: string
-
-  @ManyToOne(type => User, {
-    nullable: true
-  })
-  @Field({ nullable: true })
-  updater: User
-
-  @RelationId((warehouse: Warehouse) => warehouse.updater)
-  updaterId: string
-
-  @CreateDateColumn()
-  @Field({ nullable: true })
-  createdAt: Date
-
-  @UpdateDateColumn()
-  @Field({ nullable: true })
-  updatedAt: Date
-
-  constructor(obj?) {
-    if (obj) {
-      this.id = obj.warehouse_id
-      this.name = obj.warehouse_name
-      this.locations = obj.warehouse_locations
-      this.type = obj.warehouse_type
-      this.description = obj.warehouse_description
-      this.createdAt = obj.warehouse_created_at
-      this.updatedAt = obj.warehouse_updated_at
-    }
-  }
-}

package/server/utils/datetime-util.ts

@@ -1,54 +0,0 @@
-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,3 +0,0 @@
-export * from './inventory-no-generator'
-export * from './inventory-util'
-export * from './datetime-util'

package/server/utils/inventory-no-generator.ts

@@ -1,15 +0,0 @@
-import { v4 as uuidv4 } from 'uuid'
-
-export class InventoryNoGenerator {
-  static inventoryName() {
-    return uuidv4()
-  }
-
-  static inventoryHistoryName() {
-    return uuidv4()
-  }
-
-  static inventoryItemName() {
-    return uuidv4()
-  }
-}

package/server/utils/inventory-util.ts

@@ -1,490 +0,0 @@
-import { EntityManager, Repository } from 'typeorm'
-
-import { User } from '@things-factory/auth-base'
-import { Bizplace } from '@things-factory/biz-base'
-import { Product } from '@things-factory/product-base'
-import { Domain, getRepository } from '@things-factory/shell'
-
-import { INVENTORY_STATUS, INVENTORY_TRANSACTION_TYPE, LOCATION_STATUS, LOCATION_TYPE } 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,
-    description?: 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,
-      description || null
-    )
-
-    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)
- */
-export async function generateInventoryHistory(
-  inventory: Inventory,
-  refOrder: any,
-  transactionType: string,
-  qty: number,
-  uomValue: number,
-  user: User,
-  trxMgr?: EntityManager,
-  description?: string
-): Promise<InventoryHistory> {
-  const invHistoryRepo: Repository<InventoryHistory> =
-    trxMgr?.getRepository(InventoryHistory) || getRepository(InventoryHistory)
-  const invRepo: Repository<Inventory> = trxMgr?.getRepository(Inventory) || getRepository(Inventory)
-
-  if (!inventory?.id) throw new Error(`Can't find out ID of inventory.`)
-
-  inventory = await invRepo.findOne({
-    where: { id: inventory.id },
-    relations: ['domain', 'bizplace', 'product', 'warehouse', 'location']
-  })
-
-  const domain: Domain = inventory.domain
-  const location: Location = inventory.location
-
-  const lastInvHistory: InventoryHistory = await invHistoryRepo.findOne({
-    where: {
-      domain: { id: inventory.domain.id },
-      palletId: inventory.palletId
-    },
-    order: {
-      seq: 'DESC'
-    }
-  })
-
-  let seq: number = 0
-  let openingQty: number = 0
-  let openingUomValue: number = 0
-
-  if (lastInvHistory) {
-    openingQty = lastInvHistory.openingQty + lastInvHistory.qty
-    openingUomValue = lastInvHistory.openingUomValue + lastInvHistory.uomValue
-    seq = lastInvHistory.seq + 1
-  }
-
-  let remainQty = (openingQty || 0) + (qty || 0)
-
-  let inventoryHistory: any = new InventoryHistory()
-
-  inventoryHistory = {
-    ...inventory,
-    name: InventoryNoGenerator.inventoryHistoryName(),
-    description,
-    inventory,
-    seq: seq,
-    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
-  }
-
-  delete inventoryHistory.updatedAt
-  delete inventoryHistory.createdAt
-  delete inventoryHistory.id
-
-  let newInventoryHistory = await invHistoryRepo.save(inventoryHistory)
-
-  if (remainQty == 0) {
-    seq = seq + 1
-    let terminatedHistory = {
-      ...newInventoryHistory,
-      name: InventoryNoGenerator.inventoryHistoryName(),
-      seq: seq,
-      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.update(inventory.id, { lastSeq: newInventoryHistory.seq, updater: user })
-  }
-
-  await switchLocationStatus(domain, location, user, trxMgr)
-  return newInventoryHistory
-}
-
-/**
- * @description: Check location emptiness and update status of location
- * @param domain
- * @param location
- * @param updater
- * @param trxMgr
- */
-export async function switchLocationStatus(
-  domain: Domain,
-  location: Location,
-  updater: User,
-  trxMgr?: EntityManager
-): Promise<Location> {
-  const invRepo: Repository<Inventory> = trxMgr?.getRepository(Inventory) || getRepository(Inventory)
-  const locationRepo: Repository<Location> = trxMgr?.getRepository(Location) || getRepository(Location)
-  const allocatedItemsCnt: number = await invRepo.countBy({
-    domain: { id: domain.id },
-    status: INVENTORY_STATUS.STORED,
-    location: { id: location.id }
-  })
-
-  if (!allocatedItemsCnt && location.status !== LOCATION_STATUS.EMPTY) {
-    location = await locationRepo.save({
-      ...location,
-      status: LOCATION_STATUS.EMPTY,
-      updater
-    })
-  } else if (allocatedItemsCnt && location.status === LOCATION_STATUS.EMPTY) {
-    location = await locationRepo.save({
-      ...location,
-      status: LOCATION_STATUS.OCCUPIED,
-      updater
-    })
-  }
-
-  return location
-}
-
-export async function checkPalletDuplication(
-  domain: Domain,
-  bizplace: Bizplace,
-  palletId: string,
-  trxMgr?: EntityManager
-): Promise<boolean> {
-  const invRepo: Repository<Inventory> = trxMgr?.getRepository(Inventory) || getRepository(Inventory)
-  const duplicatedPalletCnt: number = await invRepo.countBy({
-    domain: { id: domain.id },
-    bizplace: { id: bizplace.id },
-    palletId
-  })
-
-  return Boolean(duplicatedPalletCnt)
-}
-
-/**
- * @description Check whether inventory is same with passed conditions
- * @param {Domain} domain
- * @param {Bizplace} bizplace
- * @param {String} palletId
- * @param {String} batchId
- * @param {String | Product} product
- * @param {String} packingType
- * @param {EntityManager} trxMgr
- */
-export async function checkPalletIdenticallity(
-  domain: Domain,
-  bizplace: Bizplace,
-  palletId: string,
-  batchId: string,
-  product: string | Product,
-  packingType: string,
-  trxMgr?: EntityManager
-): Promise<{ identicallity: boolean; errorMessage?: string }> {
-  const productRepo: Repository<Product> = trxMgr?.getRepository(Product) || getRepository(Product)
-  const invRepo: Repository<Inventory> = trxMgr?.getRepository(Inventory) || getRepository(Inventory)
-
-  if (typeof product === 'string') {
-    const foundProduct: Product = await productRepo.findOneBy({ id: product }) /* TODO check migration typeorm 0.3 */
-    if (!foundProduct) throw new Error(`Failed to find product with ${product}`)
-    product = foundProduct
-  }
-
-  const inv: Inventory = await invRepo.findOne({
-    where: { domain: { id: domain.id }, bizplace: { id: bizplace.id }, palletId },
-    relations: ['product']
-  })
-
-  if (batchId !== inv.batchId) return { identicallity: false, errorMessage: `Batch ID is not matched with ${batchId}` }
-
-  if (product?.id !== inv?.product?.id)
-    return { identicallity: false, errorMessage: `Product is not matched with ${product.name}` }
-
-  if (packingType !== inv.packingType)
-    return { identicallity: false, errorMessage: `Packing Type is not matched with ${packingType}` }
-
-  return { identicallity: true }
-}
-
-/**
- * @description Check whether inventory is same with passed conditions
- * @param {Domain} domain
- * @param {Domain} productOwnerDomain
- * @param {OrderProduct} bizplace *
- * @param {EntityManager} trxMgr
- */
-export async function getProductBundleInventory(
-  domain: Domain,
-  productOwnerDomain: Domain,
-  orderProducts: any[],
-  trxMgr: EntityManager
-): Promise<any> {
-  let orderProductsJson = JSON.stringify(
-    orderProducts.map(itm => {
-      return {
-        ...itm,
-        product_id: itm.product.id,
-        packing_type: itm.packingType,
-        packing_size: itm.packingSize,
-        uom: itm.uom
-      }
-    }) || []
-  )
-
-  const result: any[] = await trxMgr.query(
-    `
-      select product_bundle_id, sku, name, min(available_qty) as qty from (
-        select
-        pb.sku, pb.name, pbs.product_bundle_id, pbs.bundle_qty, pd.product_id, pd.packing_type, pd.packing_size, pd.uom,
-        floor(coalesce(sum(inv.qty - coalesce(inv.locked_qty,0)),0)/pbs.bundle_qty) as available_qty, 
-        floor(coalesce(sum(inv.uom_value - coalesce(inv.locked_uom_value,0)),0)/pbs.bundle_qty) as available_uom_value      
-        from (
-          select pb.id, pb.sku, pb.name
-          from json_populate_recordset(NULL::order_products,'${orderProductsJson}') src 
-          inner join product_details pd ON src.product_id = pd.product_id and src.packing_type = pd.packing_type and src.packing_size = pd.packing_size and src.uom = pd.uom
-          inner join product_bundle_settings pbs on pbs.product_detail_id = pd.id
-          inner join product_bundles pb on pb.id = pbs.product_bundle_id and pb.status = 'ACTIVATED'
-          where pb.domain_id = $1
-          group by pb.id, pb.sku, pb.name
-        ) pb
-        inner join product_bundle_settings pbs on pbs.product_bundle_id = pb.id
-        inner join product_details pd on pd.id = pbs.product_detail_id 
-        left join inventories inv on ((inv.status <> 'TERMINATED' and (inv.qty - coalesce(inv.locked_qty,0)) > 0) or (inv.status = 'TERMINATED' and (inv.qty - coalesce(inv.locked_qty,0)) = 0)) and inv.product_id = pd.product_id and inv.packing_type = pd.packing_type and inv.packing_size = pd.packing_size and inv.uom = pd.uom
-        where inv.domain_id = $2
-        group by pb.sku, pb.name, pbs.product_bundle_id, pbs.bundle_qty, pd.product_id, pd.packing_type, pd.packing_size, pd.uom
-      ) foo group by product_bundle_id, sku, name
-    `,
-    [productOwnerDomain.id, domain.id]
-  )
-
-  return result
-}
-
-/**
- * @description This function will return multiple products
- * and it is different with @inventoriesByStrategy that returns
- * inventories for one product only
- * @param {string} bizplaceId
- * @param {string} worksheetId
- * @param {any[]} orderProducts
- * @param {string} pickingStrategy
- * @param {[Object]} locationSortingRules
- * @param {EntityManager} trxMgr
- * @returns inventories for multiple products
- */
-export async function getInventoriesByStrategy(
-  domainId: string,
-  bizplaceId: string,
-  worksheetId: string,
-  orderProducts: any[],
-  locationSortingRules: any[],
-  trxMgr: EntityManager
-): Promise<Inventory[]> {
-  let orderProductsJSON: string = JSON.stringify(orderProducts)
-  let locationSorting: string = (locationSortingRules || [])
-    .map((rule: { name: string; descOrder: boolean }) => {
-      return `l.${rule.name}${rule.descOrder ? 'DESC' : ''}`
-    })
-    .join(', ')
-
-  if (locationSorting === '') locationSorting = 'l.name'
-
-  await trxMgr.query(
-    `
-    CREATE TEMP TABLE temp_op2(
-      "productId" VARCHAR(50),
-      "batchId" VARCHAR(50),
-      "packingType" VARCHAR(50),
-      "packingSize" INT,
-      "uom" VARCHAR(10),
-      "releaseQty" INT,
-      "pickingStrategy" VARCHAR(25),
-      "orderProductId" VARCHAR(50)
-    );
-  `
-  )
-
-  await trxMgr.query(
-    `
-    INSERT INTO temp_op2
-    SELECT "productId", "batchId", "packingType", "packingSize", "uom", "releaseQty", "pickingStrategy", "orderProductId"
-    FROM JSON_POPULATE_RECORDSET(NULL::temp_op2, $1) js
-  `,
-    [orderProductsJSON]
-  )
-
-  await trxMgr.query(
-    `
-    CREATE TEMP TABLE acc_oi2 AS (
-      SELECT oi.inventory_id, SUM(oi.release_qty) AS total_release_qty, SUM(oi.release_uom_value) AS total_release_uom_value
-      FROM order_inventories oi
-      WHERE oi.status IN ('PENDING','PENDING_RECEIVE','PENDING_WORKSHEET','PENDING_SPLIT')
-      AND oi.bizplace_id = $1
-      AND oi.inventory_id NOTNULL
-      AND oi.ref_worksheet_id != $2
-      GROUP BY oi.inventory_id
-    )
-  `,
-    [bizplaceId, worksheetId]
-  )
-
-  // get inventories
-  let inventories = await trxMgr.query(
-    `
-    SELECT
-    i.id,
-    op."productId",
-    op."batchId",
-    i.qty - COALESCE(i.locked_qty,0) - COALESCE(foo.total_release_qty,0) AS "remainQty",
-    i.uom_value - COALESCE(i.locked_uom_value,0) - COALESCE(foo.total_release_uom_value,0) AS "remainUomValue",
-    op."packingType",
-    op."packingSize",
-    op."uom",
-    op."orderProductId",
-    ROW_NUMBER() OVER (
-      PARTITION BY op."productId", op."batchId", op."packingType", op."packingSize", op."uom"
-      ORDER BY 
-        CASE WHEN op."pickingStrategy" = 'FIFO' THEN i.created_at END,
-        CASE WHEN op."pickingStrategy" = 'FEFO' THEN i.expiration_date END,
-        CASE WHEN op."pickingStrategy" = 'LIFO' THEN i.created_at END DESC,
-        CASE WHEN op."pickingStrategy" = 'FMFO' THEN i.manufacture_date END,
-        ${locationSorting}
-      ) AS rn
-    FROM inventories i
-    INNER JOIN locations l ON i.location_id = l.id
-      AND l.TYPE NOT IN ($1, $2)
-    INNER JOIN temp_op2 op ON i.product_id = op."productId"::uuid
-      AND i.batch_id = op."batchId"
-      AND i.packing_type = op."packingType"
-      AND i.packing_size = op."packingSize"
-    LEFT JOIN acc_oi2 foo ON i.id = foo.inventory_id
-    WHERE i.domain_id = $3
-    AND i.bizplace_id = $4
-    AND i.status = $5
-    ORDER BY op."productId", rn
-  `,
-    [LOCATION_TYPE.QUARANTINE, LOCATION_TYPE.RESERVE, domainId, bizplaceId, INVENTORY_STATUS.STORED]
-  )
-
-  await trxMgr.query('DROP TABLE temp_op2, acc_oi2')
-
-  return inventories
-}