@things-factory/sales-base 4.0.0-y.0 → 4.0.4

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

@@ -1,82 +0,0 @@
-import { getPermittedBizplaceIds } from '@things-factory/biz-base'
-import { buildQuery, convertListParams, ListParam } from '@things-factory/shell'
-import { getRepository, SelectQueryBuilder } from 'typeorm'
-import { User } from '@things-factory/auth-base'
-import { Domain } from '@things-factory/shell'
-import { DeliveryOrder, ReleaseGood, OrderInventory } from '../../../entities'
-
-export const deliveryOrdersResolver = {
-  async deliveryOrders(_: any, params: ListParam, context: any) {
-    const { domain, user }: { domain: Domain; user: User } = context.state
-
-    const bizplaceFilter = params.filters.find(param => param.name === 'bizplaceId')
-    if (!bizplaceFilter) {
-      params.filters.push({
-        name: 'bizplaceId',
-        operator: 'in',
-        value: await getPermittedBizplaceIds(domain, user),
-        relation: false
-      })
-    }
-
-    const releaseGoodParam = params.filters.find(param => param.name === 'releaseGoodNo')
-    if (releaseGoodParam) {
-      let arrFilters = []
-      params.filters.splice(
-        params.filters.findIndex(item => item.name == 'releaseGoodNo'),
-        1
-      )
-      arrFilters.push({ ...releaseGoodParam, name: 'name' })
-
-      const foundReleaseGoods: ReleaseGood[] = await getRepository(ReleaseGood).find({
-        ...convertListParams({ filters: arrFilters })
-      })
-
-      if (foundReleaseGoods && foundReleaseGoods.length) {
-        params.filters.push({
-          name: 'releaseGoodId',
-          operator: 'in',
-          value: foundReleaseGoods.map((releaseGood: ReleaseGood) => releaseGood.id),
-          relation: false
-        })
-      }
-    }
-
-    const qb: any = getRepository(DeliveryOrder).createQueryBuilder('do')
-    buildQuery(qb, params, context)
-    qb.addSelect(subQuery => {
-      return subQuery
-        .select('COALESCE("ccd".rank, 99999)', 'rank')
-        .from('common_code_details', 'ccd')
-        .innerJoin('ccd.commonCode', 'cc')
-        .where('"ccd"."name" = "do"."status"')
-        .andWhere('"ccd"."domain_id" = "do"."domain_id"')
-        .andWhere('"cc"."name" = \'DELIVERY_STATUS\'')
-    }, 'rank')
-    qb.leftJoinAndSelect('do.domain', 'domain')
-    qb.leftJoinAndSelect('do.bizplace', 'bizplace')
-    qb.leftJoinAndSelect('do.releaseGood', 'rg')
-    qb.leftJoinAndSelect('do.orderInventories', 'oi')
-    qb.leftJoinAndSelect('oi.inventory', 'inv')
-    qb.leftJoinAndSelect('inv.product', 'prdc')
-    qb.leftJoinAndSelect('inv.reusablePallet', 'plt')
-    qb.leftJoinAndSelect('do.transportDriver', 'td')
-    qb.leftJoinAndSelect('do.transportVehicle', 'th')
-    qb.leftJoinAndSelect('do.creator', 'creator')
-    qb.leftJoinAndSelect('do.updater', 'updater')
-
-    const arrChildSortData = ['bizplace', 'releaseGood']
-    const sort = (params.sortings || []).reduce(
-      (acc, sort) => ({
-        ...acc,
-        [arrChildSortData.indexOf(sort.name) >= 0 ? sort.name + '.name' : 'do.' + sort.name]: sort.desc ? 'DESC' : 'ASC'
-      }),
-      !params.sortings.some(e => e.name === 'status') ? { rank: 'ASC' } : {}
-    )
-
-    qb.orderBy(sort)
-    const [items, total] = await qb.getManyAndCount()
-
-    return { items, total }
-  }
-}

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

