@things-factory/worksheet-base 8.0.0-beta.1 → 8.0.0-beta.4

package/server/graphql/resolvers/worksheet/find-release-orders-by-task-no.ts

@@ -1,36 +0,0 @@
-import { SelectQueryBuilder } from 'typeorm'
-
-import { OrderInventory as OrderInventoryEntity, ReleaseGood as ReleaseGoodEntity } from '@things-factory/sales-base'
-import { Domain } from '@things-factory/shell'
-
-import { Worksheet as WorksheetEntity, WorksheetDetail as WorksheetDetailEntity } from '../../../entities'
-
-export const findReleaseOrdersByTaskNoResolver = {
-  async findReleaseOrdersByTaskNo(_: any, { taskNo }, context: ResolverContext) {
-    const { domain, tx } = context.state
-    let task = await tx.getRepository(WorksheetEntity).findOne({
-      where: { taskNo }
-    })
-
-    if (!task) throw new Error('Unable to find task no.')
-
-    const qb: SelectQueryBuilder<WorksheetEntity> = tx
-      .getRepository(WorksheetEntity)
-      .createQueryBuilder('ws')
-      .select('rg.id as id')
-      .addSelect('rg.name as name')
-      .addSelect('rg.status as status')
-      .innerJoin(Domain, 'domain', 'ws.domain_id = domain.id')
-      .innerJoin(WorksheetDetailEntity, 'wsd', 'ws.id = wsd.worksheet_id')
-      .innerJoin(OrderInventoryEntity, 'oi', 'oi.id = wsd.target_inventory_id')
-      .innerJoin(ReleaseGoodEntity, 'rg', 'rg.id = oi.release_good_id')
-      .where('domain.id = :domainId', { domainId: domain.id })
-      .andWhere('ws.taskNo = :taskNo', { taskNo: taskNo })
-      .groupBy('rg.id')
-      .addGroupBy('rg.name')
-      .addGroupBy('rg.status')
-
-    const releaseGoods: ReleaseGoodEntity[] = await qb.getRawMany()
-    return { releaseGoods, taskNo }
-  }
-}

package/server/graphql/resolvers/worksheet/find-release-orders-by-worksheet-no.ts

@@ -1,29 +0,0 @@
-import { SelectQueryBuilder } from 'typeorm'
-
-//@ts-ignore
-import { ReleaseGood as ReleaseGoodEntity, Worksheet as WorksheetEntity } from '@things-factory/sales-base'
-
-export const findReleaseOrderByWorksheetNoResolver = {
-  async findReleaseOrderByWorksheetNo(_: any, { batchWorksheetNo }, context: ResolverContext) {
-    const { domain, tx } = context.state
-    if (!batchWorksheetNo) throw new Error('Unable to find worksheet no.')
-
-    const qb: SelectQueryBuilder<WorksheetEntity> = tx
-      .getRepository(WorksheetEntity)
-      .createQueryBuilder('ws')
-      .select('rg.name')
-      .addSelect('rg.status')
-      .innerJoin('ws.domain', 'domain')
-      .innerJoin('ws.worksheetDetail', 'wsd')
-      .innerJoin('wsd.targetInventory', 'oi')
-      .innerJoin('oi.releaseGood', 'rg')
-      .where('ws.domain_id = :domainId', { domainId: domain.id })
-      .andWhere('ws.name = :worksheetNo', { worksheetNo: batchWorksheetNo })
-      .groupBy('rg.id')
-      .addGroupBy('rg.name')
-      .addGroupBy('rg.status')
-
-    const releaseGoods: ReleaseGoodEntity[] = await qb.getRawMany()
-    return releaseGoods
-  }
-}

package/server/graphql/resolvers/worksheet/find-sorting-release-orders-by-task-no.ts

