@things-factory/worksheet-base 8.0.0-beta.8 → 8.0.0

package/server/graphql/resolvers/worksheet/putaway/putaway.ts

@@ -0,0 +1,26 @@
+import { EntityManager } from 'typeorm'
+
+import { User } from '@things-factory/auth-base'
+import { Domain } from '@things-factory/shell'
+
+import { PutawayWorksheetController } from '../../../../controllers'
+
+export const putawayResolver = {
+  async putaway(_: any, { worksheetDetailName, palletId, cartonId, toLocation }, context: ResolverContext) {
+    const { tx, domain, user } = context.state
+    await putaway(tx, domain, user, worksheetDetailName, palletId, cartonId, toLocation)
+  }
+}
+
+async function putaway(
+  tx: EntityManager,
+  domain: Domain,
+  user: User,
+  worksheetDetailName: [string],
+  palletId: string,
+  cartonId: string,
+  locationName: string
+) {
+  const worksheetController: PutawayWorksheetController = new PutawayWorksheetController(tx, domain, user)
+  await worksheetController.putaway(worksheetDetailName, palletId, cartonId, locationName)
+}

package/server/graphql/resolvers/worksheet/putaway/undo-putaway.ts

@@ -0,0 +1,25 @@
+import { EntityManager } from 'typeorm'
+
+import { User } from '@things-factory/auth-base'
+import { Domain } from '@things-factory/shell'
+
+import { PutawayWorksheetController } from '../../../../controllers'
+
+export const undoPutawayResolver = {
+  async undoPutaway(_: any, { worksheetDetailName, palletId, cartonId }, context: ResolverContext) {
+    const { tx, domain, user } = context.state
+    await undoPutaway(tx, domain, user, worksheetDetailName, palletId, cartonId)
+  }
+}
+
+export async function undoPutaway(
+  tx: EntityManager,
+  domain: Domain,
+  user: User,
+  worksheetDetailName: [string],
+  palletId: string,
+  cartonId: string
+): Promise<void> {
+  const worksheetController: PutawayWorksheetController = new PutawayWorksheetController(tx, domain, user)
+  await worksheetController.undoPutaway(worksheetDetailName, palletId, cartonId)
+}

package/server/graphql/resolvers/worksheet/putaway-return/activate-putaway-return.ts

@@ -0,0 +1,55 @@
+import { EntityManager, Equal, Not } from 'typeorm'
+
+import { User } from '@things-factory/auth-base'
+import { Domain } from '@things-factory/shell'
+
+import { WORKSHEET_STATUS, WORKSHEET_TYPE } from '../../../../constants'
+import { PutawayReturningWorksheetController } from '../../../../controllers'
+import { Worksheet, WorksheetDetail } from '../../../../entities'
+
+export const activatePutawayReturnResolver = {
+  async activatePutawayReturn(_: any, { worksheetNo, putawayWorksheetDetails }, context: ResolverContext) {
+    const { tx, domain, user } = context.state
+    const foundWorksheet: Worksheet = await tx.getRepository(Worksheet).findOne({
+      where: {
+        domain: { id: domain.id },
+        name: worksheetNo,
+        status: WORKSHEET_STATUS.DEACTIVATED,
+        type: WORKSHEET_TYPE.PUTAWAY_RETURN
+      },
+      relations: ['bizplace', 'returnOrder', 'worksheetDetails', 'worksheetDetails.targetInventory']
+    })
+
+    if (!foundWorksheet) throw new Error(`Worksheet doesn't exists`)
+
+    const relatedWorksheetCnt: number = await tx.getRepository(Worksheet).count({
+      where: {
+        domain: { id: domain.id },
+        returnOrder: { id: foundWorksheet.returnOrder.id },
+        type: WORKSHEET_TYPE.VAS,
+        status: Not(Equal(WORKSHEET_STATUS.DONE))
+      }
+    })
+
+    if (relatedWorksheetCnt) {
+      throw new Error(`Related VAS order with GAN: ${foundWorksheet.arrivalNotice.name} is still under processing.`)
+    }
+
+    return await activatePutawayReturn(tx, domain, user, worksheetNo, putawayWorksheetDetails)
+  }
+}
+
+export async function activatePutawayReturn(
+  tx: EntityManager,
+  domain: Domain,
+  user: User,
+  worksheetNo: string,
+  putawayWorksheetDetails: Partial<WorksheetDetail>[]
+) {
+  const worksheetController: PutawayReturningWorksheetController = new PutawayReturningWorksheetController(
+    tx,
+    domain,
+    user
+  )
+  await worksheetController.activatePutawayReturning(worksheetNo, putawayWorksheetDetails)
+}