@@ -1,114 +0,0 @@
-import { EntityManager } from 'typeorm'
-import { ORDER_STATUS } from '../../../constants'
-import { DeliveryOrder, OrderInventory } from '../../../entities'
-import { Domain } from '@things-factory/shell'
-import { User } from '@things-factory/auth-base'
-import { ContactPoint } from '@things-factory/biz-base'
-import { TransportDriver, TransportVehicle, TRUCK_STATUS } from '@things-factory/transport-base'
-import { Inventory } from '@things-factory/warehouse-base'
-import { Product } from '@things-factory/product-base'
-
-export const dispatchDeliveryOrder = {
-  async dispatchDeliveryOrder(_: any, { orderInfo, orderItems }, context: any) {
-    try {
-      const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
-      const foundDeliveryOrder: DeliveryOrder = await tx.getRepository(DeliveryOrder).findOne({
-        where: { domain, name: orderInfo.name },
-        relations: ['transportVehicle', 'bizplace']
-      })
-
-      if (!foundDeliveryOrder) throw new Error(`Delivery order doesn't exists.`)
-      if (foundDeliveryOrder.status === ORDER_STATUS.PENDING_CANCEL)
-        throw new Error('Release order is pending for cancel')
-
-      let deliveryOrderStatus = foundDeliveryOrder.status
-      let orderInventories: OrderInventory[]
-      orderInventories = await tx.getRepository(OrderInventory).find({
-        where: { domain, deliveryOrder: foundDeliveryOrder },
-        relations: ['inventory', 'inventory.product', 'inventory.reusablePallet']
-      })
-
-      orderInventories = orderInventories.map((orderInventory: OrderInventory) => {
-        const inventory: Inventory = orderInventory.inventory
-        const product: Product = inventory.product
-        const foundItem = inventory.reusablePallet
-          ? orderItems.filter(
-              (item: any) =>
-                item.productName === `${product.name} (${product.description})` &&
-                item.pallet === inventory.reusablePallet.name
-            )
-          : orderItems.filter((item: any) => item.productName === `${product.name} (${product.description})`)
-
-        if (foundItem[0].remark !== '') orderInventory.remark = foundItem[0].remark
-        return orderInventory
-      })
-      await tx.getRepository(OrderInventory).save(orderInventories)
-
-      // if there is other destination value, create a new contact point
-      let foundCP: any = {}
-      if (orderInfo?.otherDestination) {
-        foundCP = {
-          domain,
-          name: orderInfo.contactName,
-          bizplace: foundDeliveryOrder.bizplace,
-          address: orderInfo.otherDestination,
-          billingAddress: orderInfo.billingAddress,
-          phone: orderInfo.contactPhone,
-          email: orderInfo.contactEmail,
-          companyName: orderInfo.contactCompany,
-          type: orderInfo.contactType,
-          creator: user
-        }
-        foundCP = await tx.getRepository(ContactPoint).save(foundCP)
-      } else {
-        foundCP = await tx.getRepository(ContactPoint).findOne({
-          where: { domain, id: orderInfo.contactPoint, bizplace: foundDeliveryOrder.bizplace }
-        })
-      }
-
-      let transportDriver: TransportDriver = null
-      let transportVehicle: TransportVehicle = null
-      if (orderInfo?.ownDriver) {
-        transportDriver = await tx.getRepository(TransportDriver).findOne({
-          where: { domain, name: orderInfo.ownDriver }
-        })
-      }
-
-      if (orderInfo?.ownTruck) {
-        transportVehicle = await tx.getRepository(TransportVehicle).findOne({
-          where: { domain, name: orderInfo.ownTruck }
-        })
-
-        await tx.getRepository(TransportVehicle).save({
-          ...transportVehicle,
-          status: TRUCK_STATUS.IN_USE,
-          updater: user
-        })
-      }
-
-      if (foundDeliveryOrder.status === ORDER_STATUS.READY_TO_DISPATCH) {
-        // update status to DELIVERING if current status is READY_TO_DISPATCH
-        deliveryOrderStatus = ORDER_STATUS.DELIVERING
-      }
-
-      await tx.getRepository(DeliveryOrder).save({
-        ...foundDeliveryOrder,
-        transportDriver,
-        transportVehicle,
-        contactPointRefId: foundCP.id || null,
-        otherDriver: orderInfo?.otherDriver || null,
-        truckNo: orderInfo?.otherTruck || orderInfo?.ownTruck,
-        to: foundCP.address,
-        deliveryDate: orderInfo.deliveryDate,
-        remark: orderInfo.remark,
-        status: deliveryOrderStatus,
-        reusablePallet: orderInfo.reusablePallet,
-        updater: user
-      })
-
-      return foundDeliveryOrder
-    } catch (e) {
-      throw e
-    }
-  }
-}

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

