@things-factory/sales-base 4.0.0-alpha.7 → 4.0.0-beta.1

package/server/graphql/resolvers/collection-order/generate-collection-order.ts

@@ -1,37 +0,0 @@
-import { createAttachments } from '@things-factory/attachment-base'
-import { User } from '@things-factory/auth-base'
-import { Bizplace, getMyBizplace } from '@things-factory/biz-base'
-import { Domain } from '@things-factory/shell'
-import { EntityManager } from 'typeorm'
-import { ORDER_STATUS } from '../../../constants'
-import { ArrivalNotice, CollectionOrder } from '../../../entities'
-
-export const generateCollectionOrder = {
-  async generateCollectionOrder(_: any, { collectionOrder, attachments }, context: any) {
-    const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
-
-    const myBizplace: Bizplace = await getMyBizplace(domain, user)
-    // 1. Create collection order
-    const createdCollectionOrder: CollectionOrder = await tx.getRepository(CollectionOrder).save({
-      ...collectionOrder,
-      domain,
-      bizplace: myBizplace,
-      arrivalNotice: await tx.getRepository(ArrivalNotice).findOne({
-        where: { domain, name: collectionOrder.refNo }
-      }),
-      status: ORDER_STATUS.PENDING,
-      creator: user,
-      updater: user
-    })
-
-    // 2. Create attachment
-    if (!attachments) return createdCollectionOrder
-
-    attachments = attachments.map(attachment => {
-      return { refBy: createdCollectionOrder.id, file: attachment, category: 'ORDER' }
-    })
-    await createAttachments(_, { attachments }, context)
-
-    return createdCollectionOrder
-  }
-}

package/server/graphql/resolvers/collection-order/index.ts

@@ -1,28 +0,0 @@
-import { collectionOrderResolver } from './collection-order'
-import { collectionOrdersResolver } from './collection-orders'
-import { collectionOrderRequestsResolver } from './collection-order-requests'
-import { deleteCollectionOrder } from './delete-collection-order'
-import { updateCollectionOrder } from './update-collection-order'
-import { generateCollectionOrder } from './generate-collection-order'
-import { confirmCollectionOrder } from './confirm-collection-order'
-import { receiveCollectionOrder } from './receive-collection-order'
-import { dispatchCollectionOrder } from './dispatch-collection-order'
-import { checkCollectedOrder } from './check-collected-order'
-import { rejectCollectionOrder } from './reject-collection-order'
-
-export const Query = {
-  ...collectionOrdersResolver,
-  ...collectionOrderResolver,
-  ...collectionOrderRequestsResolver
-}
-
-export const Mutation = {
-  ...updateCollectionOrder,
-  ...deleteCollectionOrder,
-  ...generateCollectionOrder,
-  ...confirmCollectionOrder,
-  ...receiveCollectionOrder,
-  ...dispatchCollectionOrder,
-  ...checkCollectedOrder,
-  ...rejectCollectionOrder
-}

package/server/graphql/resolvers/collection-order/receive-collection-order.ts

@@ -1,30 +0,0 @@
-import { User } from '@things-factory/auth-base'
-import { Domain } from '@things-factory/shell'
-import { EntityManager } from 'typeorm'
-import { ORDER_STATUS } from '../../../constants'
-import { CollectionOrder } from '../../../entities'
-
-export const receiveCollectionOrder = {
-  async receiveCollectionOrder(_: any, { name }, context: any) {
-    try {
-      const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
-
-      const collectionOrder: CollectionOrder = await tx.getRepository(CollectionOrder).findOne({
-        where: { domain, name }
-      })
-
-      if (!collectionOrder) throw new Error(`Collection order doesn't exists.`)
-      if (collectionOrder.status !== ORDER_STATUS.PENDING_RECEIVE) throw new Error(`Status is not receivable.`)
-
-      await tx.getRepository(CollectionOrder).save({
-        ...collectionOrder,
-        status: ORDER_STATUS.READY_TO_DISPATCH,
-        updater: user
-      })
-
-      return collectionOrder
-    } catch (e) {
-      throw e
-    }
-  }
-}

package/server/graphql/resolvers/collection-order/reject-collection-order.ts

