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

package/server/graphql/resolvers/worksheet/generate-worksheet/generate-return-order-worksheet.ts

@@ -0,0 +1,45 @@
+import { EntityManager } from 'typeorm'
+
+import { User } from '@things-factory/auth-base'
+import { ReturnOrder } from '@things-factory/sales-base'
+import { Domain } from '@things-factory/shell'
+
+import { UnloadingReturningWorksheetController } from '../../../../controllers'
+import { Worksheet } from '../../../../entities'
+
+export const generateReturnOrderWorksheetResolver = {
+  async generateReturnOrderWorksheet(_: any, { returnOrderNo, bufferLocation }, context: ResolverContext) {
+    const { tx, domain, user } = context.state
+    let outboundReturningWorksheet = await generateReturnOrderWorksheet(tx, domain, user, returnOrderNo, bufferLocation)
+
+    if (!outboundReturningWorksheet.returnOrder?.id) {
+      outboundReturningWorksheet = await tx.getRepository(Worksheet).findOne({
+        where: { id: outboundReturningWorksheet.id },
+        relations: ['returnOrder']
+      })
+    }
+
+    let returnOrder: ReturnOrder = outboundReturningWorksheet.returnOrder
+
+    const vasWorksheet: Worksheet = await tx.getRepository(Worksheet).findOne({
+      where: { domain: { id: domain.id }, returnOrder: { id: returnOrder.id } }
+    })
+
+    return { outboundReturningWorksheet, vasWorksheet }
+  }
+}
+
+async function generateReturnOrderWorksheet(
+  tx: EntityManager,
+  domain: Domain,
+  user: User,
+  returnOrderNo: string,
+  bufferLocation: { id: string }
+): Promise<Worksheet> {
+  const worksheetController: UnloadingReturningWorksheetController = new UnloadingReturningWorksheetController(
+    tx,
+    domain,
+    user
+  )
+  return await worksheetController.generateUnloadingReturnWorksheet(returnOrderNo, bufferLocation.id)
+}

package/server/graphql/resolvers/worksheet/generate-worksheet/generate-vas-order-worksheet.ts

@@ -0,0 +1,35 @@
+import { EntityManager } from 'typeorm'
+
+import { User } from '@things-factory/auth-base'
+import { ORDER_STATUS, VasOrder } from '@things-factory/sales-base'
+import { Domain } from '@things-factory/shell'
+
+import { VasWorksheetController } from '../../../../controllers/'
+import { Worksheet } from '../../../../entities'
+
+export const generateVasOrderWorksheetResolver = {
+  async generateVasOrderWorksheet(_: any, { vasNo }, context: ResolverContext) {
+    const { tx, domain, user } = context.state
+    const foundVasOrder: VasOrder = await tx.getRepository(VasOrder).findOne({
+      where: { domain: { id: domain.id }, name: vasNo, status: ORDER_STATUS.PENDING_RECEIVE }
+    })
+
+    const vasOrderWorksheet: Worksheet = await generateVasOrderWorksheet(tx, domain, user, foundVasOrder)
+    await tx.getRepository(VasOrder).save({
+      ...foundVasOrder,
+      status: ORDER_STATUS.READY_TO_EXECUTE
+    })
+
+    return vasOrderWorksheet
+  }
+}
+
+export async function generateVasOrderWorksheet(
+  tx: EntityManager,
+  domain: Domain,
+  user: User,
+  vasOrder: VasOrder
+): Promise<Worksheet> {
+  const worksheetController: VasWorksheetController = new VasWorksheetController(tx, domain, user)
+  return await worksheetController.generateVasWorksheet(vasOrder)
+}

package/server/graphql/resolvers/worksheet/generate-worksheet/index.ts