@@ -1,114 +0,0 @@
-import { EntityManager } from 'typeorm'
-import { ORDER_STATUS, ORDER_INVENTORY_STATUS } from '../../../constants'
-import { DeliveryOrder, OrderInventory } from '../../../entities'
-import { Domain } from '@things-factory/shell'
-import { User } from '@things-factory/auth-base'
-import { ContactPoint } from '@things-factory/biz-base'
-import { TransportDriver, TransportVehicle, TRUCK_STATUS } from '@things-factory/transport-base'
-import { Product } from '@things-factory/product-base'
-
-export const dispatchManualDeliveryOrder = {
-  async dispatchManualDeliveryOrder(_: any, { orderInfo, orderItems }, context: any) {
-    try {
-      const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
-      const foundDeliveryOrder: DeliveryOrder = await tx.getRepository(DeliveryOrder).findOne({
-        where: { domain, name: orderInfo.name },
-        relations: ['transportVehicle', 'bizplace']
-      })
-
-      if (!foundDeliveryOrder) throw new Error(`Delivery order doesn't exists.`)
-      if (foundDeliveryOrder.status === ORDER_STATUS.PENDING_CANCEL)
-        throw new Error('Release order is pending for cancel')
-
-      let deliveryOrderStatus = foundDeliveryOrder.status
-      let orderInventories: OrderInventory[]
-      orderInventories = await tx.getRepository(OrderInventory).find({
-        where: { domain, deliveryOrder: foundDeliveryOrder },
-        relations: ['product']
-      })
-
-      // if there is other destination value, create a new contact point
-      let foundCP: any = {}
-      if (orderInfo?.otherDestination) {
-        foundCP = {
-          domain,
-          name: orderInfo.contactName,
-          bizplace: foundDeliveryOrder.bizplace,
-          address: orderInfo.otherDestination,
-          billingAddress: orderInfo.billingAddress,
-          phone: orderInfo.contactPhone,
-          email: orderInfo.contactEmail,
-          companyName: orderInfo.contactCompany,
-          type: orderInfo.contactType,
-          creator: user
-        }
-        foundCP = await tx.getRepository(ContactPoint).save(foundCP)
-      } else {
-        foundCP = await tx.getRepository(ContactPoint).findOne({
-          where: { domain, id: orderInfo.contactPoint }
-        })
-      }
-
-      let transportDriver: TransportDriver = null
-      let transportVehicle: TransportVehicle = null
-      if (orderInfo?.ownDriver) {
-        transportDriver = await tx.getRepository(TransportDriver).findOne({
-          where: { domain, name: orderInfo.ownDriver }
-        })
-      }
-
-      if (orderInfo?.ownTruck) {
-        transportVehicle = await tx.getRepository(TransportVehicle).findOne({
-          where: { domain, name: orderInfo.ownTruck }
-        })
-
-        await tx.getRepository(TransportVehicle).save({
-          ...transportVehicle,
-          status: TRUCK_STATUS.IN_USE,
-          updater: user
-        })
-      }
-
-      orderInventories = orderInventories.map((orderInventory: OrderInventory) => {
-        const remark = orderItems.find(
-          (item: any) => 
-            item.productId === orderInventory.product.id &&
-            item.batchId === orderInventory.batchId
-        ).remark
-
-        // add remark if found, else remain existing remark
-        if (remark) {
-          orderInventory.remark = remark
-        }
-
-        // update status of DO and order inventory to DELIVERING if current status is READY_TO_DISPATCH
-        if (foundDeliveryOrder.status === ORDER_STATUS.READY_TO_DISPATCH) {
-          deliveryOrderStatus = ORDER_STATUS.DELIVERING
-          orderInventory.status = ORDER_STATUS.DELIVERING
-        }
-
-        return orderInventory
-      })
-      await tx.getRepository(OrderInventory).save(orderInventories)
-
-      await tx.getRepository(DeliveryOrder).save({
-        ...foundDeliveryOrder,
-        transportDriver,
-        transportVehicle,
-        contactPointRefId: foundCP.id || null,
-        otherDriver: orderInfo?.otherDriver || null,
-        truckNo: orderInfo?.otherTruck || orderInfo?.ownTruck,
-        to: foundCP.address,
-        deliveryDate: orderInfo.deliveryDate,
-        remark: orderInfo.remark,
-        status: deliveryOrderStatus,
-        reusablePallet: orderInfo.reusablePallet,
-        updater: user
-      })
-
-      return foundDeliveryOrder
-    } catch (e) {
-      throw e
-    }
-  }
-}

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