@@ -1,80 +0,0 @@
-import { SelectQueryBuilder } from 'typeorm'
-
-import {
-  ORDER_INVENTORY_STATUS,
-  ORDER_STATUS,
-  OrderInventory as OrderInventoryEntity,
-  ReleaseGood as ReleaseGoodEntity
-} from '@things-factory/sales-base'
-import { Domain } from '@things-factory/shell'
-import { Location } from '@things-factory/warehouse-base'
-
-import { WORKSHEET_STATUS, WORKSHEET_TYPE } from '../../../constants'
-import { Worksheet as WorksheetEntity, WorksheetDetail as WorksheetDetailEntity } from '../../../entities'
-
-export const findSortingReleaseOrdersByTaskNoResolver = {
-  async findSortingReleaseOrdersByTaskNo(_: any, { taskNo }, context: ResolverContext) {
-    const { domain, tx } = context.state
-    let task = await tx.getRepository(WorksheetEntity).findOne({
-      where: { taskNo, status: WORKSHEET_STATUS.EXECUTING, type: WORKSHEET_TYPE.SORTING }
-    })
-
-    // Find Task based on Bin
-    if (!task) {
-      const binLocation: Location = await tx.getRepository(Location).findOne({
-        where: { domain: { id: domain.id }, name: taskNo }
-      })
-
-      const qb: SelectQueryBuilder<OrderInventoryEntity> = tx
-        .getRepository(OrderInventoryEntity)
-        .createQueryBuilder('orderInventory')
-
-      qb.innerJoinAndSelect('orderInventory.releaseGood', 'releaseGood')
-        .innerJoinAndSelect('worksheets', 'ws', `orderInventory.ref_worksheet_id = ws.id AND ws.type = 'BATCH_PICKING'`)
-        .innerJoinAndSelect('worksheets', 'ws2', `ws2.task_no = ws.task_no AND ws2.type = 'SORTING'`)
-        .innerJoinAndSelect('releaseGood.bizplace', 'bizplace')
-        .innerJoinAndSelect('bizplace.domain', 'domain')
-        .where('orderInventory.domain_id = :domainId', { domainId: domain.id })
-        .andWhere('orderInventory.status IN (:...orderInventoryStatus)', {
-          orderInventoryStatus: [ORDER_INVENTORY_STATUS.SORTING]
-        })
-        .andWhere('orderInventory.bin_location_id = :locationId', { locationId: binLocation.id })
-        .andWhere('releaseGood.status = :status', { status: ORDER_STATUS.SORTING })
-
-      const orderInventoryByBin = await qb.getRawOne()
-      if (orderInventoryByBin?.releaseGood_id) {
-        taskNo = orderInventoryByBin.ws_task_no
-        task = await tx.getRepository(WorksheetEntity).findOne({
-          where: { taskNo, status: WORKSHEET_STATUS.EXECUTING, type: WORKSHEET_TYPE.SORTING }
-        })
-      } else {
-        throw new Error(`Bin do not have any batch picking order.`)
-      }
-    }
-
-    if (!task) throw new Error('Unable to find task no.')
-
-    const qb: SelectQueryBuilder<WorksheetEntity> = tx
-      .getRepository(WorksheetEntity)
-      .createQueryBuilder('ws')
-      .select('rg.id as id')
-      .addSelect('rg.name as name')
-      .addSelect('rg.status as status')
-      .innerJoin(Domain, 'domain', 'ws.domain_id = domain.id')
-      .innerJoin(WorksheetDetailEntity, 'wsd', 'ws.id = wsd.worksheet_id')
-      .innerJoin(OrderInventoryEntity, 'oi', 'oi.id = wsd.target_inventory_id')
-      .innerJoin(ReleaseGoodEntity, 'rg', 'rg.id = oi.release_good_id')
-      .where('domain.id = :domainId', { domainId: domain.id })
-      .andWhere('ws.taskNo = :taskNo', { taskNo: taskNo })
-      .andWhere('ws.type = :worksheetType', { worksheetType: WORKSHEET_TYPE.SORTING })
-      .andWhere('ws.status = :worksheetStatus', { worksheetStatus: WORKSHEET_STATUS.EXECUTING })
-      .andWhere('rg.status = :roStatus', { roStatus: ORDER_STATUS.SORTING })
-      .groupBy('rg.id')
-      .addGroupBy('rg.name')
-      .addGroupBy('rg.status')
-      .orderBy('rg.createdAt', 'ASC')
-
-    const releaseGoods: ReleaseGoodEntity[] = await qb.getRawMany()
-    return { releaseGoods, taskNo }
-  }
-}

