@things-factory/operato-wms 6.1.83 → 6.1.85

package/server/graphql/resolvers/other/add-release-good-products.ts

@@ -1,413 +0,0 @@
-import { In, Not } from 'typeorm'
-
-import { Bizplace } from '@things-factory/biz-base'
-import { Product } from '@things-factory/product-base'
-import {
-  ORDER_INVENTORY_STATUS,
-  ORDER_PRODUCT_STATUS,
-  OrderInventory,
-  OrderNoGenerator,
-  OrderProduct,
-  ReleaseGood
-} from '@things-factory/sales-base'
-import { Inventory } from '@things-factory/warehouse-base'
-import {
-  generatePickingWorksheetDetail,
-  Worksheet,
-  WORKSHEET_STATUS,
-  WORKSHEET_TYPE,
-  WorksheetDetail
-} from '@things-factory/worksheet-base'
-
-export const addReleaseGoodProducts = {
-  async addReleaseGoodProducts(_: any, { name, orderInventories, existingOrderInventories }, context: ResolverContext) {
-    try {
-      const { tx, user, domain } = context.state
-
-      let releaseGood: ReleaseGood = await tx.getRepository(ReleaseGood).findOne({
-        where: { domain: { id: domain.id }, name: name },
-        relations: ['bizplace', 'orderProducts']
-      })
-
-      const bizplace: Bizplace = releaseGood.bizplace
-
-      let pickingWorksheet: Worksheet = await tx.getRepository(Worksheet).findOne({
-        where: { releaseGood, type: WORKSHEET_TYPE.PICKING }
-      })
-
-      let loadingWorksheet: Worksheet = await tx.getRepository(Worksheet).findOne({
-        where: { releaseGood, type: WORKSHEET_TYPE.LOADING }
-      })
-
-      if (existingOrderInventories) {
-        for (let oi of existingOrderInventories) {
-          // map input to OrderInventory Object
-          let curOrderInv: OrderInventory = Object.assign({}, oi)
-          curOrderInv.domain = domain
-          curOrderInv.bizplace = bizplace
-          curOrderInv.releaseGood = releaseGood
-          curOrderInv.product = await tx.getRepository(Product).findOneBy({ id: oi.product.id })
-
-          let existingOrderInv: OrderInventory
-
-          if (curOrderInv?.inventory?.id) {
-            const foundInv: Inventory = await tx.getRepository(Inventory).findOneBy({ id: curOrderInv.inventory.id })
-            curOrderInv.inventory = foundInv
-
-            existingOrderInv = await tx.getRepository(OrderInventory).findOne({
-              where: {
-                releaseGood,
-                product: curOrderInv.product,
-                batchId: curOrderInv.batchId,
-                packingType: curOrderInv.packingType,
-                inventory: foundInv
-              }
-            })
-
-            if (foundInv && foundInv.lockedQty == 0) {
-              foundInv.qty += Number(existingOrderInv.releaseQty)
-              foundInv.uomValue += Number(existingOrderInv.releaseUomValue)
-              foundInv.lockedQty = Number(existingOrderInv.releaseQty)
-              foundInv.lockedUomValue = Number(existingOrderInv.releaseUomValue)
-            }
-
-            if (curOrderInv.releaseQty < existingOrderInv.pickedQty) {
-              throw new Error(`${curOrderInv.inventory.palletId} has already picked ${existingOrderInv.pickedQty}`)
-            }
-
-            if (curOrderInv.releaseQty === 0) {
-              foundInv.lockedQty = Number(foundInv.lockedQty) - Number(existingOrderInv.releaseQty)
-              foundInv.lockedUomValue = Number(foundInv.lockedUomValue) - Number(existingOrderInv.releaseUomValue)
-
-              await tx.getRepository(Inventory).save(foundInv)
-
-              if (existingOrderInv) {
-                // if found existing OrderInventory and worksheetDetail then qty, uomValue, and status are updated
-                curOrderInv = {
-                  ...existingOrderInv,
-                  releaseQty: curOrderInv.releaseQty,
-                  releaseUomValue: curOrderInv.releaseUomValue,
-                  lockedUomValue: curOrderInv.lockedUomValue,
-                  status: ORDER_INVENTORY_STATUS.CANCELLED
-                }
-
-                let existingWorksheetDetail: WorksheetDetail = await tx.getRepository(WorksheetDetail).findOne({
-                  where: {
-                    worksheet: { id: pickingWorksheet.id },
-                    type: WORKSHEET_TYPE.PICKING,
-                    targetInventory: { id: curOrderInv.id }
-                  }
-                })
-
-                existingWorksheetDetail = {
-                  ...existingWorksheetDetail,
-                  status: WORKSHEET_STATUS.CANCELLED
-                }
-                await tx.getRepository(WorksheetDetail).save(existingWorksheetDetail)
-                await tx.getRepository(OrderInventory).save(curOrderInv)
-              }
-            } else if (curOrderInv.releaseQty == existingOrderInv.pickedQty) {
-              curOrderInv = {
-                ...existingOrderInv,
-                releaseQty: curOrderInv.releaseQty,
-                releaseUomValue: curOrderInv.releaseUomValue,
-                lockedUomValue: curOrderInv.lockedUomValue,
-                status: ORDER_INVENTORY_STATUS.PICKED
-              }
-
-              let existingWorksheetDetail: WorksheetDetail = await tx.getRepository(WorksheetDetail).findOne({
-                where: {
-                  targetInventory: { id: curOrderInv.id }
-                }
-              })
-
-              existingWorksheetDetail = {
-                ...existingWorksheetDetail,
-                status: WORKSHEET_STATUS.PICKED
-              }
-
-              await tx.getRepository(WorksheetDetail).save(existingWorksheetDetail)
-              await tx.getRepository(OrderInventory).save(curOrderInv)
-            } else {
-              foundInv.updater = user
-              foundInv.lockedQty =
-                foundInv.lockedQty - Number(existingOrderInv.releaseQty) + Number(curOrderInv.releaseQty)
-              foundInv.lockedUomValue =
-                foundInv.lockedUomValue - Number(existingOrderInv.releaseUomValue) + Number(curOrderInv.releaseUomValue)
-
-              await tx.getRepository(Inventory).save(foundInv)
-
-              if (existingOrderInv) {
-                // if found existing OrderInventory and worksheetDetail then qty, uomValue, and status are updated
-                curOrderInv = {
-                  ...existingOrderInv,
-                  releaseQty: curOrderInv.releaseQty,
-                  releaseUomValue: curOrderInv.releaseUomValue,
-                  status: ORDER_INVENTORY_STATUS.PICKING
-                }
-
-                let existingWorksheetDetail: WorksheetDetail = await tx.getRepository(WorksheetDetail).findOne({
-                  where: {
-                    worksheet: { id: pickingWorksheet.id },
-                    type: WORKSHEET_TYPE.PICKING,
-                    targetInventory: { id: existingOrderInv.id }
-                  }
-                })
-
-                if (existingWorksheetDetail) {
-                  if (curOrderInv.releaseQty != existingOrderInv.releaseQty) {
-                    existingWorksheetDetail = {
-                      ...existingWorksheetDetail,
-                      status: WORKSHEET_STATUS.DEACTIVATED
-                    }
-
-                    await tx.getRepository(WorksheetDetail).save(existingWorksheetDetail)
-                  }
-                }
-
-                await tx.getRepository(OrderInventory).save(curOrderInv)
-              }
-            }
-
-            if (pickingWorksheet) {
-              // if has picking worksheet, status will be deactivated to prevent any action from warehouse operator until office admin has confirmation
-              pickingWorksheet = {
-                ...pickingWorksheet,
-                status: WORKSHEET_STATUS.DEACTIVATED
-              }
-              await tx.getRepository(Worksheet).save(pickingWorksheet)
-            }
-
-            if (loadingWorksheet) {
-              // if has loading worksheet, status will be deactivated to prevent any action from warehouse operator until office admin has confirmation
-              loadingWorksheet = {
-                ...loadingWorksheet,
-                status: WORKSHEET_STATUS.DEACTIVATED
-              }
-
-              await tx.getRepository(Worksheet).save(loadingWorksheet)
-            }
-          }
-        }
-      }
-
-      if (orderInventories) {
-        for (let oi of orderInventories) {
-          // map input to OrderInventory Object
-          let newOrderInv: OrderInventory = Object.assign({}, oi)
-          newOrderInv.domain = domain
-          newOrderInv.bizplace = bizplace
-          newOrderInv.batchId = oi.batchId
-          newOrderInv.packingType = oi.packingType
-          newOrderInv.status = pickingWorksheet ? ORDER_INVENTORY_STATUS.PICKING : ORDER_INVENTORY_STATUS.PENDING
-          newOrderInv.name = OrderNoGenerator.orderInventory()
-          newOrderInv.releaseGood = releaseGood
-          newOrderInv.product = await tx.getRepository(Product).findOneBy({ id: oi.product.id })
-          newOrderInv.creator = user
-          newOrderInv.updater = user
-
-          let existingOrderInv: OrderInventory
-
-          let existingOrderProduct: OrderProduct = await tx.getRepository(OrderProduct).findOne({
-            where: {
-              domain: { id: domain.id },
-              releaseGood: { id: releaseGood.id },
-              batchId: oi.batchId,
-              packingType: oi.packingType,
-              product: { id: newOrderInv.product.id }
-            }
-          })
-
-          // check if it is release by inventory (has inventory value) or product
-          if (newOrderInv.inventory?.id) {
-            // if release by inventory, then quantity and uomValue values are updated
-            const foundInv: Inventory = await tx.getRepository(Inventory).findOneBy({ id: newOrderInv.inventory.id })
-            newOrderInv.inventory = foundInv
-            newOrderInv.uom = oi?.uom || foundInv.uom
-            newOrderInv.batchIdRef = oi?.batchIdRef || foundInv.batchIdRef
-
-            // check for existing released OrderInventory specifying product, batchId, packingType, and inventory
-            existingOrderInv = await tx.getRepository(OrderInventory).findOne({
-              where: {
-                releaseGood: { id: releaseGood.id },
-                product: { id: newOrderInv.product.id },
-                batchId: newOrderInv.batchId,
-                packingType: newOrderInv.packingType,
-                inventory: { id: foundInv.id }
-              }
-            })
-
-            foundInv.lockedQty = Number(foundInv.lockedQty) + newOrderInv.releaseQty
-            foundInv.lockedUomValue = Number(foundInv.lockedUomValue) + newOrderInv.releaseUomValue
-            foundInv.updater = user
-
-            let newOrderProduct: OrderProduct = Object.assign(new OrderProduct(), newOrderInv)
-            newOrderProduct = {
-              ...newOrderProduct,
-              packQty: 0,
-              actualPackQty: 0,
-              palletQty: 0,
-              actualPalletQty: 0,
-              status: ORDER_PRODUCT_STATUS.ASSIGNED
-            }
-
-            if (!existingOrderProduct) newOrderProduct = await tx.getRepository(OrderProduct).save(newOrderProduct)
-
-            newOrderInv.orderProduct = existingOrderProduct ? existingOrderProduct : newOrderProduct
-
-            await tx.getRepository(Inventory).save(foundInv)
-          } else {
-            // check for existing released OrderInventory specifying product, batchId and packingType
-            existingOrderInv = await tx.getRepository(OrderInventory).findOne({
-              where: {
-                releaseGood: { id: releaseGood.id },
-                product: { id: newOrderInv.product.id },
-                batchId: newOrderInv.batchId,
-                packingType: newOrderInv.packingType
-              }
-            })
-          }
-
-          if (existingOrderInv) {
-            // if found existing OrderInventory and worksheetDetail then qty, uomValue, and status are updated
-            newOrderInv = {
-              ...existingOrderInv,
-              releaseQty:
-                existingOrderInv.status === ORDER_INVENTORY_STATUS.REPLACED
-                  ? newOrderInv.releaseQty
-                  : existingOrderInv.releaseQty + newOrderInv.releaseQty,
-              releaseUomValue: ORDER_INVENTORY_STATUS.REPLACED
-                ? newOrderInv.releaseUomValue
-                : existingOrderInv.releaseUomValue + newOrderInv.releaseUomValue,
-              status:
-                existingOrderInv.status === ORDER_INVENTORY_STATUS.CANCELLED
-                  ? pickingWorksheet
-                    ? ORDER_INVENTORY_STATUS.PICKING
-                    : ORDER_INVENTORY_STATUS.PENDING
-                  : existingOrderInv.status
-            }
-
-            let existingWorksheetDetail: WorksheetDetail = await tx.getRepository(WorksheetDetail).findOne({
-              where: {
-                worksheet: { id: pickingWorksheet.id },
-                type: WORKSHEET_TYPE.PICKING,
-                targetInventory: { id: existingOrderInv.id }
-              }
-            })
-
-            if (existingWorksheetDetail) {
-              existingWorksheetDetail = {
-                ...existingWorksheetDetail,
-                targetProduct: newOrderInv.orderProduct,
-                status: WORKSHEET_STATUS.DEACTIVATED
-              }
-
-              await tx.getRepository(WorksheetDetail).save(existingWorksheetDetail)
-            }
-          }
-
-          if (pickingWorksheet) {
-            // if has picking worksheet, status will be deactivated to prevent any action from warehouse operator until office admin has confirmation
-            pickingWorksheet = {
-              ...pickingWorksheet,
-              status: WORKSHEET_STATUS.DEACTIVATED
-            }
-
-            let savedOrderInv: OrderInventory = new OrderInventory()
-            savedOrderInv.name = newOrderInv.name
-            savedOrderInv.type = newOrderInv.type
-            savedOrderInv.releaseQty = newOrderInv.releaseQty
-            savedOrderInv.releaseUomValue = newOrderInv.releaseUomValue
-            savedOrderInv.batchId = newOrderInv.batchId
-            savedOrderInv.batchIdRef = newOrderInv.batchIdRef
-            savedOrderInv.packingType = newOrderInv.packingType
-            savedOrderInv.uom = newOrderInv.uom
-            savedOrderInv.product = newOrderInv.product
-            savedOrderInv.inventory = newOrderInv.inventory
-            savedOrderInv.status = newOrderInv.status
-            savedOrderInv.releaseGood = newOrderInv.releaseGood
-            savedOrderInv.orderProduct = newOrderInv.orderProduct
-            savedOrderInv.bizplace = newOrderInv.bizplace
-            savedOrderInv.domain = domain
-            savedOrderInv.creator = user
-            savedOrderInv.updater = user
-
-            if (newOrderInv?.id) {
-              // newOrderInv will have id if it was updated from existingOrderInv
-              // this solution will remove ix_order-inventory_0 unique error
-              // ** please revise this resolver in future. looks like there's few
-              //    things that can refactor
-              savedOrderInv.id = newOrderInv.id
-            }
-
-            savedOrderInv = await tx.getRepository(OrderInventory).save(savedOrderInv)
-
-            if (!existingOrderInv && pickingWorksheet) {
-              // if this is a new orderInventory and has existing worksheet then generate a new worksheet detail for it
-              await generatePickingWorksheetDetail(tx, domain, user, pickingWorksheet, savedOrderInv)
-            }
-          }
-        }
-
-        await tx.getRepository(Worksheet).save(pickingWorksheet)
-      }
-
-      if (loadingWorksheet) {
-        // if has loading worksheet, status will be deactivated to prevent any action from warehouse operator until office admin has confirmation
-        loadingWorksheet = {
-          ...loadingWorksheet,
-          status: WORKSHEET_STATUS.DEACTIVATED
-        }
-
-        await tx.getRepository(Worksheet).save(loadingWorksheet)
-      }
-
-      // Update Order Product Release Qty
-      let rgOrderProducts: OrderProduct[] = await tx
-        .getRepository(OrderProduct)
-        .find({ where: { domain: { id: domain.id }, releaseGood: { id: releaseGood.id } } })
-
-      await Promise.all(
-        rgOrderProducts.map(async op => {
-          const orderInventories: OrderInventory[] = await tx.getRepository(OrderInventory).find({
-            where: {
-              domain: { id: domain.id },
-              releaseGood: { id: releaseGood.id },
-              orderProduct: { id: op.id },
-              status: Not(
-                In([
-                  ORDER_INVENTORY_STATUS.TERMINATED,
-                  ORDER_INVENTORY_STATUS.CANCELLED,
-                  ORDER_INVENTORY_STATUS.PENDING_CANCEL
-                ])
-              )
-            }
-          })
-
-          let totalReleaseQty: number = orderInventories.reduce((total, currentValue) => {
-            total += currentValue.releaseQty
-            return total
-          }, 0)
-
-          let totalReleaseUomValue: number = orderInventories.reduce((total, currentValue) => {
-            total += currentValue.releaseUomValue
-            return total
-          }, 0)
-
-          let updateOPInfo: any = {
-            releaseQty: totalReleaseQty,
-            releaseUomValue: totalReleaseUomValue
-          }
-
-          if (totalReleaseQty <= 0) {
-            updateOPInfo.status = ORDER_PRODUCT_STATUS.TERMINATED
-          }
-
-          await tx.getRepository(OrderProduct).update({ id: op.id }, updateOPInfo)
-        })
-      )
-    } catch (error) {
-      throw error
-    }
-  }
-}

