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

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

@@ -0,0 +1,36 @@
+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

@@ -0,0 +1,29 @@
+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

@@ -0,0 +1,80 @@
+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

@@ -0,0 +1,100 @@
+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

@@ -0,0 +1,26 @@
+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

@@ -0,0 +1,51 @@
+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

@@ -0,0 +1,17 @@
+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

@@ -0,0 +1,69 @@
+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

@@ -0,0 +1,65 @@
+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

@@ -0,0 +1,54 @@
+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

@@ -0,0 +1,114 @@
+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)
+}