@@ -0,0 +1,23 @@
+import { generateArrivalNoticeWorksheetResolver } from './generate-arrival-notice-worksheet'
+import { generateBatchPickingWorksheetResolver } from './generate-batch-picking-worksheet'
+import { generateCycleCountWorksheetResolver } from './generate-cycle-count-worksheet'
+import { generatePartialPutawayWorksheetResolver } from './generate-partial-putaway-worksheet'
+import { generatePutawayWorksheetResolver } from './generate-putaway-worksheet'
+import { generateReleaseGoodWorksheetResolver } from './generate-release-good-worksheet'
+import { generateMultipleReleaseGoodWorksheetResolver } from './generate-multiple-release-good-worksheet'
+import { generateVasOrderWorksheetResolver } from './generate-vas-order-worksheet'
+import { generateReturnOrderWorksheetResolver } from './generate-return-order-worksheet'
+import { generatePartialPutawayReturnWorksheetResolver } from './generate-partial-putaway-return-worksheet'
+
+export const Mutations = {
+  ...generateArrivalNoticeWorksheetResolver,
+  ...generateBatchPickingWorksheetResolver,
+  ...generateCycleCountWorksheetResolver,
+  ...generatePartialPutawayWorksheetResolver,
+  ...generatePutawayWorksheetResolver,
+  ...generateReleaseGoodWorksheetResolver,
+  ...generateMultipleReleaseGoodWorksheetResolver,
+  ...generateVasOrderWorksheetResolver,
+  ...generateReturnOrderWorksheetResolver,
+  ...generatePartialPutawayReturnWorksheetResolver
+}

package/server/graphql/resolvers/worksheet/having-vas.ts

@@ -0,0 +1,45 @@
+import { FindOneOptions, Repository } from 'typeorm'
+
+import { ArrivalNotice, ORDER_TYPES, ReleaseGood } from '@things-factory/sales-base'
+import { getRepository } from '@things-factory/shell'
+
+import { WORKSHEET_TYPE } from '../../../constants'
+import { Worksheet } from '../../../entities'
+
+export const havingVasResolver = {
+  async havingVas(_: any, { orderType, orderNo }, context: ResolverContext): Promise<Worksheet> {
+    return await havingVas(orderType, orderNo, context)
+  }
+}
+
+export async function havingVas(orderType: string, orderNo: string, context: ResolverContext) {
+  const ganRepo: Repository<ArrivalNotice> = getRepository(ArrivalNotice)
+  const roRepo: Repository<ReleaseGood> = getRepository(ReleaseGood)
+  const wsRepo: Repository<Worksheet> = getRepository(Worksheet)
+
+  const { domain } = context.state
+
+  const orderFindOptions: FindOneOptions<ArrivalNotice | ReleaseGood> = {
+    where: { domain: { id: domain.id }, name: orderNo }
+  }
+  let wsFindOptions: FindOneOptions<Worksheet> = {
+    where: { domain: { id: domain.id }, type: WORKSHEET_TYPE.VAS },
+    relations: ['worksheetDetails', 'worksheetDetails.targetVas', 'worksheetDetails.targetVas.vas']
+  }
+
+  if (orderType === ORDER_TYPES.ARRIVAL_NOTICE) {
+    //@ts-ignore
+    const arrivalNotice: ArrivalNotice = await ganRepo.findOne(orderFindOptions)
+    if (!arrivalNotice) throw new Error(`Failed to find arrival notice with passed order no (${orderNo})`)
+    wsFindOptions.where['arrivalNotice'] = arrivalNotice
+  } else if (orderType === ORDER_TYPES.RELEASE_OF_GOODS) {
+    //@ts-ignore
+    const releaseGood: ReleaseGood = await roRepo.findOne(orderFindOptions)
+    if (!releaseGood) throw new Error(`Failed to find release of goods with passed order no (${orderNo})`)
+    wsFindOptions.where['releaseGood'] = releaseGood
+  } else {
+    throw new Error(`Order type (${orderType}) is not target to check about having VAS`)
+  }
+
+  return await wsRepo.findOne(wsFindOptions)
+}

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