package/server/graphql/resolvers/other/index.ts

@@ -1,10 +0,0 @@
-import { addReleaseGoodProducts } from './add-release-good-products'
-import { pageSettings } from './page-settings'
-
-export const Query = {
-    ...pageSettings
-}
-
-export const Mutation = {
-    ...addReleaseGoodProducts
-}

package/server/graphql/resolvers/other/page-settings.ts

@@ -1,105 +0,0 @@
-import { getRepository, EntityManager, In } from 'typeorm'
-
-import { Sequence, SEQUENCE_TYPE } from '@things-factory/id-rule-base'
-import { buildQuery, Domain, ListParam, convertListParams } from '@things-factory/shell'
-import { User } from '@things-factory/auth-base'
-import {
-  getMyBizplace,
-  getPartnerBizplaceIds,
-  getPartnersBizplaces,
-  getPartnersCompanyBizplaces,
-  getPermittedBizplaceIds,
-  Bizplace
-} from '@things-factory/biz-base'
-
-import { CommonCode as CommonCodeEntity, CommonCodeDetail as CommonCodeDetailEntity } from '@things-factory/code-base'
-
-export const pageSettings = {
-  async pageSettings(_: any, { codes, partners }, context: any) {
-    const { domain, user, tx }: { domain: Domain; user: User; tx: EntityManager } = context.state
-    try {
-      let promiseTask = []
-      if (codes) {
-        promiseTask.push(queryCommonCode(codes, domain, tx, context))
-      }
-
-      if (partners) {
-        promiseTask.push(queryPartners(partners, domain, tx, context))
-      }
-
-      return await Promise.all(promiseTask)
-    } catch (error) {
-      throw error
-    }
-  }
-}
-
-async function queryCommonCode(codes, domain, tx, context) {
-  const codeQb = tx.getRepository(CommonCodeEntity).createQueryBuilder('cc')
-  buildQuery(codeQb, { filters: codes }, context)
-
-  codes = (await codeQb
-    .leftJoinAndSelect('cc.details', 'ccdet')
-    .orderBy('cc.name')
-    .addOrderBy('ccdet.rank')
-    .addOrderBy('ccdet.name')
-    .getMany()).map((cc: CommonCodeEntity) => {
-      return {
-        id: cc.id,
-        name: cc.name,
-        description: cc.description,
-        settingDetails: cc.details.map(det => {
-          return {
-            id: det.id,
-            name: det.name,
-            description: det.description,
-            rank: det.rank
-          }
-        })
-      }
-    })
-
-  return {
-    type: 'code',
-    details: codes
-  }
-}
-
-async function queryPartners(partners, domain, tx, context) {
-  let partnersBizplaceIds = []
-  let bizplaceIndex: any = partners.filters?.findIndex(x => x.name === 'bizplace')
-  if (bizplaceIndex && bizplaceIndex > -1) {
-    partnersBizplaceIds = partners.filters
-      .filter(x => x.name === 'bizplace')
-      .map(item => {
-        return item.value
-      })
-    partners.filters.splice(bizplaceIndex, 1)
-  }
-
-  const convertedParams = convertListParams({ filters: partners })
-
-  if (!(partnersBizplaceIds.length > 0)) {
-    const partnersBizplaces: Bizplace[] = await getPartnersBizplaces(context.state.domain, context.state.user)
-    partnersBizplaceIds = partnersBizplaces.map((bizplace: Bizplace) => bizplace.id || null)
-    convertedParams.where.id = In(partnersBizplaceIds)
-  } else {
-    convertedParams.where.id = In(partnersBizplaceIds)
-  }
-
-  partners = ((await tx.getRepository(Bizplace).find({
-    ...convertedParams,
-    relations: ['domain', 'company', 'users', 'creator', 'updater']
-  })).map((biz: Bizplace) => {
-    return {
-      id: biz.id,
-      name: biz.name,
-      description: biz.description,
-    }
-  }))
-
-  return {
-    type: 'partner',
-    details: partners
-  }
-}