package/server/graphql/resolvers/worksheet/generate-worksheet/generate-arrival-notice-worksheet.ts

@@ -1,100 +0,0 @@
-import { EntityManager } from 'typeorm'
-
-import { User } from '@things-factory/auth-base'
-import { ArrivalNotice } from '@things-factory/sales-base'
-import { Domain } from '@things-factory/shell'
-
-import { PickingWorksheetController, UnloadingWorksheetController } from '../../../../controllers'
-import { Worksheet } from '../../../../entities'
-
-export const generateArrivalNoticeWorksheetResolver = {
-  async generateArrivalNoticeWorksheet(_: any, { arrivalNoticeNos, bufferLocation }, context: ResolverContext) {
-    const { tx, domain, user } = context.state
-    /* REVIEW ME --
-      return await generateArrivalNoticeWorksheet(tx, domain, user, arrivalNoticeNo, bufferLocation)
-    */
-
-    await Promise.all(
-      arrivalNoticeNos.map(async arrivalNoticeNo => {
-        try {
-          let unloadingWorksheet = await generateUnloadingWorksheet(tx, domain, user, arrivalNoticeNo, bufferLocation)
-
-          if (!unloadingWorksheet.arrivalNotice?.id) {
-            unloadingWorksheet = await tx.getRepository(Worksheet).findOne({
-              where: { id: unloadingWorksheet.id },
-              relations: ['arrivalNotice']
-            })
-          }
-
-          let arrivalNotice: ArrivalNotice = unloadingWorksheet.arrivalNotice
-          const crossDocking: boolean = unloadingWorksheet.arrivalNotice.crossDocking
-
-          if (crossDocking) {
-            arrivalNotice = await tx
-              .getRepository(ArrivalNotice)
-              .findOne({ where: { domain: { id: domain.id }, name: arrivalNoticeNo }, relations: ['releaseGood'] })
-
-            const releaseGoodNo: string = arrivalNotice.releaseGood.name
-            const pickingWSCtrl: PickingWorksheetController = new PickingWorksheetController(tx, domain, user)
-            await pickingWSCtrl.generatePickingWorksheet(releaseGoodNo)
-          }
-
-          const vasWorksheet: Worksheet = await tx.getRepository(Worksheet).findOne({
-            where: { domain: { id: domain.id }, arrivalNotice: { id: arrivalNotice.id } }
-          })
-
-          return { unloadingWorksheet, vasWorksheet }
-        } catch (e) {
-          throw new Error(e)
-        }
-      })
-    )
-  }
-}
-
-export async function generateArrivalNoticeWorksheet(
-  tx: EntityManager,
-  domain: Domain,
-  user: User,
-  arrivalNoticeNo: string,
-  bufferLocation: { id: string }
-) {
-  let unloadingWorksheet = await generateUnloadingWorksheet(tx, domain, user, arrivalNoticeNo, bufferLocation)
-
-  if (!unloadingWorksheet.arrivalNotice?.id) {
-    unloadingWorksheet = await tx.getRepository(Worksheet).findOne({
-      where: { id: unloadingWorksheet.id },
-      relations: ['arrivalNotice']
-    })
-  }
-
-  let arrivalNotice: ArrivalNotice = unloadingWorksheet.arrivalNotice
-  const crossDocking: boolean = unloadingWorksheet.arrivalNotice.crossDocking
-
-  if (crossDocking) {
-    arrivalNotice = await tx
-      .getRepository(ArrivalNotice)
-      .findOne({ where: { domain: { id: domain.id }, name: arrivalNoticeNo }, relations: ['releaseGood'] })
-
-    const releaseGoodNo: string = arrivalNotice.releaseGood.name
-    const pickingWSCtrl: PickingWorksheetController = new PickingWorksheetController(tx, domain, user)
-    await pickingWSCtrl.generatePickingWorksheet(releaseGoodNo)
-  }
-
-  const vasWorksheet: Worksheet = await tx.getRepository(Worksheet).findOne({
-    where: { domain: { id: domain.id }, arrivalNotice: { id: arrivalNotice.id } }
-  })
-
-  return { unloadingWorksheet, vasWorksheet }
-}
-
-async function generateUnloadingWorksheet(
-  tx: EntityManager,
-  domain: Domain,
-  user: User,
-  arrivalNoticeNo: string,
-  bufferLocation: { id: string }
-): Promise<Worksheet> {
-  const worksheetController: UnloadingWorksheetController = new UnloadingWorksheetController(tx, domain, user)
-  return await worksheetController.generateUnloadingWorksheet(arrivalNoticeNo, bufferLocation.id)
-}