@@ -1,32 +0,0 @@
-import { User } from '@things-factory/auth-base'
-import { Domain } from '@things-factory/shell'
-import { EntityManager } from 'typeorm'
-import { ORDER_STATUS } from '../../../constants'
-import { CollectionOrder } from '../../../entities'
-
-export const rejectCollectionOrder = {
-  async rejectCollectionOrder(_: any, { name, patch }, context: any) {
-    try {
-      const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
-
-      const collectionOrder: CollectionOrder = await tx.getRepository(CollectionOrder).findOne({
-        where: { domain, name }
-      })
-
-      if (!collectionOrder) throw new Error(`Collection order doesn't exists.`)
-      if (!patch.remark) throw new Error('Remark is not exist.')
-      if (collectionOrder.status !== ORDER_STATUS.PENDING_RECEIVE) throw new Error(`Status is not receivable.`)
-
-      await tx.getRepository(CollectionOrder).save({
-        ...collectionOrder,
-        ...patch,
-        status: ORDER_STATUS.REJECTED,
-        updater: user
-      })
-
-      return collectionOrder
-    } catch (e) {
-      throw e
-    }
-  }
-}

package/server/graphql/resolvers/collection-order/update-collection-order.ts

@@ -1,25 +0,0 @@
-import { getPermittedBizplaceIds } from '@things-factory/biz-base'
-import { EntityManager, In } from 'typeorm'
-import { Domain } from '@things-factory/shell'
-import { User } from '@things-factory/auth-base'
-import { CollectionOrder } from '../../../entities'
-
-export const updateCollectionOrder = {
-  async updateCollectionOrder(_: any, { name, patch }, context: any) {
-    const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
-
-    const collectionOrder = await tx.getRepository(CollectionOrder).findOne({
-      where: {
-        domain,
-        name,
-        bizplace: In(await getPermittedBizplaceIds(domain, user))
-      }
-    })
-
-    return await tx.getRepository(CollectionOrder).save({
-      ...collectionOrder,
-      ...patch,
-      updater: user
-    })
-  }
-}

package/server/graphql/resolvers/delivery-order/check-delivered-order.ts

@@ -1,60 +0,0 @@
-import { User } from '@things-factory/auth-base'
-import { Domain } from '@things-factory/shell'
-import { TransportVehicle, TRUCK_STATUS } from '@things-factory/transport-base'
-import { EntityManager } from 'typeorm'
-import { ORDER_STATUS, ORDER_INVENTORY_STATUS, ORDER_TYPES } from '../../../constants'
-import { DeliveryOrder, OrderInventory } from '../../../entities'
-
-export const checkDeliveredOrder = {
-  async checkDeliveredOrder(_: any, { name, patch }, context: any) {
-    try {
-      const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
-      const deliveryOrder: DeliveryOrder = await tx.getRepository(DeliveryOrder).findOne({
-        where: { domain, name },
-        relations: ['bizplace', 'transportDriver', 'transportVehicle']
-      })
-
-      if (!deliveryOrder) throw new Error(`Delivery order doesn't exists.`)
-      if (deliveryOrder.status !== ORDER_STATUS.DELIVERING) throw new Error(`Status is not receivable.`)
-
-      let orderInventories: OrderInventory[] = await tx.getRepository(OrderInventory).find({
-        where: { domain, deliveryOrder: deliveryOrder },
-        relations: ['product']
-      })
-      
-      // update order inventory status for manual DO only
-      orderInventories = orderInventories.map((orderInventory: OrderInventory) => {
-        if (
-          orderInventory.type === ORDER_TYPES.DELIVERY &&
-          orderInventory.status === ORDER_INVENTORY_STATUS.DELIVERING
-        ) {
-          return {
-            ...orderInventory,
-            status: ORDER_INVENTORY_STATUS.DONE
-          }
-        } else return orderInventory
-      })
-      await tx.getRepository(OrderInventory).save(orderInventories)
-      
-      await tx.getRepository(DeliveryOrder).save({
-        ...deliveryOrder,
-        ...patch,
-        status: ORDER_STATUS.DONE,
-        updater: user
-      })
-
-      if (!deliveryOrder?.ownCollection) {
-        const foundTruck: TransportVehicle = deliveryOrder.transportVehicle
-        await tx.getRepository(TransportVehicle).save({
-          ...foundTruck,
-          status: TRUCK_STATUS.IDLE,
-          updater: user
-        })
-      }
-
-      return deliveryOrder
-    } catch (e) {
-      throw e
-    }
-  }
-}

package/server/graphql/resolvers/delivery-order/confirm-delivery-order.ts