package/server/graphql/resolvers/worksheet/putaway-return/complete-putaway-return.ts

@@ -0,0 +1,38 @@
+import { EntityManager } from 'typeorm'
+
+import { User } from '@things-factory/auth-base'
+import { Domain } from '@things-factory/shell'
+
+import { PutawayReturningWorksheetController } from '../../../../controllers'
+import { Worksheet } from '../../../../entities'
+
+export const completePutawayReturnResolver = {
+  async completePutawayReturn(_: any, { returnOrderNo }, context: ResolverContext) {
+    const { tx, domain, user } = context.state
+    await completePutawayReturn(tx, domain, user, returnOrderNo)
+  }
+}
+
+export async function completePutawayReturn(
+  tx: EntityManager,
+  domain: Domain,
+  user: User,
+  returnOrderNo: string
+): Promise<void> {
+  const worksheetController: PutawayReturningWorksheetController = new PutawayReturningWorksheetController(
+    tx,
+    domain,
+    user
+  )
+  let worksheet: Worksheet = await worksheetController.completePutawayReturn(returnOrderNo)
+
+  /**
+   * 4. Generate the Goods Received Note straight away
+   */
+  if (!worksheet.returnOrder?.name || !worksheet.bizplace?.id) {
+    worksheet = await tx.getRepository(Worksheet).findOne({
+      where: { id: worksheet.id },
+      relations: ['bizplace', 'returnOrder']
+    })
+  }
+}

package/server/graphql/resolvers/worksheet/putaway-return/index.ts

@@ -0,0 +1,11 @@
+import { activatePutawayReturnResolver } from './activate-putaway-return'
+import { completePutawayReturnResolver } from './complete-putaway-return'
+import { putawayReturnResolver } from './putaway-return'
+import { undoPutawayReturnResolver } from './undo-putaway-return'
+
+export const Mutations = {
+  ...activatePutawayReturnResolver,
+  ...completePutawayReturnResolver,
+  ...putawayReturnResolver,
+  ...undoPutawayReturnResolver
+}

package/server/graphql/resolvers/worksheet/putaway-return/putaway-return.ts

@@ -0,0 +1,30 @@
+import { EntityManager } from 'typeorm'
+
+import { User } from '@things-factory/auth-base'
+import { Domain } from '@things-factory/shell'
+
+import { PutawayReturningWorksheetController } from '../../../../controllers'
+
+export const putawayReturnResolver = {
+  async putawayReturn(_: any, { worksheetDetailName, palletId, cartonId, toLocation }, context: ResolverContext) {
+    const { tx, domain, user } = context.state
+    await putawayReturn(tx, domain, user, worksheetDetailName, palletId, cartonId, toLocation)
+  }
+}
+
+async function putawayReturn(
+  tx: EntityManager,
+  domain: Domain,
+  user: User,
+  worksheetDetailName: [string],
+  palletId: string,
+  cartonId: string,
+  locationName: string
+) {
+  const worksheetController: PutawayReturningWorksheetController = new PutawayReturningWorksheetController(
+    tx,
+    domain,
+    user
+  )
+  await worksheetController.putawayReturn(worksheetDetailName, palletId, cartonId, locationName)
+}

package/server/graphql/resolvers/worksheet/putaway-return/undo-putaway-return.ts

@@ -0,0 +1,29 @@
+import { EntityManager } from 'typeorm'
+
+import { User } from '@things-factory/auth-base'
+import { Domain } from '@things-factory/shell'
+
+import { PutawayReturningWorksheetController } from '../../../../controllers'
+
+export const undoPutawayReturnResolver = {
+  async undoPutawayReturn(_: any, { worksheetDetailName, palletId, cartonId }, context: ResolverContext) {
+    const { tx, domain, user } = context.state
+    await undoPutawayReturn(tx, domain, user, worksheetDetailName, palletId, cartonId)
+  }
+}
+
+async function undoPutawayReturn(
+  tx: EntityManager,
+  domain: Domain,
+  user: User,
+  worksheetDetailName: [string],
+  palletId: string,
+  cartonId: string
+) {
+  const worksheetController: PutawayReturningWorksheetController = new PutawayReturningWorksheetController(
+    tx,
+    domain,
+    user
+  )
+  await worksheetController.undoPutawayReturn(worksheetDetailName, palletId, cartonId)
+}