package/server/graphql/resolvers/worksheet/generate-worksheet/generate-batch-picking-worksheet.ts

@@ -1,26 +0,0 @@
-import { EntityManager } from 'typeorm'
-
-import { User } from '@things-factory/auth-base'
-//@ts-ignore
-import { GenerateBatchPickInfo } from '@things-factory/sales-base'
-import { Domain } from '@things-factory/shell'
-
-import { PickingWorksheetController } from '../../../../controllers/'
-import { Worksheet } from '../../../../entities'
-
-export const generateBatchPickingWorksheetResolver = {
-  async generateBatchPickingWorksheet(_: any, { releaseGoodWithBiz }, context: ResolverContext) {
-    const { tx, domain, user } = context.state
-    return await generateBatchPickingWorksheet(tx, domain, user, releaseGoodWithBiz)
-  }
-}
-
-export async function generateBatchPickingWorksheet(
-  tx: EntityManager,
-  domain: Domain,
-  user: User,
-  releaseGoodWithBiz: [[GenerateBatchPickInfo]]
-): Promise<Worksheet[]> {
-  const worksheetController: PickingWorksheetController = new PickingWorksheetController(tx, domain, user)
-  return await worksheetController.generateBatchPickingWorksheet(releaseGoodWithBiz)
-}

package/server/graphql/resolvers/worksheet/generate-worksheet/generate-cycle-count-worksheet.ts

@@ -1,51 +0,0 @@
-import { EntityManager } from 'typeorm'
-
-import { User } from '@things-factory/auth-base'
-import { OrderInventory } from '@things-factory/sales-base'
-import { Domain } from '@things-factory/shell'
-
-import { CycleCountWorksheetController } from '../../../../controllers'
-import { Worksheet } from '../../../../entities'
-
-export const generateCycleCountWorksheetResolver = {
-  async generateCycleCountWorksheet(
-    _: any,
-    { executionDate, customerId, orderInventoryIds, orderInventories, limit },
-    context: any
-  ) {
-    const { tx, domain, user } = context.state
-
-    const cycleCountWorksheet: Worksheet = await generateCycleCountWorksheet(
-      tx,
-      domain,
-      user,
-      executionDate,
-      customerId,
-      orderInventoryIds,
-      orderInventories,
-      limit
-    )
-
-    return cycleCountWorksheet
-  }
-}
-
-export async function generateCycleCountWorksheet(
-  tx: EntityManager,
-  domain: Domain,
-  user: User,
-  executionDate: string,
-  customerId: string,
-  orderInventoryIds: string[] = [],
-  orderInventories: OrderInventory[],
-  limit: number
-): Promise<Worksheet> {
-  const worksheetController: CycleCountWorksheetController = new CycleCountWorksheetController(tx, domain, user)
-  return await worksheetController.generateCycleCountWorksheet(
-    executionDate,
-    customerId,
-    orderInventoryIds,
-    orderInventories,
-    limit
-  )
-}