@@ -1,29 +0,0 @@
-import { User } from '@things-factory/auth-base'
-import { Domain } from '@things-factory/shell'
-import { EntityManager } from 'typeorm'
-import { ORDER_STATUS } from '../../../constants'
-import { DeliveryOrder } from '../../../entities'
-
-export const confirmDeliveryOrder = {
-  async confirmDeliveryOrder(_: any, { name }, context: any) {
-    const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
-
-    const foundDeliveryOrder: DeliveryOrder = await tx.getRepository(DeliveryOrder).findOne({
-      where: { domain, name },
-      relations: ['creator', 'updater']
-    })
-
-    let deliveryOrder: DeliveryOrder
-    if (!foundDeliveryOrder) throw new Error(`Delivery Order doesn't exists.`)
-    if (foundDeliveryOrder.status !== ORDER_STATUS.PENDING) throw new Error('Not confirmable status.')
-
-    // delivery Order Status change (PENDING => PENDING_RECEIVE)
-    deliveryOrder = await tx.getRepository(DeliveryOrder).save({
-      ...foundDeliveryOrder,
-      status: ORDER_STATUS.PENDING_RECEIVE,
-      updater: user
-    })
-
-    return deliveryOrder
-  }
-}

package/server/graphql/resolvers/delivery-order/create-delivery-order.ts

