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

package/server/graphql/resolvers/worksheet-detail/generate-picking-worksheet-details.ts

@@ -0,0 +1,259 @@
+import { EntityManager } from 'typeorm'
+
+import { User } from '@things-factory/auth-base'
+import {
+  ORDER_INVENTORY_STATUS,
+  ORDER_PRODUCT_STATUS,
+  ORDER_TYPES,
+  OrderInventory,
+  OrderInventoryPatch,
+  OrderNoGenerator,
+  OrderProduct,
+  ReleaseGood
+} from '@things-factory/sales-base'
+import { Setting } from '@things-factory/setting-base'
+import { Domain } from '@things-factory/shell'
+import { getInventoriesByStrategy, Inventory } from '@things-factory/warehouse-base'
+
+import { WORKSHEET_STATUS, WORKSHEET_TYPE } from '../../../constants'
+import { Worksheet, WorksheetDetail } from '../../../entities'
+import { WorksheetNoGenerator } from '../../../utils'
+
+export const generatePickingWorksheetDetailsResolver = {
+  async generatePickingWorksheetDetails(
+    _: any,
+    { bizplaceId, selectedItems, worksheetNo, locationSortingRules },
+    context: any
+  ): Promise<Boolean> {
+    const { tx, user, domain } = context.state
+
+    // 1. find related worksheet
+    const worksheet: Worksheet = await tx.getRepository(Worksheet).findOne({
+      where: { name: worksheetNo, status: WORKSHEET_STATUS.DEACTIVATED, domain: { id: domain.id } },
+      relations: ['releaseGood']
+    })
+
+    if (!worksheet) throw new Error('picking worksheet not found')
+    const worksheetId = worksheet.id
+
+    // 2. search for sorting rules
+    const inventoryAssignmentSetting: Setting = await tx.getRepository(Setting).findOne({
+      where: { domain: { id: domain.id }, name: 'rule-for-inventory-assignment' }
+    })
+
+    if (!locationSortingRules && inventoryAssignmentSetting) {
+      locationSortingRules = []
+      let locationSetting = JSON.parse(inventoryAssignmentSetting.value)
+      for (const key in locationSetting) {
+        locationSortingRules.push({ name: key, desc: locationSetting[key] == 'ASC' ? false : true })
+      }
+    }
+
+    try {
+      // 3. get all related inventories by strategy
+      let inventories: any[] = await getInventoriesByStrategy(
+        domain.id,
+        bizplaceId,
+        worksheetId,
+        selectedItems,
+        locationSortingRules,
+        tx
+      )
+
+      // 4. get worksheet details
+      let worksheetDetails: WorksheetDetail[] = selectedItems.reduce(
+        (accWSD: WorksheetDetail[], oi: OrderInventoryPatch) => {
+          const relatedInventories = inventories.filter(
+            inv =>
+              inv.productId == oi.productId &&
+              inv.batchId == oi.batchId &&
+              inv.packingType == oi.packingType &&
+              inv.packingSize == oi.packingSize &&
+              inv.uom == oi.uom &&
+              inv.remainQty
+          )
+
+          if (
+            relatedInventories.length &&
+            oi.releaseQty <= inventories.reduce((totalQty: number, inv) => totalQty + inv.remainQty, 0)
+          ) {
+            let composedWSD: WorksheetDetail[] = _composeWorksheetDetails(
+              domain,
+              user,
+              worksheet.releaseGood,
+              bizplaceId,
+              oi,
+              relatedInventories
+            )
+
+            accWSD.push(...composedWSD)
+          }
+
+          return accWSD
+        },
+        []
+      )
+
+      //@ts-ignore
+      let targetInventories: OrderInventory = worksheetDetails.map((wsd: WorksheetDetail) => wsd.targetInventory)
+
+      // 5. remove existing worksheet details and its target inventory if there's any
+      //@ts-ignore
+      await _removeOldWorksheetDetails(targetInventories, worksheet.id, tx)
+
+      targetInventories = await tx.getRepository(OrderInventory).save(targetInventories)
+
+      let newWorksheetDetails: WorksheetDetail[] = []
+
+      //@ts-ignore
+      for (let i = 0, l = targetInventories.length; i < l; i++) {
+        const targetInventory: OrderInventory = targetInventories[i]
+
+        // 6. update inventory lockedQty and lockedUomValue
+        await tx
+          .createQueryBuilder()
+          .update(Inventory)
+          .set({
+            lockedQty: () => `COALESCE("locked_qty", 0) + ${targetInventory.releaseQty}`,
+            lockedUomValue: () => `COALESCE("locked_uom_value", 0) + ${targetInventory.releaseUomValue}`,
+            updater: user
+          } as any)
+          .where('id = :id', { id: targetInventory.inventory.id })
+          .execute()
+
+        // update order product status to ASSIGNED
+        await tx.getRepository(OrderProduct).update({ id: targetInventory.orderProduct.id }, {
+          status: ORDER_PRODUCT_STATUS.ASSIGNED,
+          updater: user
+        } as any)
+
+        // 7. collect new worksheet details records
+        const worksheetDetail: WorksheetDetail = Object.assign(new WorksheetDetail(), {
+          domain,
+          bizplace: { id: bizplaceId },
+          worksheet,
+          name: WorksheetNoGenerator.pickingDetail(),
+          seq: 0,
+          targetInventory,
+          targetProduct: targetInventory.orderProduct,
+          type: WORKSHEET_TYPE.PICKING,
+          status: WORKSHEET_STATUS.DEACTIVATED,
+          creator: user,
+          updater: user
+        })
+
+        newWorksheetDetails.push(worksheetDetail)
+      }
+
+      // 8. save worksheet details
+      await tx.getRepository(WorksheetDetail).save(newWorksheetDetails)
+
+      return true
+    } catch (error) {
+      throw error
+    }
+  }
+}
+
+function _composeWorksheetDetails(
+  domain: Domain,
+  user: User,
+  releaseGood: ReleaseGood,
+  bizplaceId: string,
+  record: OrderInventoryPatch,
+  inventories: Inventory[]
+): WorksheetDetail[] {
+  let leftReleaseQty: number = record.releaseQty
+  let leftReleaseUomValue: number = record.releaseUomValue
+  let compReleaseQty: number = 0
+  let compReleaseUomValue: number = 0
+
+  let worksheetDetails: Partial<WorksheetDetail[]> = []
+  let idx = 0
+
+  while (compReleaseQty < record.releaseQty) {
+    const inv = inventories[idx]
+
+    if (!inv) break
+
+    let releaseQty: number = 0
+    let releaseUomValue: number = 0
+
+    if (inv.remainQty > leftReleaseQty) {
+      compReleaseQty += leftReleaseQty
+      compReleaseUomValue += leftReleaseUomValue
+      releaseQty = leftReleaseQty
+      releaseUomValue = leftReleaseUomValue
+    } else {
+      compReleaseQty += inv.remainQty
+      compReleaseUomValue += inv.remainUomValue
+      leftReleaseQty -= inv.remainQty
+      leftReleaseUomValue -= inv.remainUomValue
+      releaseQty = inv.remainQty
+      releaseUomValue = inv.remainUomValue
+    }
+
+    let worksheetDetail: WorksheetDetail = Object.assign(new WorksheetDetail(), {
+      targetInventory: {
+        domain,
+        bizplace: { id: bizplaceId },
+        name: OrderNoGenerator.orderInventory(),
+        releaseGood,
+        inventory: { id: inv.id },
+        product: { id: inv.productId },
+        batchId: inv.batchId,
+        batchIdRef: inv.batchIdRef,
+        packingType: inv.packingType,
+        packingSize: inv.packingSize,
+        releaseQty,
+        releaseUomValue,
+        creator: user,
+        updater: user,
+        status: ORDER_INVENTORY_STATUS.READY_TO_PICK,
+        type: ORDER_TYPES.RELEASE_OF_GOODS,
+        uom: record.uom,
+        orderProduct: { id: inv.orderProductId }
+      }
+    })
+
+    worksheetDetails.push(worksheetDetail)
+
+    idx++
+  }
+
+  return worksheetDetails
+}
+
+async function _removeOldWorksheetDetails(targetInventories: OrderInventory[], worksheetId: string, tx: EntityManager) {
+  let orderProductJson = JSON.stringify(
+    targetInventories.map((target: OrderInventory) => {
+      return {
+        product_id: target.product.id,
+        batch_id: target.batchId,
+        packing_type: target.packingType,
+        packing_size: target.packingSize
+      }
+    })
+  )
+
+  // get worksheetDetail IDs and their targetInventory IDs
+  let existingOIandWSD: WorksheetDetail[] = await tx.query(
+    `
+    SELECT wsd.id AS "worksheetDetailId", oi.id AS "orderInventoryId"
+    FROM order_inventories oi  
+    INNER JOIN JSON_POPULATE_RECORDSET(NULL::order_products, $1) js ON oi.batch_id = js.batch_id 
+      AND oi.product_id = js.product_id 
+      AND oi.packing_type = js.packing_type
+      AND oi.packing_size = js.packing_size
+    LEFT JOIN worksheet_details wsd ON oi.id = wsd.target_inventory_id
+    WHERE oi.release_good_id = $2
+  `,
+    [orderProductJson, worksheetId]
+  )
+
+  // if found the records then delete, so that we can create new records
+  if (existingOIandWSD.length) {
+    await tx.getRepository(WorksheetDetail).delete(existingOIandWSD.map((wsd: any) => wsd.worksheetDetailId))
+    await tx.getRepository(OrderInventory).delete(existingOIandWSD.map((wsd: any) => wsd.orderInventoryId))
+  }
+}

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

