@things-factory/sales-base 3.6.46 → 3.6.50

package/server/graphql/resolvers/reverse-kitting-order/reverse-kitting-inventories.ts

@@ -0,0 +1,37 @@
+import { getRepository } from 'typeorm'
+
+import { Bizplace } from '@things-factory/biz-base'
+import { Domain } from '@things-factory/shell'
+import { Inventory, INVENTORY_STATUS } from '@things-factory/warehouse-base'
+
+import { ORDER_VAS_STATUS } from '../../../constants'
+import { OrderReverseKitting, ReverseKittingOrder } from '../../../entities'
+
+export const reverseKittingInventoriesResolver = {
+  async reverseKittingInventories(_: any, { orderReverseKittingName }, context: any) {
+    const { domain }: { domain: Domain } = context.state
+    const foundOrderReverseKitting: OrderReverseKitting = await getRepository(OrderReverseKitting).findOne({
+      where: {
+        domain,
+        name: orderReverseKittingName,
+        status: ORDER_VAS_STATUS.PROCESSING
+      },
+      relations: ['bizplace', 'reverseKittingOrder', 'inventory']
+    })
+
+    if (!foundOrderReverseKitting) return
+
+    const reverseKittingOrder: ReverseKittingOrder = foundOrderReverseKitting.reverseKittingOrder
+    const customerBizplace: Bizplace = foundOrderReverseKitting.bizplace
+    return await getRepository(Inventory).find({
+      where: {
+        domain,
+        bizplace: customerBizplace,
+        refOrderId: reverseKittingOrder.id,
+        orderVasId: foundOrderReverseKitting.id,
+        status: INVENTORY_STATUS.STORED
+      },
+      relations: ['product', 'bizplace']
+    })
+  }
+}

package/server/graphql/resolvers/reverse-kitting-order/reverse-kitting-order.ts

@@ -0,0 +1,34 @@
+import { getRepository, In } from 'typeorm'
+
+import { User } from '@things-factory/auth-base'
+import { getPermittedBizplaceIds } from '@things-factory/biz-base'
+import { Domain } from '@things-factory/shell'
+
+import { ReverseKittingOrder } from '../../../entities'
+
+export const reverseKittingOrderResolver = {
+  async reverseKittingOrder(_: any, { name }, context: any) {
+    const { domain, user }: { domain: Domain; user: User } = context.state
+
+    return await getRepository(ReverseKittingOrder).findOne({
+      where: {
+        domain,
+        name,
+        bizplace: In(await getPermittedBizplaceIds(domain, user))
+      },
+      relations: [
+        'domain',
+        'bizplace',
+        'orderReverseKittings',
+        'orderReverseKittings.vas',
+        'orderReverseKittings.inventory',
+        'orderReverseKittings.inventory.product',
+        'orderReverseKittings.inventory.location',
+        'orderReverseKittings.inventory.warehouse',
+        'orderReverseKittings.targetProduct',
+        'creator',
+        'updater'
+      ]
+    })
+  }
+}

package/server/graphql/resolvers/reverse-kitting-order/reverse-kitting-orders.ts

@@ -0,0 +1,30 @@
+import { getRepository, In } from 'typeorm'
+
+import { User } from '@things-factory/auth-base'
+import { getPermittedBizplaceIds } from '@things-factory/biz-base'
+import { convertListParams, Domain, ListParam } from '@things-factory/shell'
+
+import { ReverseKittingOrder } from '../../../entities'
+
+export const reverseKittingOrdersResolver = {
+  async reverseKittingOrders(_: any, params: ListParam, context: any) {
+    const { domain, user }: { domain: Domain; user: User } = context.state
+
+    const convertedParams = convertListParams(params)
+    convertedParams.where.bizplace = In(await getPermittedBizplaceIds(domain, user))
+
+    const [items, total] = await getRepository(ReverseKittingOrder).findAndCount({
+      ...convertedParams,
+      relations: [
+        'domain',
+        'bizplace',
+        'orderReverseKittings',
+        'orderReverseKittings.inventory',
+        'orderReverseKittings.inventory.product',
+        'creator',
+        'updater'
+      ]
+    })
+    return { items, total }
+  }
+}