package/server/graphql/resolvers/worksheet/putaway-returning-worksheet.ts

@@ -0,0 +1,83 @@
+import { Bizplace } from '@things-factory/biz-base'
+import { OrderInventory, ReturnOrder } from '@things-factory/sales-base'
+import { Domain, getRepository } from '@things-factory/shell'
+import { Inventory } from '@things-factory/warehouse-base'
+
+import { WORKSHEET_TYPE } from '../../../constants'
+import { Worksheet, WorksheetDetail } from '../../../entities'
+import { fetchExecutingWorksheet } from '../../../utils'
+
+export const putawayReturningWorksheetResolver = {
+  async putawayReturningWorksheet(_: any, { returnOrderNo }, context: ResolverContext) {
+    const { domain } = context.state
+    const returnOrder: ReturnOrder = await getRepository(ReturnOrder).findOne({
+      // Because of partial unloading current status of returnOrder can be PUTTING_AWAY or PROCESSING
+      // PUTTING_AWAY means unloading is completely finished.
+      // PROCESSING means some products are still being unloaded.
+      where: {
+        domain: { id: domain.id },
+        name: returnOrderNo
+        /*status: In([ORDER_STATUS.PUTTING_AWAY, ORDER_STATUS.PROCESSING])*/
+      },
+      relations: ['bizplace', 'bizplace.domain', 'bizplace.company', 'bizplace.company.domain']
+    })
+
+    const customerBizplace: Bizplace = returnOrder.bizplace
+    const customerCompanyDomain: Domain = returnOrder.bizplace?.company.domain
+
+    if (!returnOrder) throw new Error(`Return order doesn't exist.`)
+    const worksheet: Worksheet = await fetchExecutingWorksheet(
+      domain,
+      returnOrder.bizplace,
+      [
+        'bizplace',
+        'returnOrder',
+        'bufferLocation',
+        'worksheetDetails',
+        'worksheetDetails.targetInventory',
+        'worksheetDetails.targetInventory.inventory',
+        'worksheetDetails.targetInventory.inventory.location',
+        'worksheetDetails.targetInventory.inventory.product',
+        'worksheetDetails.targetInventory.inventory.reusablePallet',
+        'worksheetDetails.toLocation'
+      ],
+      WORKSHEET_TYPE.PUTAWAY_RETURN,
+      returnOrder
+    )
+
+    return {
+      worksheetInfo: {
+        bizplaceName: returnOrder.bizplace.name,
+        partnerDomainId: customerBizplace?.domain.id,
+        customerCompanyDomainId: customerCompanyDomain.id,
+        bufferLocation: worksheet?.bufferLocation.name,
+        refNo: returnOrder.refNo,
+        //@ts-ignore
+        refNo2: returnOrder.refNo2,
+        //@ts-ignore
+        refNo3: returnOrder.refNo3,
+        startedAt: worksheet.startedAt
+      },
+      worksheetDetailInfos: worksheet.worksheetDetails.map(async (putawayWSD: WorksheetDetail) => {
+        const targetInventory: OrderInventory = putawayWSD.targetInventory
+        const inventory: Inventory = targetInventory.inventory
+        return {
+          name: putawayWSD.name,
+          palletId: inventory.palletId,
+          cartonId: inventory.cartonId,
+          expirationDate: inventory.expirationDate,
+          batchId: inventory.batchId,
+          product: inventory.product,
+          qty: inventory.qty,
+          status: putawayWSD.status,
+          description: putawayWSD.description,
+          targetName: targetInventory.name,
+          packingType: inventory.packingType,
+          packingSize: inventory.packingSize,
+          location: inventory.location,
+          reusablePallet: inventory.reusablePallet
+        }
+      })
+    }
+  }
+}

package/server/graphql/resolvers/worksheet/putaway-worksheet.ts