@@ -0,0 +1,142 @@
+import { EntityManager, Equal } from 'typeorm'
+
+import { User } from '@things-factory/auth-base'
+import { Product } from '@things-factory/product-base'
+import {
+  ORDER_INVENTORY_STATUS,
+  ORDER_PRODUCT_STATUS,
+  OrderInventory,
+  OrderNoGenerator,
+  OrderProduct
+} 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 { Worksheet, WorksheetDetail } from '../../../entities'
+import { WorksheetNoGenerator } from '../../../utils'
+
+export const generateReleaseGoodWorksheetDetailsResolver = {
+  async generateReleaseGoodWorksheetDetails(
+    _: any,
+    { worksheetNo, batchId, productId, packingType, packingSize, worksheetDetails },
+    context: any
+  ): Promise<void> {
+    const { tx, domain, user } = context.state
+    return await generateReleaseGoodWorksheetDetails(
+      tx,
+      domain,
+      user,
+      worksheetNo,
+      batchId,
+      productId,
+      packingType,
+      packingSize,
+      worksheetDetails
+    )
+  }
+}
+
+export async function generateReleaseGoodWorksheetDetails(
+  tx: EntityManager,
+  domain: Domain,
+  user: User,
+  worksheetNo: string,
+  batchId: string,
+  productId: string,
+  packingType: string,
+  packingSize: number,
+  worksheetDetails: Partial<WorksheetDetail>[]
+): Promise<void> {
+  // 1. Remove prev worksheet details if it's exists
+  const worksheet: Worksheet = await tx.getRepository(Worksheet).findOne({
+    where: { name: worksheetNo, domain: { id: domain.id } },
+    relations: [
+      'bizplace',
+      'releaseGood',
+      'worksheetDetails',
+      'worksheetDetails.targetInventory',
+      'worksheetDetails.targetInventory.product'
+    ]
+  })
+
+  const prevWSDs: WorksheetDetail[] = worksheet.worksheetDetails.filter((wsd: WorksheetDetail) => {
+    const targetInv: OrderInventory = wsd.targetInventory
+    if (targetInv.batchId === batchId && targetInv.product.id === productId && targetInv.packingType === packingType)
+      return wsd.id
+  })
+
+  // TODO: Delete order inventories
+  if (prevWSDs?.length) {
+    const wsdIds: string[] = prevWSDs.map((wsd: WorksheetDetail) => wsd.id)
+    const prevOrderInvIds: string[] = prevWSDs.map((wsd: WorksheetDetail) => wsd.targetInventory.id)
+    await tx.getRepository(WorksheetDetail).delete(wsdIds)
+    await tx.getRepository(OrderInventory).delete(prevOrderInvIds)
+  }
+
+  await Promise.all(
+    worksheetDetails.map(async (wsd: WorksheetDetail) => {
+      // 2. Create order inventory
+      let targetInventory: OrderInventory = wsd.targetInventory
+      const inventory: Inventory = await tx
+        .getRepository(Inventory)
+        .findOne({ where: { id: targetInventory.inventory.id } })
+
+      let targetProduct: OrderProduct = await tx
+        .getRepository(OrderProduct)
+        .findOne({ where: { id: Equal(wsd.targetProduct?.id) } })
+
+      targetInventory = await tx.getRepository(OrderInventory).save({
+        ...targetInventory,
+        domain,
+        bizplace: worksheet.bizplace,
+        name: OrderNoGenerator.orderInventory(),
+        releaseGood: worksheet.releaseGood,
+        inventory,
+        batchId,
+        batchIdRef: inventory.batchIdRef,
+        status: ORDER_INVENTORY_STATUS.READY_TO_PICK,
+        product: await tx.getRepository(Product).findOneBy({ id: productId }),
+        packingType,
+        packingSize,
+        orderProduct: targetProduct,
+        creator: user,
+        updater: user
+      })
+
+      const currentLockedQty: any = inventory.lockedQty
+      const currentLockedUomValue: any = inventory.lockedUomValue
+
+      await tx.getRepository(Inventory).save({
+        ...targetInventory.inventory,
+        lockedQty: Boolean(currentLockedQty)
+          ? targetInventory.releaseQty + currentLockedQty
+          : targetInventory.releaseQty,
+        lockedUomValue: Boolean(currentLockedUomValue)
+          ? targetInventory.releaseUomValue + currentLockedUomValue
+          : targetInventory.releaseUomValue,
+        updater: user
+      })
+
+      // update order product status to ASSIGNED
+      await tx
+        .getRepository(OrderProduct)
+        .update({ id: targetProduct?.id }, { status: ORDER_PRODUCT_STATUS.ASSIGNED, updater: user } as any)
+
+      // 3. Create worksheet details
+      await tx.getRepository(WorksheetDetail).save({
+        ...wsd,
+        domain,
+        bizplace: worksheet.bizplace,
+        worksheet,
+        name: WorksheetNoGenerator.pickingDetail(),
+        targetProduct,
+        targetInventory,
+        type: WORKSHEET_TYPE.PICKING,
+        status: WORKSHEET_STATUS.DEACTIVATED,
+        creator: user,
+        updater: user
+      })
+    })
+  )
+}

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