package/server/graphql/resolvers/worksheet/generate-worksheet/generate-multiple-release-good-worksheet.ts

@@ -1,17 +0,0 @@
-import { getManager } from 'typeorm'
-
-import { generatePickingWorksheet } from './generate-release-good-worksheet'
-
-export const generateMultipleReleaseGoodWorksheetResolver = {
-  async generateMultipleReleaseGoodWorksheet(_: any, { releaseGoods }, context: ResolverContext) {
-    const { tx, domain, user } = context.state
-
-    for (let idx = 0; idx < releaseGoods.length; idx++) {
-      await getManager().transaction(async txMgr => {
-        await generatePickingWorksheet(txMgr, domain, user, releaseGoods[idx].name, releaseGoods[idx].status)
-      })
-    }
-
-    return true
-  }
-}

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

@@ -1,69 +0,0 @@
-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 { Inventory } from '@things-factory/warehouse-base'
-
-import { WORKSHEET_STATUS, WORKSHEET_TYPE } from '../../../../constants'
-import { PutawayReturningWorksheetController } from '../../../../controllers'
-import { Worksheet, WorksheetDetail } from '../../../../entities'
-
-export const generatePartialPutawayReturnWorksheetResolver = {
-  async generatePartialPutawayReturnWorksheet(
-    _: any,
-    { returnOrderNo, inventories },
-    context: ResolverContext
-  ): Promise<void> {
-    const { tx, domain, user } = context.state
-    let worksheet: Worksheet = await generatePartialPutawayReturnWorksheet(tx, domain, user, returnOrderNo, inventories)
-
-    if (!worksheet?.returnOrder?.id) {
-      worksheet = await tx.getRepository(Worksheet).findOne({
-        where: { id: worksheet.id },
-        relations: ['returnOrder']
-      })
-    }
-
-    const returnOrder: ReturnOrder = worksheet.returnOrder
-    const unloadingWorksheet: Worksheet = await tx.getRepository(Worksheet).findOne({
-      where: { returnOrder: { id: returnOrder.id }, type: WORKSHEET_TYPE.UNLOADING_RETURN },
-      relations: ['worksheetDetails', 'worksheetDetails.targetInventory', 'worksheetDetails.targetInventory.inventory']
-    })
-
-    const remainPalletCnt: number = await tx.getRepository(Inventory).count({
-      where: {
-        domain: { id: domain.id },
-        refOrderId: returnOrder.id,
-        status: WORKSHEET_STATUS.PARTIALLY_UNLOADED
-      }
-    })
-    const wsdStatus: string = remainPalletCnt >= 0 ? WORKSHEET_STATUS.PARTIALLY_UNLOADED : WORKSHEET_STATUS.EXECUTING
-
-    const worksheetDetails: WorksheetDetail[] = unloadingWorksheet.worksheetDetails
-    // const nonStartedWorksheetDetails: WorksheetDetail[] = worksheetDetails
-    //   .filter((wsd: WorksheetDetail) => wsd.targetInventory?.inventory?.status !== INVENTORY_STATUS.PARTIALLY_UNLOADED)
-    //   .map((wsd: WorksheetDetail) => {
-    //     wsd.status = wsdStatus
-    //     wsd.updater = user
-    //     return wsd
-    //   })
-
-    // await tx.getRepository(WorksheetDetail).save(nonStartedWorksheetDetails)
-  }
-}
-
-export async function generatePartialPutawayReturnWorksheet(
-  tx: EntityManager,
-  domain: Domain,
-  user: User,
-  returnOrderNo: string,
-  inventories: Inventory[]
-): Promise<Worksheet> {
-  const worksheetController: PutawayReturningWorksheetController = new PutawayReturningWorksheetController(
-    tx,
-    domain,
-    user
-  )
-  return await worksheetController.generatePutawayReturnWorksheet(returnOrderNo, inventories)
-}

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