@@ -1,185 +0,0 @@
-import { Attachment, createAttachments } from '@things-factory/attachment-base'
-import { ATTACHMENT_TYPE } from '../../../constants/attachment-type'
-import { Bizplace, ContactPoint } from '@things-factory/biz-base'
-import { DeliveryOrder, OrderInventory } from '../../../entities'
-import { Domain } from '@things-factory/shell'
-import { EntityManager, getRepository, Repository } from 'typeorm'
-import { generateId } from '@things-factory/id-rule-base'
-import { ORDER_STATUS, ORDER_NUMBER_SETTING_KEY, ORDER_NUMBER_RULE_TYPE, ORDER_INVENTORY_STATUS, ORDER_TYPES } from '../../../constants'
-import { OrderNoGenerator } from '../../../utils/order-no-generator'
-import { Product } from '@things-factory/product-base'
-import { Setting } from '@things-factory/setting-base'
-import { TransportVehicle, TransportDriver, TRUCK_STATUS } from '@things-factory/transport-base'
-import { User } from '@things-factory/auth-base'
-
-export const createDeliveryOrderResolver = {
-  async createDeliveryOrder(_: any, { orderInfo, customerBizplace, targetInventories, file }, context: any) {
-    const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
-
-    return await createDeliveryOrder(orderInfo, customerBizplace, targetInventories, file, domain, user, tx)
-  }
-}
-
-export async function createDeliveryOrder(
-  orderInfo: any,
-  customerBizplace: Bizplace,
-  targetInventories: OrderInventory[],
-  file: Attachment,
-  domain: Domain,
-  user: User,
-  tx?: EntityManager
-): Promise<DeliveryOrder> {
-
-  const bizplaceRepo: Repository<Bizplace> = tx?.getRepository(Bizplace) || getRepository(Bizplace)
-  const contactPointRepo: Repository<ContactPoint> = tx?.getRepository(ContactPoint) || getRepository(ContactPoint)
-  const deliveryOrderRepo: Repository<DeliveryOrder> = tx?.getRepository(DeliveryOrder) || getRepository(DeliveryOrder)
-  const productRepo: Repository<Product> = tx?.getRepository(Product) || getRepository(Product)
-  const transportVehicleRepo: Repository<TransportVehicle> =
-    tx?.getRepository(TransportVehicle) || getRepository(TransportVehicle)
-  const transportDriverRepo: Repository<TransportDriver> =
-    tx?.getRepository(TransportDriver) || getRepository(TransportDriver)
-  const orderInventoryRepo: Repository<OrderInventory> =
-    tx?.getRepository(OrderInventory) || getRepository(OrderInventory)
-  const settingRepo: Repository<Setting> = tx?.getRepository(Setting) || getRepository(Setting)
-
-  const foundBizplace: Bizplace = await bizplaceRepo.findOne({
-    where: {
-      id: customerBizplace.id,
-      name: customerBizplace.name
-    }
-  })
-  
-  if (!foundBizplace) throw new Error(`customer not found`)
-
-  // #1 find order number setting and set as DO name
-  const doNoSetting: Setting = await settingRepo.findOne({
-    where: {
-      domain,
-      name: ORDER_NUMBER_SETTING_KEY.DO_NUMBER_RULE
-    }
-  })
-
-  let orderNo: string = ''
-
-  if (doNoSetting) {
-    orderNo = await generateId({ domain, type: ORDER_NUMBER_RULE_TYPE.DO_NUMBER, seed: {} })
-  } else {
-    orderNo = OrderNoGenerator.deliveryOrder()
-  }
-
-  // #2 update truck vehicle status to IN_USE (only if using warehouse truck)
-  let transportVehicle: TransportVehicle = null
-  let transportDriver: TransportDriver = null
-  
-  if (!orderInfo.ownCollection) {
-    transportVehicle = await transportVehicleRepo.findOne({
-      where: {
-        domain,
-        id: orderInfo.transportVehicle
-      }
-    })
-
-    transportDriver = await transportDriverRepo.findOne({
-      where: {
-        domain,
-        id: orderInfo.transportDriver
-      }
-    })
-    
-    transportVehicle = {
-      ...transportVehicle,
-      status: TRUCK_STATUS.IN_USE,
-      updater: user
-    }
-
-    await transportVehicleRepo.save(transportVehicle)
-  }
-  
-  // #3 save other destination info in Contact Point if there's any
-  let foundCP: ContactPoint = {}
-  if (orderInfo?.otherDestination) {
-    foundCP = {
-      domain,
-      name: orderInfo.contactName,
-      bizplace: foundBizplace,
-      address: orderInfo.otherDestination,
-      billingAddress: orderInfo.otherBillingAddress
-        ? orderInfo.otherBillingAddress
-        : orderInfo.otherDestination,
-      phone: orderInfo.contactPhone || '-',
-      email: orderInfo.contactEmail || '-',
-      companyName: orderInfo.contactCompany || '-',
-      type: orderInfo.contactType,
-      creator: user,
-      updater: user
-    }
-    foundCP = await tx.getRepository(ContactPoint).save(foundCP)
-  } else {
-    foundCP = await tx.getRepository(ContactPoint).findOne({
-      where: { domain, id: orderInfo.contactPointRefId, bizplace: foundBizplace }
-    })
-  }
-
-  // #4 save the delivery order info
-  let totalPalletQty = 0
-  targetInventories.forEach(oi => totalPalletQty += oi.palletQty)
-
-  let deliveryOrder: any = {
-    domain,
-    name: orderNo,
-    refNo: orderInfo.refNo,
-    bizplace: foundBizplace,
-    deliveryDate: orderInfo.deliveryDate,
-    ownCollection: orderInfo.ownCollection,
-    truckNo: orderInfo.truckNo,
-    palletQty: totalPalletQty,
-    status: ORDER_STATUS.READY_TO_DISPATCH,
-    contactPointRefId: foundCP.id,
-    remark: orderInfo.remark,
-    transportDriver,
-    transportVehicle,
-    otherDriver: orderInfo.otherDriver,
-    creator: user,
-    updater: user
-  }
-  deliveryOrder = <DeliveryOrder>await deliveryOrderRepo.save(deliveryOrder)
-
-  // #5 save order inventories
-  targetInventories = await Promise.all(
-    targetInventories.map(async (orderInventory: OrderInventory) => {
-      const product: Product = await productRepo.findOne({
-        where: {
-          id: orderInventory.product.id
-        }
-      })
-
-      if (!product) throw new Error(`product not found`)
-      return {
-        ...orderInventory,
-        domain,
-        product,
-        name: OrderNoGenerator.orderInventory(),
-        bizplace: foundBizplace,
-        status: ORDER_INVENTORY_STATUS.READY_TO_DISPATCH,
-        type: ORDER_TYPES.DELIVERY,
-        deliveryOrder,
-        creator: user,
-        updater: user
-      }
-    })
-  )
-  await orderInventoryRepo.save(targetInventories)
-
-  // if (file?.length) {
-  //   const attachments: Attachment[] = file.map(attachment => {
-  //     return {
-  //       file: attachment,
-  //       refBy: deliveryOrder.id,
-  //       category: ATTACHMENT_TYPE.GAN
-  //     }
-  //   })
-  //   await createAttachments(_, { attachments }, context)
-  // }
-
-  return deliveryOrder
-}