@@ -1,89 +0,0 @@
-import { User } from '@things-factory/auth-base'
-import { Bizplace } from '@things-factory/biz-base'
-import { generateId } from '@things-factory/id-rule-base'
-import { Setting } from '@things-factory/setting-base'
-import { Domain } from '@things-factory/shell'
-import { TransportVehicle } from '@things-factory/transport-base'
-import { EntityManager, getRepository, Repository } from 'typeorm'
-import { ORDER_NUMBER_RULE_TYPE, ORDER_NUMBER_SETTING_KEY, ORDER_STATUS } from '../../../constants'
-import { DeliveryOrder, OrderInventory, ReleaseGood } from '../../../entities'
-import { OrderNoGenerator } from '../../../utils/order-no-generator'
-
-export const generateDeliveryOrderResolver = {
-  async generateDeliveryOrder(_: any, { orderInfo, customerBizplace, releaseGood, targetInventories }, context: any) {
-    const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
-
-    return await generateDeliveryOrder(orderInfo, customerBizplace, releaseGood, targetInventories, domain, user, tx)
-  }
-}
-
-export async function generateDeliveryOrder(
-  orderInfo: DeliveryOrder,
-  targetInventories: OrderInventory[],
-  customerBizplace: Bizplace,
-  releaseGood: ReleaseGood,
-  domain: Domain,
-  user: User,
-  tx?: EntityManager
-): Promise<DeliveryOrder> {
-  /**
-   * 1. Validation for creating DO - data existing
-   */
-  const deliveryOrderRepo: Repository<DeliveryOrder> = tx?.getRepository(DeliveryOrder) || getRepository(DeliveryOrder)
-  const transportVehicleRepo: Repository<TransportVehicle> =
-    tx?.getRepository(TransportVehicle) || getRepository(TransportVehicle)
-  const orderInventoryRepo: Repository<OrderInventory> =
-    tx?.getRepository(OrderInventory) || getRepository(OrderInventory)
-  const settingRepo: Repository<Setting> = tx?.getRepository(Setting) || getRepository(Setting)
-
-  let transportVehicle: TransportVehicle = null
-  if (orderInfo?.truckNo) {
-    transportVehicle = await transportVehicleRepo.findOne({
-      where: { domain, name: orderInfo.truckNo }
-    })
-  }
-
-  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()
-  }
-
-  let deliveryOrder: any = {
-    domain,
-    name: orderNo,
-    bizplace: customerBizplace,
-    releaseGood,
-    refNo: releaseGood.refNo,
-    ownCollection: orderInfo.ownCollection,
-    truckNo: orderInfo?.truckNo || null,
-    palletQty: orderInfo?.palletQty || null,
-    transportVehicle,
-    status: ORDER_STATUS.READY_TO_DISPATCH,
-    contactPointRefId: orderInfo?.contactPointRefId || null,
-    creator: user,
-    updater: user
-  }
-
-  deliveryOrder = <DeliveryOrder>await deliveryOrderRepo.save(deliveryOrder)
-
-  targetInventories = targetInventories.map((targetInventory: OrderInventory) => {
-    return {
-      ...targetInventory,
-      deliveryOrder,
-      updater: user
-    }
-  })
-  await orderInventoryRepo.save(targetInventories)
-
-  return deliveryOrder
-}

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