@@ -0,0 +1,82 @@
+import { Bizplace } from '@things-factory/biz-base'
+import { ArrivalNotice, OrderInventory } from '@things-factory/sales-base'
+import { Domain, getRepository } from '@things-factory/shell'
+import { Inventory } from '@things-factory/warehouse-base'
+
+import { WORKSHEET_TYPE } from '../../../constants'
+import { Worksheet, WorksheetDetail } from '../../../entities'
+import { fetchExecutingWorksheet } from '../../../utils'
+
+export const putawayWorksheetResolver = {
+  async putawayWorksheet(_: any, { arrivalNoticeNo }, context: ResolverContext) {
+    const { domain } = context.state
+    const arrivalNotice: ArrivalNotice = await getRepository(ArrivalNotice).findOne({
+      // Because of partial unloading current status of arrivalNotice can be PUTTING_AWAY or PROCESSING
+      // PUTTING_AWAY means unloading is completely finished.
+      // PROCESSING means some products are still being unloaded.
+      where: {
+        domain: { id: domain.id },
+        name: arrivalNoticeNo
+        /*status: In([ORDER_STATUS.PUTTING_AWAY, ORDER_STATUS.PROCESSING])*/
+      },
+      relations: ['bizplace', 'bizplace.domain', 'bizplace.company', 'bizplace.company.domain']
+    })
+
+    if (!arrivalNotice) throw new Error(`Arrival notice dosen't exist.`)
+
+    const customerBizplace: Bizplace = arrivalNotice.bizplace
+    const customerCompanyDomain: Domain = arrivalNotice.bizplace?.company.domain
+    const worksheet: Worksheet = await fetchExecutingWorksheet(
+      domain,
+      arrivalNotice.bizplace,
+      [
+        'bizplace',
+        'arrivalNotice',
+        'bufferLocation',
+        'worksheetDetails',
+        'worksheetDetails.targetInventory',
+        'worksheetDetails.targetInventory.inventory',
+        'worksheetDetails.targetInventory.inventory.location',
+        'worksheetDetails.targetInventory.inventory.product',
+        'worksheetDetails.targetInventory.inventory.reusablePallet',
+        'worksheetDetails.toLocation'
+      ],
+      WORKSHEET_TYPE.PUTAWAY,
+      arrivalNotice
+    )
+
+    return {
+      worksheetInfo: {
+        bizplaceName: customerBizplace.name,
+        partnerDomainId: customerBizplace?.domain.id,
+        customerCompanyDomainId: customerCompanyDomain.id,
+        bufferLocation: worksheet?.bufferLocation.name,
+        refNo: arrivalNotice.refNo,
+        refNo2: arrivalNotice.refNo2,
+        refNo3: arrivalNotice.refNo3,
+        startedAt: worksheet.startedAt
+      },
+      worksheetDetailInfos: worksheet.worksheetDetails.map(async (putawayWSD: WorksheetDetail) => {
+        const targetInventory: OrderInventory = putawayWSD.targetInventory
+        const inventory: Inventory = targetInventory.inventory
+        return {
+          name: putawayWSD.name,
+          palletId: inventory.palletId,
+          cartonId: inventory.cartonId,
+          batchId: inventory.batchId,
+          expirationDate: inventory.expirationDate,
+          batchIdRef: inventory.batchIdRef,
+          product: inventory.product,
+          qty: inventory.qty,
+          status: putawayWSD.status,
+          description: putawayWSD.description,
+          targetName: targetInventory.name,
+          packingType: inventory.packingType,
+          packingSize: inventory.packingSize,
+          location: inventory.location,
+          reusablePallet: inventory.reusablePallet
+        }
+      })
+    }
+  }
+}

package/server/graphql/resolvers/worksheet/recommend-putway-location.ts