@@ -0,0 +1,34 @@
+import { checkProgressingPalletResolver } from './check-progressing-pallet'
+import { createWorksheetDetail } from './create-worksheet-detail'
+import { deleteWorksheetDetail } from './delete-worksheet-detail'
+import { generateBatchPickingWorksheetDetailsResolver } from './generate-batch-picking-worksheet-details'
+import { generateBatchPickingWorksheetDetailsByBulkResolver } from './generate-batch-picking-worksheet-details-by-bulk'
+import { generateCartonIdResolver } from './generate-carton-id'
+import { generatePalletIdResolver } from './generate-pallet-id'
+import { generatePickingWorksheetDetailsResolver } from './generate-picking-worksheet-details'
+import { generateReleaseGoodWorksheetDetailsResolver } from './generate-release-good-worksheet-details'
+import { regenerateReleaseGoodWorksheetDetailsResolver } from './regenerate-release-good-worksheet-details'
+import { updateWorksheetDetail } from './update-worksheet-detail'
+import { worksheetDetailResolver } from './worksheet-detail'
+import { worksheetDetailsResolver } from './worksheet-details'
+import { worksheetDetailsByProductGroupResolver } from './worksheet-details-by-product-group'
+
+export const Query = {
+  ...worksheetDetailsResolver,
+  ...worksheetDetailResolver,
+  ...worksheetDetailsByProductGroupResolver,
+  ...checkProgressingPalletResolver,
+  ...generatePalletIdResolver,
+  ...generateCartonIdResolver
+}
+
+export const Mutation = {
+  ...updateWorksheetDetail,
+  ...createWorksheetDetail,
+  ...deleteWorksheetDetail,
+  ...generateBatchPickingWorksheetDetailsResolver,
+  ...generateBatchPickingWorksheetDetailsByBulkResolver,
+  ...generatePickingWorksheetDetailsResolver,
+  ...generateReleaseGoodWorksheetDetailsResolver,
+  ...regenerateReleaseGoodWorksheetDetailsResolver
+}