@@ -1,41 +0,0 @@
-import { checkDeliveredOrder } from './check-delivered-order'
-import { confirmDeliveryOrder } from './confirm-delivery-order'
-import { deleteDeliveryOrder } from './delete-delivery-order'
-import { deliveryOrderResolver } from './delivery-order'
-import { deliveryOrderByReleaseGoodResolver } from './delivery-order-by-release-good'
-import { deliveryOrderItemsResolver } from './delivery-order-items'
-import { deliveryOrderRequestsResolver } from './delivery-order-requests'
-import { deliveryOrdersResolver } from './delivery-orders'
-import { dispatchDeliveryOrder } from './dispatch-delivery-order'
-import { generateDeliveryOrder, generateDeliveryOrderResolver } from './generate-delivery-order'
-import { receiveDeliveryOrder } from './receive-delivery-order'
-import { rejectDeliveryOrder } from './reject-delivery-order'
-import { updateDeliveryOrder } from './update-delivery-order'
-import { submitGoodsDeliveryNote } from './submit-goods-delivery-note'
-import { createDeliveryOrderResolver } from './create-delivery-order'
-import { manualDeliveryOrderItemsResolver } from './manual-delivery-order-items'
-import { dispatchManualDeliveryOrder } from './dispatch-manual-delivery-order'
-
-export const Query = {
-  ...deliveryOrdersResolver,
-  ...deliveryOrderResolver,
-  ...deliveryOrderRequestsResolver,
-  ...deliveryOrderByReleaseGoodResolver,
-  ...deliveryOrderItemsResolver,
-  ...manualDeliveryOrderItemsResolver
-}
-
-export const Mutation = {
-  ...updateDeliveryOrder,
-  ...generateDeliveryOrderResolver,
-  ...deleteDeliveryOrder,
-  ...generateDeliveryOrder,
-  ...confirmDeliveryOrder,
-  ...receiveDeliveryOrder,
-  ...dispatchDeliveryOrder,
-  ...checkDeliveredOrder,
-  ...rejectDeliveryOrder,
-  ...submitGoodsDeliveryNote,
-  ...createDeliveryOrderResolver,
-  ...dispatchManualDeliveryOrder
-}

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