@@ -0,0 +1,133 @@
+import { In } from 'typeorm'
+
+import { ArrivalNotice, ReturnOrder } from '@things-factory/sales-base'
+import { Setting } from '@things-factory/setting-base'
+import { Domain, getRepository } from '@things-factory/shell'
+import { Inventory, Location, LOCATION_STATUS, LOCATION_TYPE, Warehouse } from '@things-factory/warehouse-base'
+
+import { WORKSHEET_STATUS, WORKSHEET_TYPE } from '../../../constants'
+import { Worksheet, WorksheetDetail } from '../../../entities'
+import { isInventoryExpiring } from '../../../utils/inventory-util'
+
+export const recommendPutawayLocationResolver = {
+  async recommendPutawayLocation(
+    _: void,
+    { worksheetDetailName, optCnt = 1 }: { worksheetDetailName: string; optCnt: number },
+    context: any
+  ): Promise<Location[]> {
+    const domain: Domain = context.state.domain
+
+    const worksheetDetail: WorksheetDetail = await getRepository(WorksheetDetail).findOne({
+      where: {
+        domain: { id: domain.id },
+        name: worksheetDetailName
+      },
+      relations: [
+        'worksheet',
+        'worksheet.arrivalNotice',
+        'worksheet.returnOrder',
+        'targetInventory',
+        'targetInventory.inventory'
+      ]
+    })
+
+    const inventory: Inventory = worksheetDetail.targetInventory.inventory
+    if (worksheetDetail.status !== WORKSHEET_STATUS.EXECUTING) throw new Error('Current target is not processing')
+
+    const arrivalNotice: ArrivalNotice = worksheetDetail.worksheet.arrivalNotice
+    const returnOrder: ReturnOrder = worksheetDetail.worksheet.returnOrder
+
+    let unloadingWS: Worksheet
+    if (arrivalNotice) {
+      unloadingWS = await getRepository(Worksheet).findOne({
+        where: { domain: { id: domain.id }, arrivalNotice: { id: arrivalNotice.id }, type: WORKSHEET_TYPE.UNLOADING },
+        relations: ['bufferLocation', 'bufferLocation.warehouse']
+      })
+    } else if (returnOrder) {
+      unloadingWS = await getRepository(Worksheet).findOne({
+        where: {
+          domain: { id: domain.id },
+          returnOrder: { id: returnOrder.id },
+          type: WORKSHEET_TYPE.UNLOADING_RETURN
+        },
+        relations: ['bufferLocation', 'bufferLocation.warehouse']
+      })
+    }
+
+    const targetWarehouse: Warehouse = unloadingWS.bufferLocation.warehouse
+    const sortingLevelSetting: Setting = await getRepository(Setting).findOne({
+      where: { domain: { id: domain.id }, name: 'location-recommendation-level' }
+    })
+    const sortingLevel = sortingLevelSetting?.value
+
+    const isExpiring: boolean = await isInventoryExpiring(inventory)
+
+    let recommendedLocations: Location[] = []
+    if (isExpiring) {
+      switch (sortingLevel) {
+        case 'level 1':
+          recommendedLocations = await recommendQuarantineLocationLevel1(domain, targetWarehouse, optCnt)
+          break
+
+        default:
+          recommendedLocations = await recommendQuarantineLocationLevel1(domain, targetWarehouse, optCnt)
+          break
+      }
+    }
+
+    if (recommendedLocations.length > 0) return recommendedLocations
+
+    switch (sortingLevel) {
+      case 'level 1':
+        recommendedLocations = await recommendLocationLevel1(domain, targetWarehouse, optCnt)
+        break
+
+      default:
+        recommendedLocations = await recommendLocationLevel1(domain, targetWarehouse, optCnt)
+        break
+    }
+
+    return recommendedLocations
+  }
+}
+
+export async function recommendLocationLevel1(
+  domain: Domain,
+  warehouse: Warehouse,
+  optCnt: number
+): Promise<Location[]> {
+  return await getEmptyLocations(domain, warehouse, optCnt, [LOCATION_TYPE.SHELF, LOCATION_TYPE.FLOOR])
+}
+
+export async function recommendQuarantineLocationLevel1(
+  domain: Domain,
+  warehouse: Warehouse,
+  optCnt: number
+): Promise<Location[]> {
+  return await getEmptyLocations(domain, warehouse, optCnt, [LOCATION_TYPE.QUARANTINE])
+}
+
+export async function getEmptyLocations(
+  domain: Domain,
+  warehouse: Warehouse,
+  optCnt: number,
+  //@ts-ignore
+  allowedTypes: any // LOCATION_TYPE[]
+): Promise<Location[]> {
+  const orderSetting: Setting = await getRepository(Setting).findOne({
+    where: { domain: { id: domain.id }, name: 'rule-for-storing-product' }
+  })
+  let order = {}
+  if (orderSetting?.value) order = JSON.parse(orderSetting.value)
+
+  return await getRepository(Location).find({
+    where: {
+      domain: { id: domain.id },
+      warehouse: { id: warehouse.id },
+      status: LOCATION_STATUS.EMPTY,
+      type: In(allowedTypes)
+    },
+    order,
+    take: optCnt
+  })
+}