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

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

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

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

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

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

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

@@ -1,19 +0,0 @@
-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']
-    })
-  }
-}