@@ -1,65 +0,0 @@
-import { EntityManager } from 'typeorm'
-
-import { User } from '@things-factory/auth-base'
-import { ArrivalNotice } from '@things-factory/sales-base'
-import { Domain } from '@things-factory/shell'
-import { Inventory } from '@things-factory/warehouse-base'
-
-import { WORKSHEET_STATUS, WORKSHEET_TYPE } from '../../../../constants'
-import { PutawayWorksheetController } from '../../../../controllers'
-import { Worksheet, WorksheetDetail } from '../../../../entities'
-
-export const generatePartialPutawayWorksheetResolver = {
-  async generatePartialPutawayWorksheet(
-    _: any,
-    { arrivalNoticeNo, inventories },
-    context: ResolverContext
-  ): Promise<void> {
-    const { tx, domain, user } = context.state
-    let worksheet: Worksheet = await generatePartialPutawayWorksheet(tx, domain, user, arrivalNoticeNo, inventories)
-
-    if (!worksheet?.arrivalNotice?.id) {
-      worksheet = await tx.getRepository(Worksheet).findOne({
-        where: { id: worksheet.id },
-        relations: ['arrivalNotice']
-      })
-    }
-
-    const arrivalNotice: ArrivalNotice = worksheet.arrivalNotice
-    const unloadingWorksheet: Worksheet = await tx.getRepository(Worksheet).findOne({
-      where: { arrivalNotice: { id: arrivalNotice.id }, type: WORKSHEET_TYPE.UNLOADING },
-      relations: ['worksheetDetails', 'worksheetDetails.targetInventory', 'worksheetDetails.targetInventory.inventory']
-    })
-
-    const remainPalletCnt: number = await tx.getRepository(Inventory).count({
-      where: {
-        domain: { id: domain.id },
-        refOrderId: arrivalNotice.id,
-        status: WORKSHEET_STATUS.PARTIALLY_UNLOADED
-      }
-    })
-    const wsdStatus: string = remainPalletCnt >= 0 ? WORKSHEET_STATUS.PARTIALLY_UNLOADED : WORKSHEET_STATUS.EXECUTING
-
-    const worksheetDetails: WorksheetDetail[] = unloadingWorksheet.worksheetDetails
-    // const nonStartedWorksheetDetails: WorksheetDetail[] = worksheetDetails
-    //   .filter((wsd: WorksheetDetail) => wsd.targetInventory?.inventory?.status !== INVENTORY_STATUS.PARTIALLY_UNLOADED)
-    //   .map((wsd: WorksheetDetail) => {
-    //     wsd.status = wsdStatus
-    //     wsd.updater = user
-    //     return wsd
-    //   })
-
-    // await tx.getRepository(WorksheetDetail).save(nonStartedWorksheetDetails)
-  }
-}
-
-export async function generatePartialPutawayWorksheet(
-  tx: EntityManager,
-  domain: Domain,
-  user: User,
-  arrivalNoticeNo: string,
-  inventories: Inventory[]
-): Promise<Worksheet> {
-  const worksheetController: PutawayWorksheetController = new PutawayWorksheetController(tx, domain, user)
-  return await worksheetController.generatePutawayWorksheet(arrivalNoticeNo, inventories)
-}

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