package/server/graphql/resolvers/delivery-order/delete-delivery-order.ts

@@ -1,22 +0,0 @@
-import { Attachment, deleteAttachment } from '@things-factory/attachment-base'
-import { Domain } from '@things-factory/shell'
-import { EntityManager } from 'typeorm'
-import { DeliveryOrder } from '../../../entities'
-
-export const deleteDeliveryOrder = {
-  async deleteDeliveryOrder(_: any, { name }, context: any) {
-    const { tx, domain }: { tx: EntityManager; domain: Domain } = context.state
-
-    const foundDO = await tx.getRepository(DeliveryOrder).findOne({
-      where: { domain, name }
-    })
-    if (foundDO) {
-      const previousAttachment: Attachment = await tx.getRepository(Attachment).findOne({
-        where: { domain, refBy: foundDO.id }
-      })
-      if (previousAttachment) await deleteAttachment(_, { id: previousAttachment.id }, context)
-      await tx.getRepository(DeliveryOrder).delete({ domain, name })
-    }
-    return true
-  }
-}

package/server/graphql/resolvers/delivery-order/delivery-order-by-release-good.ts

@@ -1,40 +0,0 @@
-import { EntityManager, getRepository, Repository } from 'typeorm'
-import { DeliveryOrder, OrderInventory, ReleaseGood } from '../../../entities'
-
-export const deliveryOrderByReleaseGoodResolver = {
-  async deliveryOrderByReleaseGood(_: any, { releaseGoodNo }, context: any) {
-    const releaseGood: ReleaseGood = await getRepository(ReleaseGood).findOne({
-      where: { name: releaseGoodNo }
-    })
-
-    return await deliveryOrderByReleaseGood(releaseGood)
-  }
-}
-
-export async function deliveryOrderByReleaseGood(releaseGood: ReleaseGood, trxMgr?: EntityManager): Promise<any> {
-  const doRepo: Repository<DeliveryOrder> = trxMgr?.getRepository(DeliveryOrder) || getRepository(DeliveryOrder)
-  const oiRepo: Repository<OrderInventory> = trxMgr?.getRepository(OrderInventory) || getRepository(OrderInventory)
-
-  let [items, total] = await doRepo.findAndCount({
-    where: { releaseGood },
-    relations: ['domain', 'bizplace', 'releaseGood', 'transportDriver', 'transportVehicle', 'creator', 'updater']
-  })
-
-  items = await Promise.all(
-    items.map(async (deliveryOrder: DeliveryOrder) => {
-      return {
-        ...deliveryOrder,
-        truck: deliveryOrder?.truckNo || deliveryOrder.transportVehicle?.name || null,
-        targetInventories: await oiRepo.find({
-          where: { deliveryOrder },
-          relations: ['domain', 'bizplace', 'releaseGood', 'inventory']
-        })
-      }
-    })
-  )
-
-  return {
-    items,
-    total
-  }
-}

package/server/graphql/resolvers/delivery-order/delivery-order-items.ts