package/server/graphql/resolvers/worksheet-detail/regenerate-release-good-worksheet-details.ts

@@ -0,0 +1,165 @@
+import { EntityManager, Repository } from 'typeorm'
+
+import { User } from '@things-factory/auth-base'
+import { Product } from '@things-factory/product-base'
+import {
+  ORDER_INVENTORY_STATUS,
+  ORDER_PRODUCT_STATUS,
+  OrderInventory,
+  OrderNoGenerator,
+  OrderProduct
+} 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 { Worksheet, WorksheetDetail } from '../../../entities'
+import { WorksheetNoGenerator } from '../../../utils'
+
+export const regenerateReleaseGoodWorksheetDetailsResolver = {
+  async regenerateReleaseGoodWorksheetDetails(
+    _: any,
+    { worksheetNo, batchId, productId, packingType, packingSize, orderProductId, worksheetDetails },
+    context: any
+  ): Promise<void> {
+    const { tx, domain, user } = context.state
+    return await regenerateReleaseGoodWorksheetDetails(
+      tx,
+      domain,
+      user,
+      worksheetNo,
+      batchId,
+      productId,
+      packingType,
+      packingSize,
+      orderProductId,
+      worksheetDetails
+    )
+  }
+}
+
+export async function regenerateReleaseGoodWorksheetDetails(
+  tx: EntityManager,
+  domain: Domain,
+  user: User,
+  worksheetNo: string,
+  batchId: string,
+  productId: string,
+  packingType: string,
+  packingSize: number,
+  orderProductId: string,
+  worksheetDetails: Partial<WorksheetDetail>[]
+): Promise<void> {
+  // 1. Remove prev worksheet details if it's exists
+  const worksheet: Worksheet = await tx.getRepository(Worksheet).findOne({
+    where: { name: worksheetNo, domain: { id: domain.id } },
+    relations: [
+      'bizplace',
+      'releaseGood',
+      'worksheetDetails',
+      'worksheetDetails.targetInventory',
+      'worksheetDetails.targetInventory.inventory',
+      'worksheetDetails.targetInventory.product',
+      'worksheetDetails.targetInventory.releaseGood',
+      'worksheetDetails.targetInventory.orderProduct',
+      'worksheetDetails.targetInventory.bizplace'
+    ]
+  })
+
+  const prevWSDs: WorksheetDetail[] = worksheet.worksheetDetails.filter((wsd: WorksheetDetail) => {
+    const targetInv: OrderInventory = wsd.targetInventory
+    if (targetInv.orderProductId === orderProductId) return wsd.id
+  })
+
+  // TODO: Update prev inventory locked qty and delete order inventories
+  if (prevWSDs?.length) {
+    const wsdIds: string[] = prevWSDs.map((wsd: WorksheetDetail) => wsd.id)
+    const prevOrderInvIds: string[] = prevWSDs.map((wsd: WorksheetDetail) => wsd.targetInventory.id)
+    const prevOrderInventories: OrderInventory[] = prevWSDs.map((wsd: WorksheetDetail) => wsd.targetInventory)
+    await Promise.all(
+      prevOrderInventories.map(async prevOI => {
+        if (prevOI?.inventory) {
+          await (tx.getRepository(Inventory) as Repository<Inventory>).update(
+            { id: prevOI.inventory.id },
+            {
+              lockedQty: prevOI.inventory.lockedQty - prevOI.releaseQty,
+              lockedUomValue: prevOI.inventory.lockedUomValue - prevOI.releaseUomValue
+            }
+          )
+        }
+      })
+    )
+
+    await tx.getRepository(WorksheetDetail).delete(wsdIds)
+    await tx.getRepository(OrderInventory).delete(prevOrderInvIds)
+  }
+
+  await Promise.all(
+    worksheetDetails.map(async (wsd: WorksheetDetail) => {
+      // 2. Create order inventory
+      let targetInventory: OrderInventory = wsd.targetInventory
+      //@ts-ignore
+      const inventory: Inventory = await tx.getRepository(Inventory).findOne(targetInventory.inventory.id)
+
+      let targetProduct: OrderProduct = await tx
+        .getRepository(OrderProduct)
+        .findOne({ where: { id: wsd.targetProduct.id }, relations: ['releaseGood'] })
+
+      targetInventory = await tx.getRepository(OrderInventory).save({
+        ...targetInventory,
+        domain,
+        bizplace: worksheet.bizplace,
+        name: OrderNoGenerator.orderInventory(),
+        releaseGood: worksheet.type == WORKSHEET_TYPE.BATCH_PICKING ? targetProduct.releaseGood : worksheet.releaseGood,
+        inventory,
+        batchId: inventory.batchId,
+        batchIdRef: inventory.batchIdRef,
+        status: ORDER_INVENTORY_STATUS.READY_TO_PICK,
+        product: await tx.getRepository(Product).findOneBy({ id: productId }),
+        packingType,
+        packingSize,
+        orderProduct: targetProduct,
+        refWorksheetId: worksheet.type == WORKSHEET_TYPE.BATCH_PICKING ? worksheet.id : null,
+        creator: user,
+        updater: user
+      })
+
+      const currentLockedQty: any = inventory.lockedQty
+      const currentLockedUomValue: any = inventory.lockedUomValue
+
+      await tx.getRepository(Inventory).save({
+        ...targetInventory.inventory,
+        lockedQty: Boolean(currentLockedQty)
+          ? targetInventory.releaseQty + currentLockedQty
+          : targetInventory.releaseQty,
+        lockedUomValue: Boolean(currentLockedUomValue)
+          ? targetInventory.releaseUomValue + currentLockedUomValue
+          : targetInventory.releaseUomValue,
+        updater: user
+      })
+
+      // update order product status to ASSIGNED
+      await tx
+        .getRepository(OrderProduct)
+        .update({ id: targetProduct.id }, { status: ORDER_PRODUCT_STATUS.ASSIGNED, updater: user } as any)
+
+      // 3. Create worksheet details
+      await tx.getRepository(WorksheetDetail).save({
+        ...wsd,
+        domain,
+        bizplace: worksheet.bizplace,
+        worksheet,
+        name:
+          worksheet.type == WORKSHEET_TYPE.BATCH_PICKING
+            ? WorksheetNoGenerator.batchPickingDetail()
+            : WorksheetNoGenerator.pickingDetail(),
+        targetProduct,
+        targetInventory,
+        type: worksheet.type == WORKSHEET_TYPE.BATCH_PICKING ? WORKSHEET_TYPE.BATCH_PICKING : WORKSHEET_TYPE.PICKING,
+        status: WORKSHEET_STATUS.DEACTIVATED,
+        creator: user,
+        updater: user
+      })
+    })
+  )
+}