@@ -0,0 +1,142 @@
+import { batchPickingWorksheetResolver } from './batch-picking-worksheet'
+import { checkInventoryReleaseResolver } from './check-inventory-release'
+import { checkStockTakeCurrentLocationResolver } from './check-stock-take-current-location'
+import { confirmCancellationReleaseOrder } from './confirm-cancellation-release-order'
+import { createWorksheet } from './create-worksheet'
+import { crossDockPickingResolver } from './cross-dock-picking'
+import { cycleCountAdjustmentResolver } from './cycle-count-adjustment'
+import { cycleCountWorksheetResolver } from './cycle-count-worksheet'
+import { deleteWorksheet } from './delete-worksheet'
+import { deliveryOrderByWorksheetResolver } from './delivery-order-by-worksheet'
+import { fetchDeliveryOrderROResolver } from './fetch-delivery-order-ro'
+import { fetchSellercraftDocumentResolver } from './fetch-sellercraft-document'
+import { findReleaseOrdersByTaskNoResolver } from './find-release-orders-by-task-no'
+import { findSortingReleaseOrdersByTaskNoResolver } from './find-sorting-release-orders-by-task-no'
+import { Mutations as GenerateWorksheetMutations } from './generate-worksheet'
+import { havingVasResolver } from './having-vas'
+import { Mutations as InspectMutations } from './inspecting'
+import { inventoriesByPalletResolver } from './inventories-by-pallet'
+import { loadedInventories } from './loaded-inventories'
+import { Mutations as LoadingMutations } from './loading'
+import { loadingWorksheetResolver } from './loading-worksheet'
+import { notTallyTargetInventoriesResolver } from './not-tally-target-inventories'
+import { Mutations as PackingMutations } from './packing'
+import { packingWorksheetResolver } from './packing-worksheet'
+import { palletizingPallets } from './palletizing-pallets'
+import { pendingCancellationReleaseOrder } from './pending-cancellation-release-order'
+import { cancelDraftReleaseOrder } from './cancel-draft-release-order'
+import { Mutations as PickingMutations } from './picking'
+import { pickingWorksheetResolver } from './picking-worksheet'
+import { myPickingAssignmentStatusResolver } from './picking/my-picking-assignment-status'
+import { pickingAssignmentStatusByUsersResolver } from './picking/picking-assignment-status-by-user'
+import { proceedExtraProductsResolver } from './proceed-extra-products'
+import { Mutations as PutawayMutations } from './putaway'
+import { Mutations as PutawayReturnMutations } from './putaway-return'
+import { putawayReturningWorksheetResolver } from './putaway-returning-worksheet'
+import { putawayWorksheetResolver } from './putaway-worksheet'
+import { recommendPutawayLocationResolver } from './recommend-putway-location'
+import { rejectCancellationReleaseOrder } from './reject-cancellation-release-order'
+import { replacePickingPalletsResolver } from './replace-picking-pallets'
+import { returnWorksheetResolver } from './return-worksheet'
+import { Mutations as ReturningMutations } from './returning'
+import { Mutations as SortingMutations } from './sorting'
+import { sortingWorksheetResolver } from './sorting-worksheet'
+import { transfer } from './transfer'
+import { unloadedInventories } from './unloaded-inventories'
+import { unloadedInventoriesByReusablePallet } from './unloaded-inventories-by-reusable-pallet'
+import { Mutations as UnloadingMutations } from './unloading'
+import { Mutations as UnloadingReturnMutations } from './unloading-return'
+import { unloadingReturnWorksheetResolver } from './unloading-return-worksheet'
+import { unloadingWorksheetResolver } from './unloading-worksheet'
+import { updateWorksheet } from './update-worksheet'
+import { Mutations as VasMutations } from './vas'
+import { vasCandidatesResolver } from './vas-candidates'
+import { vasInventories } from './vas-inventories'
+import {
+  checkRelabelableResolver,
+  relabelingResolver,
+  repackagingResolver,
+  repalletizingResolver,
+  undoRelabelingResolver,
+  undoRepackagingResolver,
+  undoRepalletizingResolver,
+  unpackingResolver
+} from './vas-transactions'
+import { vasWorksheetResolver } from './vas-worksheet'
+import { worksheetResolver } from './worksheet'
+import { worksheetByOrderNoResolver } from './worksheet-by-order-no'
+import { worksheetWithPaginationResolver } from './worksheet-with-pagination'
+import { worksheetsResolver } from './worksheets'
+
+export const Query = {
+  ...worksheetsResolver,
+  ...worksheetResolver,
+  ...unloadingWorksheetResolver,
+  ...unloadingReturnWorksheetResolver,
+  ...deliveryOrderByWorksheetResolver,
+  ...packingWorksheetResolver,
+  ...putawayWorksheetResolver,
+  ...putawayReturningWorksheetResolver,
+  ...returnWorksheetResolver,
+  ...pickingWorksheetResolver,
+  ...cycleCountWorksheetResolver,
+  ...vasWorksheetResolver,
+  ...loadingWorksheetResolver,
+  ...unloadedInventories,
+  ...unloadedInventoriesByReusablePallet,
+  ...loadedInventories,
+  ...vasCandidatesResolver,
+  ...inventoriesByPalletResolver,
+  ...batchPickingWorksheetResolver,
+  ...checkStockTakeCurrentLocationResolver,
+  ...checkInventoryReleaseResolver,
+  ...checkRelabelableResolver,
+  ...havingVasResolver,
+  ...worksheetByOrderNoResolver,
+  ...worksheetWithPaginationResolver,
+  ...notTallyTargetInventoriesResolver,
+  ...vasInventories,
+  ...pickingAssignmentStatusByUsersResolver,
+  ...myPickingAssignmentStatusResolver,
+  ...recommendPutawayLocationResolver,
+  ...sortingWorksheetResolver,
+  ...findSortingReleaseOrdersByTaskNoResolver,
+  ...findReleaseOrdersByTaskNoResolver,
+  ...fetchDeliveryOrderROResolver
+} as any
+
+export const Mutation = {
+  ...GenerateWorksheetMutations,
+  ...UnloadingMutations,
+  ...SortingMutations,
+  ...PutawayMutations,
+  ...PutawayReturnMutations,
+  ...VasMutations,
+  ...PickingMutations,
+  ...PackingMutations,
+  ...LoadingMutations,
+  ...ReturningMutations,
+  ...UnloadingReturnMutations,
+  ...InspectMutations,
+  ...updateWorksheet,
+  ...createWorksheet,
+  ...cycleCountAdjustmentResolver,
+  ...deleteWorksheet,
+  ...transfer,
+  ...proceedExtraProductsResolver,
+  ...replacePickingPalletsResolver,
+  ...pendingCancellationReleaseOrder,
+  ...confirmCancellationReleaseOrder,
+  ...rejectCancellationReleaseOrder,
+  ...repalletizingResolver,
+  ...undoRepalletizingResolver,
+  ...repackagingResolver,
+  ...undoRepackagingResolver,
+  ...relabelingResolver,
+  ...undoRelabelingResolver,
+  ...crossDockPickingResolver,
+  ...unpackingResolver,
+  ...palletizingPallets,
+  ...fetchSellercraftDocumentResolver,
+  ...cancelDraftReleaseOrder
+}