@@ -1,98 +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 manualDeliveryOrderItemsResolver = {
-  async manualDeliveryOrderItems(_: 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: ['product']
-    })
-
-    items = items
-      .map((oi: OrderInventory) => {
-        const product: Product = oi.product
-        return {
-          inventory: oi.inventory,
-          productId: product.id,
-          productName: `${product.name} (${product.description})`,
-          packingType: oi.packingType,
-          batchId: oi.batchId,
-          releaseQty: oi.releaseQty,
-          releaseUomValue: oi.releaseUomValue,
-          remark: oi.remark,
-          crossDocking: oi.crossDocking,
-          pallet: ''
-        }
-      })
-      .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,
-            productId: item.productId,
-            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/receive-delivery-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 { DeliveryOrder } from '../../../entities'
-
-export const receiveDeliveryOrder = {
-  async receiveDeliveryOrder(_: any, { name }, 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 }
-      })
-
-      if (!deliveryOrder) throw new Error(`Delivery order doesn't exists.`)
-      if (deliveryOrder.status !== ORDER_STATUS.PENDING_RECEIVE) throw new Error(`Status is not receivable.`)
-
-      await tx.getRepository(DeliveryOrder).save({
-        ...deliveryOrder,
-        status: ORDER_STATUS.READY_TO_DISPATCH,
-        updater: user
-      })
-
-      return deliveryOrder
-    } catch (e) {
-      throw e
-    }
-  }
-}

package/server/graphql/resolvers/delivery-order/reject-delivery-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 { DeliveryOrder } from '../../../entities'
-
-export const rejectDeliveryOrder = {
-  async rejectDeliveryOrder(_: 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 }
-      })
-
-      if (!deliveryOrder) throw new Error(`Delivery order doesn't exists.`)
-      if (!patch.remark) throw new Error('Remark is empty.')
-      if (deliveryOrder.status !== ORDER_STATUS.PENDING_RECEIVE) throw new Error(`Status is not receivable.`)
-
-      await tx.getRepository(DeliveryOrder).save({
-        ...deliveryOrder,
-        ...patch,
-        status: ORDER_STATUS.REJECTED,
-        updater: user
-      })
-
-      return deliveryOrder
-    } catch (e) {
-      throw e
-    }
-  }
-}

package/server/graphql/resolvers/delivery-order/submit-goods-delivery-note.ts

@@ -1,43 +0,0 @@
-import { EntityManager } from 'typeorm'
-import { User } from '@things-factory/auth-base'
-import { Domain } from '@things-factory/shell'
-import { DeliveryOrder } from '../../../entities/delivery-order'
-import { ORDER_STATUS } from '../../../constants'
-import { Attachment, createAttachment, deleteAttachment } from '@things-factory/attachment-base'
-
-export const submitGoodsDeliveryNote = {
-  async submitGoodsDeliveryNote(_: any, { name, file }, context: any) {
-    const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
-
-    const foundDO: DeliveryOrder = await tx.getRepository(DeliveryOrder).findOne({
-      where: { domain, name },
-      relations: ['bizplace']
-    })
-
-    if (!foundDO) throw new Error(`DO doesn't exists.`)
-
-    const foundAttachment: Attachment = await tx.getRepository(Attachment).findOne({
-      where: { domain, refBy: foundDO.id }
-    })
-
-    const attachment = {
-      refBy: foundDO.id,
-      file: file,
-      category: 'DO'
-    }
-
-    if (!foundAttachment) {
-      await createAttachment(_, { attachment }, context)
-    } else {
-      const id = foundAttachment.id
-      await deleteAttachment(_, { id }, context)
-      await createAttachment(_, { attachment }, context)
-    }
-
-    return await tx.getRepository(DeliveryOrder).save({
-      ...foundDO,
-      status: ORDER_STATUS.DONE,
-      updater: user
-    })
-  }
-}

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

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

package/server/graphql/resolvers/goods-receival-note/delete-goods-receival-note.ts

@@ -1,11 +0,0 @@
-import { Domain } from '@things-factory/shell'
-import { EntityManager } from 'typeorm'
-import { GoodsReceivalNote } from '../../../entities/goods-receival-note'
-
-export const deleteGoodsReceivalNote = {
-  async deleteGoodsReceivalNote(_: any, { name }, context: any) {
-    const { tx, domain }: { tx: EntityManager; domain: Domain } = context.state
-    await tx.getRepository(GoodsReceivalNote).delete({ domain, name })
-    return true
-  }
-}