@@ -1,97 +0,0 @@
-import { Product } from '@things-factory/product-base'
-import { Domain } from '@things-factory/shell'
-import { Inventory } from '@things-factory/warehouse-base'
-import { getRepository } from 'typeorm'
-import { DeliveryOrder, OrderInventory } from '../../../entities'
-
-export const deliveryOrderItemsResolver = {
-  async deliveryOrderItems(_: any, { name }, context: any) {
-    const { domain }: { domain: Domain } = context.state
-    const deliveryOrder: DeliveryOrder = await getRepository(DeliveryOrder).findOne({
-      where: { domain, name }
-    })
-
-    let [items, total] = await getRepository(OrderInventory).findAndCount({
-      where: { domain, deliveryOrder },
-      relations: ['inventory', 'inventory.product', 'inventory.reusablePallet']
-    })
-
-    items = items
-      .map((oi: OrderInventory) => {
-        const inventory: Inventory = oi.inventory
-        const product: Product = inventory.product
-        return {
-          inventory: inventory,
-          productName: `${product.name} (${product.description})`,
-          packingType: inventory.packingType,
-          batchId: inventory.batchId,
-          releaseQty: oi.releaseQty,
-          releaseUomValue: oi.releaseUomValue,
-          remark: oi.remark,
-          crossDocking: oi.crossDocking,
-          pallet: inventory?.reusablePallet && inventory?.reusablePallet?.name ? inventory.reusablePallet.name : ''
-        }
-      })
-      .reduce((newItem, item) => {
-        var foundItem = newItem.find(
-          newItem =>
-            newItem.productName === item.productName &&
-            newItem.batchId === item.batchId &&
-            newItem.crossDocking === item.crossDocking &&
-            newItem.pallet === item.pallet
-        )
-        if (!foundItem) {
-          foundItem = {
-            inventory: item.inventory,
-            productName: item.productName,
-            packingType: item.packingType,
-            batchId: item.batchId,
-            releaseQty: item.releaseQty,
-            releaseUomValue: item.releaseUomValue,
-            palletQty: 1,
-            remark: item.remark,
-            crossDocking: item.crossDocking,
-            pallet: item.pallet
-          }
-
-          newItem.push(foundItem)
-          return newItem
-        } else {
-          return newItem.map(ni => {
-            if (
-              ni.productName === item.productName &&
-              ni.batchId === item.batchId &&
-              ni.crossDocking === item.crossDocking &&
-              ni.pallet === item.pallet
-            ) {
-              return {
-                ...ni,
-                palletQty: ni.palletQty + 1,
-                releaseQty: ni.releaseQty + item.releaseQty,
-                releaseUomValue: ni.releaseUomValue + item.releaseUomValue
-              }
-            } else {
-              return ni
-            }
-          })
-        }
-      }, [])
-
-    items = items.map((prod: any) => {
-      return {
-        ...prod,
-        systemRemark: prod?.remark
-          ? prod.remark
-          : prod.crossDocking
-          ? prod.pallet === ''
-            ? `${prod.palletQty} PALLET(S) [C/D]`
-            : `${prod.palletQty} PALLET(S) (${prod.pallet}) [C/D]`
-          : prod.pallet === ''
-          ? `${prod.palletQty} PALLET(S)`
-          : `${prod.palletQty} PALLET(S) (${prod.pallet})`
-      }
-    })
-
-    return { items, total }
-  }
-}

package/server/graphql/resolvers/delivery-order/delivery-order-requests.ts

@@ -1,26 +0,0 @@
-import { User } from '@things-factory/auth-base'
-import { getPermittedBizplaceIds } from '@things-factory/biz-base'
-import { convertListParams, Domain, ListParam } from '@things-factory/shell'
-import { getRepository, In, Not } from 'typeorm'
-import { ORDER_STATUS } from '../../../constants'
-import { DeliveryOrder } from '../../../entities'
-
-export const deliveryOrderRequestsResolver = {
-  async deliveryOrderRequests(_: any, params: ListParam, context: any) {
-    const { domain, user }: { domain: Domain; user: User } = context.state
-
-    const convertedParams = convertListParams(params)
-
-    if (!convertedParams.where || !convertedParams.where.status) {
-      convertedParams.where.status = Not(In([ORDER_STATUS.PENDING, ORDER_STATUS.EDITING]))
-    }
-    convertedParams.bizplace = In(await getPermittedBizplaceIds(domain, user))
-
-    const [items, total] = await getRepository(DeliveryOrder).findAndCount({
-      ...convertedParams,
-      relations: ['domain', 'bizplace', 'releaseGood', 'transportDriver', 'transportVehicle', 'creator', 'updater']
-    })
-
-    return { items, total }
-  }
-}

package/server/graphql/resolvers/delivery-order/delivery-order.ts

@@ -1,30 +0,0 @@
-import { Attachment } from '@things-factory/attachment-base'
-import { Domain } from '@things-factory/shell'
-import { getRepository } from 'typeorm'
-import { DeliveryOrder } from '../../../entities'
-
-export const deliveryOrderResolver = {
-  async deliveryOrder(_: any, { name }, context: any) {
-    const { domain }: { domain: Domain } = context.state
-
-    const foundDO = await getRepository(DeliveryOrder).findOne({
-      where: {
-        domain,
-        name
-      },
-      relations: ['domain', 'bizplace', 'transportDriver', 'transportVehicle', 'releaseGood', 'creator', 'updater']
-    })
-
-    let foundAttachments = []
-    if (foundDO) {
-      foundAttachments = await getRepository(Attachment).find({
-        where: {
-          domain,
-          refBy: foundDO.id
-        }
-      })
-    }
-
-    return { ...foundDO, attachments: foundAttachments }
-  }
-}