package/server/graphql/resolvers/worksheet/inspecting/activate-cycle-count.ts

@@ -0,0 +1,24 @@
+import { EntityManager } from 'typeorm'
+
+import { User } from '@things-factory/auth-base'
+import { Domain } from '@things-factory/shell'
+
+import { CycleCountWorksheetController } from '../../../../controllers'
+import { Worksheet } from '../../../../entities'
+
+export const activateCycleCountResolver = {
+  async activateCycleCount(_: any, { worksheetNo }, context: ResolverContext) {
+    const { tx, domain, user } = context.state
+    return await activateCycleCount(tx, domain, user, worksheetNo)
+  }
+}
+
+export async function activateCycleCount(
+  tx: EntityManager,
+  domain: Domain,
+  user: User,
+  worksheetNo: string
+): Promise<Worksheet> {
+  const worksheetController: CycleCountWorksheetController = new CycleCountWorksheetController(tx, domain, user)
+  return await worksheetController.activateCycleCount(worksheetNo)
+}

package/server/graphql/resolvers/worksheet/inspecting/add-extra-pallet.ts

@@ -0,0 +1,49 @@
+import { EntityManager } from 'typeorm'
+
+import { User } from '@things-factory/auth-base'
+import { Domain } from '@things-factory/shell'
+
+import { CycleCountWorksheetController } from '../../../../controllers'
+
+export const addExtraPalletResolver = {
+  async addExtraPallet(
+    _: any,
+    { cycleCountNo, palletId, inspectedBatchNo, inspectedQty, inspectedUomValue, locationName },
+    context: any
+  ) {
+    const { tx, domain, user } = context.state
+    await addExtraPallet(
+      tx,
+      domain,
+      user,
+      cycleCountNo,
+      palletId,
+      inspectedBatchNo,
+      inspectedQty,
+      inspectedUomValue,
+      locationName
+    )
+  }
+}
+
+export async function addExtraPallet(
+  tx: EntityManager,
+  domain: Domain,
+  user: User,
+  cycleCountNo: string,
+  palletId: string,
+  inspectedBatchNo: string,
+  inspectedQty: number,
+  inspectedUomValue: number,
+  locationName: string
+) {
+  const worksheetController: CycleCountWorksheetController = new CycleCountWorksheetController(tx, domain, user)
+  await worksheetController.addExtraPallet(
+    cycleCountNo,
+    palletId,
+    inspectedBatchNo,
+    inspectedQty,
+    inspectedUomValue,
+    locationName
+  )
+}