@@ -1,54 +0,0 @@
-import { EntityManager } from 'typeorm'
-
-import { User } from '@things-factory/auth-base'
-import { ArrivalNotice } from '@things-factory/sales-base'
-import { Domain } from '@things-factory/shell'
-import { Inventory, INVENTORY_STATUS } from '@things-factory/warehouse-base'
-
-import { WORKSHEET_STATUS, WORKSHEET_TYPE } from '../../../../constants'
-import { PutawayWorksheetController } from '../../../../controllers'
-import { Worksheet, WorksheetDetail } from '../../../../entities'
-
-export const generatePutawayWorksheetResolver = {
-  async generatePutawayWorksheet(_: any, { arrivalNoticeNo, inventories }, context: ResolverContext): Promise<void> {
-    const { tx, domain, user } = context.state
-    let worksheet: Worksheet = await generatePutawayWorksheet(tx, domain, user, arrivalNoticeNo, inventories)
-
-    if (!worksheet.arrivalNotice?.id) {
-      worksheet = await tx.getRepository(Worksheet).findOne({
-        where: { id: worksheet.id },
-        relations: ['arrivalNotice']
-      })
-    }
-
-    // Find whether there's partially unloaded and not started inventories
-    // to execute it automatically.
-    const arrivalNotice: ArrivalNotice = worksheet.arrivalNotice
-    const unloadingWorksheet: Worksheet = await tx.getRepository(Worksheet).findOne({
-      where: { arrivalNotice: { id: arrivalNotice.id }, type: WORKSHEET_TYPE.UNLOADING },
-      relations: ['worksheetDetails', 'worksheetDetails.targetInventory', 'worksheetDetails.targetInventory.inventory']
-    })
-    const worksheetDetails: WorksheetDetail[] = unloadingWorksheet.worksheetDetails
-    const nonStartedWorksheetDetails: WorksheetDetail[] = worksheetDetails
-      .filter((wsd: WorksheetDetail) => wsd.targetInventory?.inventory?.status !== INVENTORY_STATUS.PARTIALLY_UNLOADED)
-      .map((wsd: WorksheetDetail) => {
-        wsd.status = WORKSHEET_STATUS.EXECUTING
-        wsd.updater = user
-
-        return wsd
-      })
-
-    await tx.getRepository(WorksheetDetail).save(nonStartedWorksheetDetails)
-  }
-}
-
-export async function generatePutawayWorksheet(
-  tx: EntityManager,
-  domain: Domain,
-  user: User,
-  arrivalNoticeNo: string,
-  inventories: Inventory[]
-): Promise<Worksheet> {
-  const worksheetController: PutawayWorksheetController = new PutawayWorksheetController(tx, domain, user)
-  return await worksheetController.generatePutawayWorksheet(arrivalNoticeNo, inventories)
-}

package/server/graphql/resolvers/worksheet/generate-worksheet/generate-release-good-worksheet.ts