package/server/graphql/resolvers/worksheet-detail/update-worksheet-detail.ts

@@ -0,0 +1,39 @@
+import { EntityManager, In } from 'typeorm'
+
+import { User } from '@things-factory/auth-base'
+import { getPermittedBizplaceIds, Worker } from '@things-factory/biz-base'
+import { OrderProduct, OrderVas } from '@things-factory/sales-base'
+import { Domain } from '@things-factory/shell'
+
+import { WorksheetDetail } from '../../../entities'
+
+export const updateWorksheetDetail = {
+  async updateWorksheetDetail(_: any, { id, patch }, context: ResolverContext) {
+    const { tx, user, domain } = context.state
+    const worksheetDetail: WorksheetDetail = await tx.getRepository(WorksheetDetail).findOne({
+      where: {
+        domain: { id: domain.id },
+        bizplace: { id: In(await getPermittedBizplaceIds(domain, user)) },
+        id
+      }
+    })
+
+    if (patch.worker && patch.worker.id) {
+      patch.worker = await tx.getRepository(Worker).findOne(patch.worker.id)
+    }
+
+    if (patch.targetProduct && patch.targetProduct.id) {
+      patch.targetProduct = await tx.getRepository(OrderProduct).findOne(patch.targetProduct.id)
+    }
+
+    if (patch.targetVas && patch.targetVas.id) {
+      patch.targetVas = await tx.getRepository(OrderVas).findOne(patch.targetVas.id)
+    }
+
+    return await tx.getRepository(WorksheetDetail).save({
+      ...worksheetDetail,
+      ...patch,
+      updater: user
+    })
+  }
+}

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

@@ -0,0 +1,19 @@
+import { In } from 'typeorm'
+
+import { getPermittedBizplaceIds } from '@things-factory/biz-base'
+
+import { WorksheetDetail } from '../../../entities'
+
+export const worksheetDetailResolver = {
+  async worksheetDetail(_: any, { name }, context: ResolverContext) {
+    const { tx, user, domain } = context.state
+    tx.getRepository(WorksheetDetail).findOne({
+      where: {
+        domain: { id: domain.id },
+        bizplace: { id: In(await getPermittedBizplaceIds(domain, user)) },
+        name
+      },
+      relations: ['domain', 'bizplace', 'worksheet', 'worker', 'targetProduct', 'targetVas', 'creator', 'updater']
+    })
+  }
+}