package/server/graphql/resolvers/worksheet/inspecting/check-missing-pallet.ts

@@ -0,0 +1,18 @@
+import { EntityManager } from 'typeorm'
+
+import { User } from '@things-factory/auth-base'
+import { Domain } from '@things-factory/shell'
+
+import { CycleCountWorksheetController } from '../../../../controllers'
+
+export const checkMissingPalletResolver = {
+  async checkMissingPallet(_: any, { worksheetDetailName }, context: ResolverContext) {
+    const { tx, domain, user } = context.state
+    await checkMissingPallet(tx, domain, user, worksheetDetailName)
+  }
+}
+
+export async function checkMissingPallet(tx: EntityManager, domain: Domain, user: User, worksheetDetailName: string) {
+  const worksheetController: CycleCountWorksheetController = new CycleCountWorksheetController(tx, domain, user)
+  await worksheetController.checkMissingPallet(worksheetDetailName)
+}

package/server/graphql/resolvers/worksheet/inspecting/complete-inspection.ts

@@ -0,0 +1,41 @@
+import { EntityManager } from 'typeorm'
+
+import { User } from '@things-factory/auth-base'
+import { Domain } from '@things-factory/shell'
+
+import { WORKSHEET_STATUS } from '../../../../constants'
+import { CycleCountWorksheetController } from '../../../../controllers'
+import { WorksheetController } from '../../../../controllers/worksheet-controller'
+import { Worksheet } from '../../../../entities'
+
+export const completeInspectionResolver = {
+  async completeInspection(_: any, { inventoryCheckNo }, context: ResolverContext) {
+    const { tx, domain, user } = context.state
+    const worksheet: Worksheet = await completeCycleCount(tx, domain, user, inventoryCheckNo)
+
+    const body: string =
+      worksheet.status === WORKSHEET_STATUS.DONE
+        ? `Inventories are checked successfully.`
+        : `There are inventories needed to be reviewed. `
+    const worksheetController: WorksheetController = new WorksheetController(tx, domain, user)
+
+    if (context.header && context.header.referer) {
+      await worksheetController.notifyToOfficeAdmin({
+        title: `Inventory check has been completed (${inventoryCheckNo})`,
+        body,
+        url: context.header.referer,
+        data: { url: context.header.referer }
+      })
+    }
+  }
+}
+
+export async function completeCycleCount(
+  tx: EntityManager,
+  domain: Domain,
+  user: User,
+  inventoryCheckNo: string
+): Promise<Worksheet> {
+  const worksheetController: CycleCountWorksheetController = new CycleCountWorksheetController(tx, domain, user)
+  return await worksheetController.completeCycleCount(inventoryCheckNo)
+}