package/server/graphql/types/index.ts

@@ -1,26 +1,28 @@
-import * as RetailReplenishmentOrder from './retail-replenishment-order'
-import * as TransferOrder from './transfer-order'
 import * as ArrivalNotice from './arrival-notice'
+import * as Claim from './claim'
+import * as ClaimDetail from './claim-detail'
+import * as ClaimOrder from './claim-order'
 import * as CollectionOrder from './collection-order'
 import * as DeliveryOrder from './delivery-order'
+import * as GoodsReceivalNote from './goods-receival-note'
+import * as InventoryCheck from './inventory-check'
 import * as Invoice from './invoice'
+import * as JobSheet from './job-sheet'
+import * as OrderInventory from './order-inventory'
 import * as OrderProduct from './order-product'
+import * as OrderReverseKitting from './order-reverse-kitting'
 import * as OrderVas from './order-vas'
-import * as OrderInventory from './order-inventory'
-import * as InventoryCheck from './inventory-check'
-import * as JobSheet from './job-sheet'
+import * as Others from './others'
 import * as PurchaseOrder from './purchase-order'
 import * as PurchaseOrderOtherCharge from './purchase-order-other-charge'
-import * as ShippingOrder from './shipping-order'
 import * as ReleaseGood from './release-good'
+import * as RetailReplenishmentOrder from './retail-replenishment-order'
 import * as ReturnOrder from './return-order'
+import * as ReverseKittingOrder from './reverse-kitting-order'
+import * as ShippingOrder from './shipping-order'
+import * as TransferOrder from './transfer-order'
 import * as Vas from './vas'
-import * as Claim from './claim'
-import * as ClaimDetail from './claim-detail'
-import * as ClaimOrder from './claim-order'
 import * as VasOrder from './vas-order'