@@ -1,114 +0,0 @@
-import { EntityManager } from 'typeorm'
-
-import { User } from '@things-factory/auth-base'
-import { ORDER_INVENTORY_STATUS, ORDER_STATUS, OrderInventory, ReleaseGood } from '@things-factory/sales-base'
-import { Setting } from '@things-factory/setting-base'
-import { Domain } from '@things-factory/shell'
-import { Inventory, INVENTORY_TRANSACTION_TYPE, InventoryUtil } from '@things-factory/warehouse-base'
-
-import { PickingWorksheetController } from '../../../../controllers/'
-import { Worksheet, WorksheetDetail } from '../../../../entities'
-
-export const generateReleaseGoodWorksheetResolver = {
-  async generateReleaseGoodWorksheet(_: any, { releaseGoodNo, currentStatus = null }, context: ResolverContext) {
-    const { tx, domain, user } = context.state
-    return await generatePickingWorksheet(tx, domain, user, releaseGoodNo, currentStatus)
-  }
-}
-
-export async function generatePickingWorksheet(
-  tx: EntityManager,
-  domain: Domain,
-  user: User,
-  releaseGoodNo: string,
-  currentStatus: string = null
-): Promise<Worksheet> {
-  try {
-    const worksheetController: PickingWorksheetController = new PickingWorksheetController(tx, domain, user)
-
-    //@ts-ignore
-    let releaseGood: ReleaseGood = await worksheetController.findRefOrder(ReleaseGood, {
-      domain: { id: domain.id },
-      name: releaseGoodNo,
-      status: ORDER_STATUS.PENDING_WORKSHEET
-    })
-
-    let worksheet: Worksheet = new Worksheet()
-
-    const directReleaseOrder: Setting = await tx.getRepository(Setting).findOne({
-      where: { domain: { id: domain.id }, category: 'id-rule', name: 'enable-direct-b2c-release-order' }
-    })
-
-    if (releaseGood.type == 'b2c' && directReleaseOrder && directReleaseOrder.value.toLowerCase() == 'true') {
-      const inventoryUtil = new InventoryUtil(tx, domain, user)
-
-      let orderInventories: OrderInventory[] = await tx.getRepository(OrderInventory).find({
-        where: { domain: { id: domain.id }, releaseGood: { id: releaseGood.id } },
-        relations: ['inventory']
-      })
-
-      for (let idx = 0; idx < orderInventories.length; idx++) {
-        let orderInventory = orderInventories[idx]
-        //@ts-ignore
-        if (orderInventory.releaseQty <= 0 || (orderInventory.uomValue != null && orderInventory.uomValue <= 0)) {
-          throw new Error(`Invalid data for ${releaseGoodNo}. Please contact support.`)
-        }
-        //@ts-ignore
-        orderInventory.uomValue = orderInventory.uomValue > 0 ? orderInventory.uomValue : 0
-
-        let inventory: Inventory = await tx
-          .getRepository(Inventory)
-          .findOne({ where: { id: orderInventory.inventory.id } })
-
-        await inventoryUtil.transactionInventory(
-          {
-            id: inventory.id,
-            qty: inventory.qty - orderInventory.releaseQty,
-            uomValue: Math.round((inventory.uomValue - orderInventory.releaseUomValue) * 100) / 100,
-            lockedQty: inventory.lockedQty - orderInventory.releaseQty,
-            lockedUomValue: Math.round((inventory.lockedUomValue - orderInventory.releaseUomValue) * 100) / 100
-          } as any,
-          releaseGood,
-          -orderInventory.releaseQty,
-          -orderInventory.releaseUomValue,
-          INVENTORY_TRANSACTION_TYPE.DIRECT_DEDUCTION
-        )
-
-        await tx
-          .getRepository(OrderInventory)
-          .update({ id: orderInventory.id }, { status: ORDER_INVENTORY_STATUS.TERMINATED })
-      }
-
-      await tx.getRepository(ReleaseGood).update({ id: releaseGood.id }, { status: ORDER_STATUS.DONE })
-    } else {
-      worksheet = await worksheetController.generatePickingWorksheet(releaseGoodNo, currentStatus)
-    }
-
-    return worksheet
-  } catch (error) {
-    return new Worksheet()
-  }
-}
-
-/**
- * @description This function will generate picking worksheet detail
- * If you call this function without specified status, status will be set as DEACTIVATED
- *
- * @param {EntityManager} tx
- * @param {Domain} domain
- * @param {Bizplace} bizplace
- * @param {User} user
- * @param {Worksheet} worksheet
- * @param {OrderInventory} targetInventory
- * @param {String} status
- */
-export async function generatePickingWorksheetDetail(
-  tx: EntityManager,
-  domain: Domain,
-  user: User,
-  worksheet: Worksheet,
-  targetInventory: Partial<OrderInventory>[]
-): Promise<WorksheetDetail[]> {
-  const worksheetController: PickingWorksheetController = new PickingWorksheetController(tx, domain, user)
-  return await worksheetController.generatePickingWorksheetDetail(worksheet, targetInventory)
-}