package/server/graphql/resolvers/worksheet/inspecting/index.ts

@@ -0,0 +1,17 @@
+import { activateCycleCountResolver } from './activate-cycle-count'
+import { inspectingResolver } from './inspecting'
+import { checkMissingPalletResolver } from './check-missing-pallet'
+import { addExtraPalletResolver } from './add-extra-pallet'
+import { relocatePalletResolver } from './relocate-pallet'
+import { undoInspectionResolver } from './undo-inspection'
+import { completeInspectionResolver } from './complete-inspection'
+
+export const Mutations = {
+  ...activateCycleCountResolver,
+  ...inspectingResolver,
+  ...addExtraPalletResolver,
+  ...relocatePalletResolver,
+  ...checkMissingPalletResolver,
+  ...undoInspectionResolver,
+  ...completeInspectionResolver
+}

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

@@ -0,0 +1,30 @@
+import { EntityManager } from 'typeorm'
+
+import { User } from '@things-factory/auth-base'
+import { Domain } from '@things-factory/shell'
+
+import { CycleCountWorksheetController } from '../../../../controllers'
+
+export const inspectingResolver = {
+  async inspecting(
+    _: any,
+    { worksheetDetailName, inspectedBatchNo, inspectedQty, inspectedUomValue },
+    context: ResolverContext
+  ) {
+    const { tx, domain, user } = context.state
+    await executeInspection(tx, domain, user, worksheetDetailName, inspectedBatchNo, inspectedQty, inspectedUomValue)
+  }
+}
+
+export async function executeInspection(
+  tx: EntityManager,
+  domain: Domain,
+  user: User,
+  worksheetDetailName: string,
+  inspectedBatchNo: string,
+  inspectedQty: number,
+  inspectedUomValue: number
+) {
+  const worksheetController: CycleCountWorksheetController = new CycleCountWorksheetController(tx, domain, user)
+  await worksheetController.inspecting(worksheetDetailName, inspectedBatchNo, inspectedQty, inspectedUomValue)
+}

package/server/graphql/resolvers/worksheet/inspecting/relocate-pallet.ts

@@ -0,0 +1,46 @@
+import { EntityManager } from 'typeorm'
+
+import { User } from '@things-factory/auth-base'
+import { Domain } from '@things-factory/shell'
+
+import { CycleCountWorksheetController } from '../../../../controllers'
+
+export const relocatePalletResolver = {
+  async relocatePallet(
+    _: any,
+    { worksheetDetailName, inspectedBatchNo, inspectedQty, inspectedUomValue, inspectedLocationName },
+    context: ResolverContext
+  ) {
+    const { tx, domain, user } = context.state
+    await relocatePallet(
+      tx,
+      domain,
+      user,
+      worksheetDetailName,
+      inspectedBatchNo,
+      inspectedQty,
+      inspectedUomValue,
+      inspectedLocationName
+    )
+  }
+}
+
+export async function relocatePallet(
+  tx: EntityManager,
+  domain: Domain,
+  user: User,
+  worksheetDetailName: string,
+  inspectedBatchNo: string,
+  inspectedQty: number,
+  inspectedUomValue: number,
+  inspectedLocationName: string
+) {
+  const worksheetController: CycleCountWorksheetController = new CycleCountWorksheetController(tx, domain, user)
+  await worksheetController.relocatePallet(
+    worksheetDetailName,
+    inspectedBatchNo,
+    inspectedQty,
+    inspectedUomValue,
+    inspectedLocationName
+  )
+}

package/server/graphql/resolvers/worksheet/inspecting/undo-inspection.ts

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