-import * as GoodsReceivalNote from './goods-receival-note'
-import * as Others from './others'
 
 export const queries = [
   RetailReplenishmentOrder.Query,
@@ -45,7 +47,9 @@ export const queries = [
   OrderInventory.Query,
   VasOrder.Query,
   GoodsReceivalNote.Query,
-  Others.Query
+  Others.Query,
+  OrderReverseKitting.Query,
+  ReverseKittingOrder.Query
 ]
 
 export const mutations = [
@@ -70,7 +74,9 @@ export const mutations = [
   ClaimOrder.Mutation,
   OrderInventory.Mutation,
   VasOrder.Mutation,
-  GoodsReceivalNote.Mutation
+  GoodsReceivalNote.Mutation,
+  ReverseKittingOrder.Mutation,
+  OrderReverseKitting.Mutation
 ]
 
 export const types = [
@@ -96,5 +102,7 @@ export const types = [
   ...OrderInventory.Types,
   ...VasOrder.Types,
   ...GoodsReceivalNote.Types,
-  ...Others.Types
+  ...Others.Types,
+  ...ReverseKittingOrder.Types,
+  ...OrderReverseKitting.Types
 ]

package/server/graphql/types/order-reverse-kitting/index.ts

@@ -0,0 +1,13 @@
+import { NewOrderReverseKitting } from './new-order-reverse-kitting'
+import { OrderReverseKitting } from './order-reverse-kitting'
+import { OrderReverseKittingList } from './order-reverse-kitting-list'
+import { OrderReverseKittingPatch } from './order-reverse-kitting-patch'
+
+export const Mutation = ``
+
+export const Query = `
+  orderReverseKittings(filters: [Filter], pagination: Pagination, sortings: [Sorting]): OrderReverseKittingList
+  orderReverseKitting(reverseKitting: ObjectRef!, name: String!): OrderReverseKitting
+`
+
+export const Types = [OrderReverseKitting, NewOrderReverseKitting, OrderReverseKittingPatch, OrderReverseKittingList]

package/server/graphql/types/order-reverse-kitting/new-order-reverse-kitting.ts

@@ -0,0 +1,25 @@
+import gql from 'graphql-tag'
+
+export const NewOrderReverseKitting = gql`
+  input NewOrderReverseKitting {
+    name: String
+    set: Int
+    targetType: String
+    targetBatchId: String
+    targetProduct: ObjectRef
+    otherTarget: String
+    qty: Int
+    uomValue: Float
+    batchId: String
+    productName: String
+    packingType: String
+    reverseKittingOrder: ObjectRef
+    inventory: ObjectRef
+    vas: ObjectRef
+    type: String
+    operationGuide: String
+    remark: String
+    description: String
+    status: String
+  }
+`

package/server/graphql/types/order-reverse-kitting/order-reverse-kitting-list.ts

@@ -0,0 +1,8 @@
+import gql from 'graphql-tag'
+
+export const OrderReverseKittingList = gql`
+  type OrderReverseKittingList {
+    items: [OrderReverseKitting]
+    total: Int
+  }
+`

package/server/graphql/types/order-reverse-kitting/order-reverse-kitting-patch.ts

@@ -0,0 +1,26 @@
+import gql from 'graphql-tag'
+
+export const OrderReverseKittingPatch = gql`
+  input OrderReverseKittingPatch {
+    id: String
+    name: String
+    set: Int
+    targetType: String
+    targetBatchId: String
+    targetProduct: ObjectRef
+    otherTarget: String
+    qty: Int
+    uomValue: Float
+    batchId: String
+    productName: String
+    packingType: String
+    reverseKittingOrder: ObjectRef
+    inventory: ObjectRef
+    vas: ObjectRef
+    operationGuide: String
+    remark: String
+    description: String
+    status: String
+    cuFlag: String
+  }
+`

package/server/graphql/types/order-reverse-kitting/order-reverse-kitting.ts

@@ -0,0 +1,31 @@
+import gql from 'graphql-tag'
+
+export const OrderReverseKitting = gql`
+  type OrderReverseKitting {
+    id: String
+    domain: Domain
+    bizplace: Bizplace
+    name: String
+    set: Int
+    targetType: String
+    targetBatchId: String
+    targetProduct: Product
+    otherTarget: String
+    qty: Int
+    uomValue: Float
+    batchId: String
+    productName: String
+    packingType: String
+    reverseKittingOrder: ReverseKittingOrder
+    inventory: Inventory
+    vas: Vas
+    operationGuide: String
+    remark: String
+    description: String
+    status: String
+    createdAt: String
+    updatedAt: String
+    creator: User
+    updater: User
+  }
+`

package/server/graphql/types/reverse-kitting-order/index.ts

@@ -0,0 +1,46 @@
+import { NewReverseKittingOrder } from './new-reverse-kitting-order'
+import { ReverseKittingOrder } from './reverse-kitting-order'
+import { ReverseKittingOrderList } from './reverse-kitting-order-list'
+import { ReverseKittingOrderPatch } from './reverse-kitting-order-patch'
+
+export const Mutation = `
+  deleteReverseKittingOrder (
+    name: String!
+  ): Boolean @transaction
+
+  generateReverseKittingOrder (
+    reverseKittingOrder: NewReverseKittingOrder!
+  ): ReverseKittingOrder @transaction
+
+  confirmReverseKittingOrder (
+    name: String!
+  ): ReverseKittingOrder @transaction
+
+  activateReverseKittingOrder (
+    name: String!
+  ): ReverseKittingOrder @transaction
+
+  cancelReverseKittingOrder (
+    name: String!
+  ): ReverseKittingOrder @transaction
+
+  executeReverseKitting (
+    name: String!
+    inventory: InventoryPatch!
+  ): Boolean @privilege(category: "worksheet_execute", privilege: "mutation") @transaction
+
+  completeReverseKittingOrder (
+    name: String!
+  ): Boolean @privilege(category: "worksheet_execute", privilege: "mutation") @transaction
+`
+
+export const Query = `
+  reverseKittingOrders(filters: [Filter], pagination: Pagination, sortings: [Sorting]): ReverseKittingOrderList
+  reverseKittingOrder(name: String!): ReverseKittingOrder
+  executingReverseKittingOrder(name: String!): ReverseKittingOrder
+  reverseKittingInventories (
+    orderReverseKittingName: String!
+  ): [Inventory]
+`
+
+export const Types = [ReverseKittingOrder, NewReverseKittingOrder, ReverseKittingOrderPatch, ReverseKittingOrderList]

package/server/graphql/types/reverse-kitting-order/new-reverse-kitting-order.ts

@@ -0,0 +1,11 @@
+import gql from 'graphql-tag'
+
+export const NewReverseKittingOrder = gql`
+  input NewReverseKittingOrder {
+    name: String
+    customerBizplaceId: String
+    description: String
+    orderReverseKittings: [NewOrderReverseKitting]
+    status: String
+  }
+`

package/server/graphql/types/reverse-kitting-order/reverse-kitting-order-list.ts

@@ -0,0 +1,8 @@
+import gql from 'graphql-tag'
+
+export const ReverseKittingOrderList = gql`
+  type ReverseKittingOrderList {
+    items: [ReverseKittingOrder]
+    total: Int
+  }
+`

package/server/graphql/types/reverse-kitting-order/reverse-kitting-order-patch.ts

@@ -0,0 +1,11 @@
+import gql from 'graphql-tag'
+
+export const ReverseKittingOrderPatch = gql`
+  input ReverseKittingOrderPatch {
+    name: String
+    description: String
+    orderReverseKittings: [ObjectRef]
+    status: String
+    remark: String
+  }
+`

package/server/graphql/types/reverse-kitting-order/reverse-kitting-order.ts

@@ -0,0 +1,18 @@
+import gql from 'graphql-tag'
+
+export const ReverseKittingOrder = gql`
+  type ReverseKittingOrder {
+    id: String
+    name: String
+    domain: Domain
+    bizplace: Bizplace
+    description: String
+    orderReverseKittings: [OrderReverseKitting]
+    status: String
+    remark: String
+    updater: User
+    creator: User
+    updatedAt: String
+    createdAt: String
+  }
+`

package/server/utils/inventory-util.ts

@@ -1,13 +1,40 @@
-import { EntityManager, In, Raw } from 'typeorm'
+import { EntityManager, Equal, getRepository, In, Not, Raw, Repository } from 'typeorm'
 
+import { User } from '@things-factory/auth-base'
 import { Bizplace } from '@things-factory/biz-base'
 import { Product, ProductBundle } from '@things-factory/product-base'
 import { Domain, ListParam } from '@things-factory/shell'
-import { Inventory } from '@things-factory/warehouse-base'
+import {
+  Inventory,
+  INVENTORY_STATUS,
+  InventoryHistory,
+  InventoryNoGenerator,
+  Location,
+  LOCATION_STATUS,
+  Pallet
+} from '@things-factory/warehouse-base'
 
-import { OrderInventory } from '../entities'
+import {
+  ArrivalNotice,
+  DeliveryOrder,
+  InventoryCheck,
+  OrderInventory,
+  ReleaseGood,
+  ReturnOrder,
+  ReverseKittingOrder,
+  VasOrder
+} from '../entities'
 import { ValidationError } from '../errors'
 
+export type ReferenceOrderType =
+  | ArrivalNotice
+  | ReleaseGood
+  | VasOrder
+  | InventoryCheck
+  | DeliveryOrder
+  | ReturnOrder
+  | ReverseKittingOrder
+
 export const InventoryUtil = {
   /**
    * Get all available product belonging to list of bizplaces
@@ -211,6 +238,50 @@ export const InventoryUtil = {
         })
       }
     })
+  },
+
+  async checkPalletDuplication(palletId: string, warehouseDomain: Domain, trxMgr: EntityManager): Promise<void> {
+    const duplicatedPalletCnt: number = await trxMgr.getRepository(Inventory).count({
+      domain: warehouseDomain,
+      palletId,
+      status: Not(Equal(INVENTORY_STATUS.TERMINATED))
+    })
+
+    if (duplicatedPalletCnt) throw new Error(palletId + ` exists`)
+
+    const duplicatedReusablePalletCnt: number = await trxMgr.getRepository(Pallet).count({
+      where: {
+        domain: warehouseDomain,
+        name: palletId
+      }
+    })
+
+    if (duplicatedReusablePalletCnt) throw new Error(palletId + ` exists`)
+  },
+
+  /**
+   * @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: Partial<Inventory>,
+    referenceOrder: ReferenceOrderType,
+    changedQty: number,
+    changedWeight: number,
+    transactionType: string,
+    user: User,
+    trxMgr: EntityManager
+  ): Promise<Inventory> {
+    if (inventory.id) {
+      inventory = await updateInventory(inventory, trxMgr)
+    } else {
+      inventory = await createInventory(inventory, trxMgr)
+    }
+
+    await generateInventoryHistory(inventory, referenceOrder, transactionType, changedQty, changedWeight, user, trxMgr)
+
+    return inventory
   }
 }
 
@@ -372,3 +443,156 @@ async function getConditions(
 
   return { bizplaceIds, productWhereClause, bundleWhereClause, whereClause, batchBundle }
 }
+
+async function createInventory(
+  inventory: Partial<Inventory> | Partial<Inventory>[],
+  trxMgr: EntityManager
+): Promise<Inventory | Inventory[]> {
+  return await 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 function updateInventory(
+  inventory: Partial<Inventory> | Partial<Inventory>[],
+  trxMgr: EntityManager
+): Promise<Inventory | Inventory[]> {
+  if (!inventory.id) throw new Error(`Target doesn't have ID`)
+  return await trxMgr.getRepository(Inventory).save(inventory)
+}
+
+async function generateInventoryHistory(
+  inventory: Inventory,
+  refOrder: any,
+  transactionType: string,
+  qty: number,
+  uomValue: number,
+  user: User,
+  trxMgr?: EntityManager
+): 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.`)
+  if (!refOrder?.id || !refOrder.name) throw new Error(`Can't find out ID or Name of Reference Order`)
+  if (
+    !inventory?.domain ||
+    !inventory?.bizplace ||
+    !inventory?.product?.id ||
+    !inventory?.warehouse?.id ||
+    !inventory?.location?.id
+  ) {
+    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 seq: number = await invHistoryRepo.count({ domain: inventory.domain, palletId: inventory.palletId })
+  let openingQty: number = 0
+  let openingUomValue: number = 0
+
+  if (seq) {
+    const lastInvHistory: InventoryHistory = await invHistoryRepo.findOne({
+      domain: inventory.domain,
+      palletId: inventory.palletId,
+      seq: seq - 1
+    })
+    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.packingSize = inventory.packingSize
+  inventoryHistory.uom = inventory.uom
+  inventoryHistory.qty = qty
+  inventoryHistory.openingQty = openingQty
+  inventoryHistory.weight = 0
+  inventoryHistory.openingWeight = 0
+  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)
+
+  if (inventory.lastSeq !== seq) {
+    await invRepo.save({
+      ...inventory,
+      lastSeq: inventoryHistory.seq,
+      updater: user
+    })
+  }
+
+  await switchLocationStatus(domain, location, user, trxMgr)
+  return inventoryHistory
+}
+
+/**
+ * @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.count({
+    domain,
+    status: INVENTORY_STATUS.STORED,
+    location
+  })
+
+  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
+}