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

package/server/graphql/resolvers/arrival-notice/delete-arrival-notice.ts

@@ -1,70 +0,0 @@
-import { User } from '@things-factory/auth-base'
-import { Domain } from '@things-factory/shell'
-import { EntityManager, In } from 'typeorm'
-import { ArrivalNotice, JobSheet, OrderProduct, OrderVas, ReleaseGood } from '../../../entities'
-import { deleteReleaseGood } from '../release-good/delete-release-good'
-
-export const deleteArrivalNoticeResolver = {
-  async deleteArrivalNotice(_: any, { name }, context: any) {
-    const { tx, user, domain }: { tx: EntityManager; user: User; domain: Domain } = context.state
-
-    return await deleteArrivalNotice(tx, name, user, domain)
-  }
-}
-
-export async function deleteArrivalNotice(
-  tx: EntityManager,
-  name: string,
-  user: User,
-  domain: Domain
-): Promise<boolean> {
-  let foundArrivalNotice: ArrivalNotice = await tx.getRepository(ArrivalNotice).findOne({
-    where: { domain, name },
-    relations: ['bizplace', 'releaseGood', 'orderProducts', 'orderVass', 'collectionOrders', 'creator', 'updater']
-  })
-
-  if (!foundArrivalNotice) throw new Error(`Arrival notice doesn't exists.`)
-
-  const foundJS: JobSheet = await tx.getRepository(JobSheet).findOne({
-    where: {
-      bizplace: foundArrivalNotice.bizplace,
-      arrivalNoticeRefNo: foundArrivalNotice.name
-    }
-  })
-
-  if (foundJS) await tx.getRepository(JobSheet).delete({ arrivalNoticeRefNo: foundArrivalNotice.name })
-
-  const foundOPs: OrderProduct[] = foundArrivalNotice.orderProducts
-  const foundOVs: OrderVas[] = foundArrivalNotice.orderVass
-
-  // 1. delete order products
-  const productIds = foundOPs.map((product: OrderProduct) => product.id)
-  if (productIds.length) {
-    await tx.getRepository(OrderProduct).delete({ id: In(productIds) })
-  }
-
-  // 2. delete order vass
-  const vasIds = foundOVs.map((vas: OrderVas) => vas.id)
-  if (vasIds.length) {
-    await tx.getRepository(OrderVas).delete({ id: In(vasIds) })
-  }
-
-  await tx.getRepository(ArrivalNotice).save({
-    ...foundArrivalNotice,
-    updater: user
-  })
-
-  // 4. Remove relation with RO if it's cross docking
-  if (foundArrivalNotice.crossDocking && foundArrivalNotice.releaseGood?.id) {
-    let releaseGood: ReleaseGood = foundArrivalNotice.releaseGood
-    releaseGood.arrivalNotice = null
-    releaseGood = await tx.getRepository(ReleaseGood).save(releaseGood)
-
-    await tx.getRepository(ArrivalNotice).delete({ domain, name })
-    await deleteReleaseGood(tx, releaseGood.name, user, domain)
-  } else {
-    // 5. delete GAN
-    await tx.getRepository(ArrivalNotice).delete({ domain, name })
-  }
-  return true
-}

package/server/graphql/resolvers/arrival-notice/generate-arrival-notice.ts

@@ -1,148 +0,0 @@
-import { Attachment, createAttachments } from '@things-factory/attachment-base'
-import { User } from '@things-factory/auth-base'
-import { Bizplace, getMyBizplace, getOutletBizplace, getPermittedBizplaces } from '@things-factory/biz-base'
-import { generateId } from '@things-factory/id-rule-base'
-import { Product } from '@things-factory/product-base'
-import { Setting } from '@things-factory/setting-base'
-import { Domain } from '@things-factory/shell'
-import { FileUpload } from 'graphql-upload'
-import { EntityManager, getRepository, Repository } from 'typeorm'
-import {
-  ORDER_NUMBER_RULE_TYPE,
-  ORDER_NUMBER_SETTING_KEY,
-  ORDER_PRODUCT_STATUS,
-  ORDER_STATUS,
-  ORDER_TYPES,
-  ORDER_VAS_STATUS
-} from '../../../constants'
-import { ATTACHMENT_TYPE } from '../../../constants/attachment-type'
-import { ArrivalNotice, OrderProduct, OrderVas, Vas } from '../../../entities'
-import { OrderNoGenerator } from '../../../utils/order-no-generator'
-import { generateJobSheet } from '../job-sheet/generate-job-sheet'
-import { addArrivalNoticeProducts } from './add-edit-arrival-notice-products'
-
-export const generateArrivalNotice = {
-  async generateArrivalNotice(_: any, { arrivalNotice, files }, context: any) {
-    const { tx }: { tx: EntityManager } = context.state
-    const createdArrivalNotice: ArrivalNotice = await generateArrivalNoticeFunction(
-      _,
-      arrivalNotice,
-      files,
-      context,
-      tx
-    )
-
-    return createdArrivalNotice
-  }
-}
-
-export async function generateArrivalNoticeFunction(
-  _: any,
-  arrivalNotice: any,
-  files: FileUpload[],
-  context: any,
-  tx?: EntityManager
-): Promise<ArrivalNotice> {
-  const { domain, user }: { domain: Domain; user: User } = context.state
-  let orderProducts: OrderProduct[] = arrivalNotice.orderProducts
-  let orderVass: OrderVas[] = arrivalNotice.orderVass
-  let myBizplace: Bizplace
-  let orderNo: string = ''
-
-  const settingRepo: Repository<Setting> = tx?.getRepository(Setting) || getRepository(Setting)
-
-  if (arrivalNotice.bizplaceId) myBizplace = context.state.bizplace
-  else if (arrivalNotice.customerBizplaceId) {
-    const permittedBizplaces: Bizplace[] = await getPermittedBizplaces(domain, user)
-    let foundPermittedBizplace: Bizplace = permittedBizplaces.find(biz => biz.id == arrivalNotice.customerBizplaceId)
-
-    if (!foundPermittedBizplace) throw new Error(`This user does not permitted for this company`)
-
-    myBizplace = arrivalNotice.customerBizplaceId
-  } else if (arrivalNotice.partnerBizplaceId) {
-    const permittedBizplaces: Bizplace[] = await getPermittedBizplaces(domain, user)
-    let foundPermittedBizplace: Bizplace = permittedBizplaces.find(biz => biz.id == arrivalNotice.partnerBizplaceId)
-
-    if (!foundPermittedBizplace) throw new Error(`This user does not permitted for this company`)
-
-    myBizplace = arrivalNotice.partnerBizplaceId
-  } else if (arrivalNotice.warehouseId) myBizplace = await getOutletBizplace(arrivalNotice.warehouseId)
-  else myBizplace = await getMyBizplace(domain, user)
-
-  // find GAN number rule setting
-  const ganNoSetting: Setting = await settingRepo.findOne({
-    where: {
-      domain,
-      name: ORDER_NUMBER_SETTING_KEY.GAN_NUMBER_RULE
-    }
-  })
-
-  if (ganNoSetting) {
-    orderNo = await generateId({ domain, type: ORDER_NUMBER_RULE_TYPE.GAN_NUMBER, seed: {} })
-  } else {
-    orderNo = OrderNoGenerator.arrivalNotice()
-  }
-
-  // 1. Create arrival notice
-  const createdArrivalNotice: ArrivalNotice = await tx.getRepository(ArrivalNotice).save({
-    ...arrivalNotice,
-    name: orderNo,
-    domain,
-    bizplace: myBizplace,
-    looseItem: arrivalNotice?.looseItem ? arrivalNotice.looseItem : false,
-    status: ORDER_STATUS.PENDING,
-    creator: user,
-    updater: user
-  })
-
-  // 2. Create arrival notice product
-  await addArrivalNoticeProducts(
-    domain,
-    createdArrivalNotice,
-    orderProducts.map((op: OrderProduct) => {
-      return { ...op, status: ORDER_PRODUCT_STATUS.PENDING }
-    }),
-    user,
-    tx
-  )
-
-  await generateJobSheet(domain, user, createdArrivalNotice, tx)
-
-  // 3. Create arrival notice vas
-  if (orderVass?.length) {
-    orderVass = await Promise.all(
-      orderVass.map(async (ov: OrderVas) => {
-        if (ov.targetProduct) {
-          ov.targetProduct = await tx.getRepository(Product).findOne(ov.targetProduct.id)
-        }
-
-        return {
-          ...ov,
-          domain,
-          bizplace: myBizplace,
-          name: OrderNoGenerator.orderVas(),
-          vas: await tx.getRepository(Vas).findOne({ domain, id: ov.vas.id }),
-          type: ORDER_TYPES.ARRIVAL_NOTICE,
-          arrivalNotice: createdArrivalNotice,
-          status: ORDER_VAS_STATUS.PENDING,
-          creator: user,
-          updater: user
-        }
-      })
-    )
-    await tx.getRepository(OrderVas).save(orderVass)
-  }
-
-  if (files?.length) {
-    const attachments: Attachment[] = files.map(attachment => {
-      return {
-        file: attachment,
-        refBy: createdArrivalNotice.id,
-        category: ATTACHMENT_TYPE.GAN
-      }
-    })
-    await createAttachments(_, { attachments }, context)
-  }
-
-  return createdArrivalNotice
-}

package/server/graphql/resolvers/arrival-notice/index.ts

@@ -1,36 +0,0 @@
-import { addEditArrivalNoticeProductsResolver } from './add-edit-arrival-notice-products'
-import { arrivalNoticeResolver } from './arrival-notice'
-import { arrivalNoticeRequestsResolver } from './arrival-notice-requests'
-import { arrivalNoticesResolver } from './arrival-notices'
-import { checkArrivedNoticeFunction, checkArrivedNotice } from './check-arrived-notice'
-import { confirmArrivalNoticeFunction, confirmArrivalNoticeResolver } from './confirm-arrival-notice'
-import { deleteArrivalNoticeResolver } from './delete-arrival-notice'
-import { generateArrivalNoticeFunction, generateArrivalNotice } from './generate-arrival-notice'
-import { receiveArrivalNoticeFunction, receiveArrivalNotice } from './receive-arrival-notice'
-import { rejectArrivalNoticeResolver } from './reject-arrival-notice'
-import { addArrivalNotice } from './add-arrival-notice'
-
-export const Query = {
-  ...arrivalNoticeResolver,
-  ...arrivalNoticeRequestsResolver,
-  ...arrivalNoticesResolver
-}
-
-export const Mutation = {
-  ...addEditArrivalNoticeProductsResolver,
-  ...checkArrivedNotice,
-  ...confirmArrivalNoticeResolver,
-  ...deleteArrivalNoticeResolver,
-  ...generateArrivalNotice,
-  ...receiveArrivalNotice,
-  ...rejectArrivalNoticeResolver,
-  ...addArrivalNotice
-}
-
-export {
-  addArrivalNotice,
-  generateArrivalNoticeFunction,
-  receiveArrivalNoticeFunction,
-  confirmArrivalNoticeFunction,
-  checkArrivedNoticeFunction
-}

package/server/graphql/resolvers/arrival-notice/receive-arrival-notice.ts

@@ -1,97 +0,0 @@
-import { EntityManager } from 'typeorm'
-import { getDomainUsers } from '@things-factory/biz-base'
-import { User } from '@things-factory/auth-base'
-import { Domain } from '@things-factory/shell'
-import { sendNotification } from '@things-factory/notification'
-import { ORDER_PRODUCT_STATUS, ORDER_STATUS, ORDER_VAS_STATUS } from '../../../constants'
-import { ArrivalNotice, CollectionOrder, OrderProduct, OrderVas } from '../../../entities'
-
-export const receiveArrivalNotice = {
-  async receiveArrivalNotice(_: any, { name }, context: any) {
-    const receiveArrivalNotice: ArrivalNotice = await receiveArrivalNoticeFunction(_, name, context)
-
-    return receiveArrivalNotice
-  }
-}
-
-export async function receiveArrivalNoticeFunction(_: any, name: String, context: any): Promise<ArrivalNotice> {
-  const { user, domain, tx }: { user: User; domain: Domain; tx: EntityManager } = context.state
-  try {
-    const foundArrivalNotice: ArrivalNotice = await tx.getRepository(ArrivalNotice).findOne({
-      where: { domain, name, status: ORDER_STATUS.PENDING_RECEIVE },
-      relations: ['bizplace', 'collectionOrders', 'orderProducts', 'orderVass']
-    })
-
-    if (!foundArrivalNotice) throw new Error(`Arrival notice doesn't exists.`)
-
-    let foundOPs: OrderProduct[] = foundArrivalNotice.orderProducts
-    let foundOVs: OrderVas[] = foundArrivalNotice.orderVass
-    let foundCOs: CollectionOrder[] = await tx.getRepository(CollectionOrder).find({
-      where: { domain, refNo: foundArrivalNotice.name }
-    })
-
-    // 1. Update status of order products (PENDING_RECEIVE => INTRANSIT)
-    foundOPs = foundOPs.map((op: OrderProduct) => {
-      return {
-        ...op,
-        status: ORDER_PRODUCT_STATUS.INTRANSIT,
-        updater: user
-      }
-    })
-    await tx.getRepository(OrderProduct).save(foundOPs)
-
-    // 2. Update status of order vass if it exists (PENDING_RECEIVE => INTRANSIT)
-    if (foundOVs && foundOVs.length) {
-      foundOVs = foundOVs.map((ov: OrderVas) => {
-        return {
-          ...ov,
-          status: ORDER_VAS_STATUS.INTRANSIT,
-          updater: user
-        }
-      })
-      await tx.getRepository(OrderVas).save(foundOVs)
-    }
-
-    // 3. If there's collection order, update status of collection order (PENDING_RECEIVE => READY_TO_DISPATCH)
-    if (foundCOs) {
-      foundCOs = foundCOs.map((co: CollectionOrder) => {
-        return {
-          ...co,
-          status: ORDER_STATUS.READY_TO_DISPATCH,
-          updater: user
-        }
-      })
-    }
-
-    // notification logics
-    const users: any[] = await getDomainUsers(foundArrivalNotice?.bizplace, tx)
-
-    // send notification to Customer Users
-    if (users?.length) {
-      const receivers: any[] = users.map(user => user.id)
-      const msg = {
-        title: `Latest status for ${foundArrivalNotice.name}`,
-        body: `Your GAN has been received and processed by ${domain.name}`,
-        url: context.header.referer,
-        data: { url: context.header.referer }
-      }
-      await sendNotification({
-        receivers,
-        message: { ...msg }
-      })
-    }
-
-    // 4. Update status of arrival notice (PENDING_RECEIVE => INTRANSIT)
-    await tx.getRepository(ArrivalNotice).save({
-      ...foundArrivalNotice,
-      status: ORDER_STATUS.INTRANSIT,
-      acceptedBy: user,
-      acceptedAt: new Date(),
-      updater: user
-    })
-
-    return foundArrivalNotice
-  } catch (e) {
-    throw e
-  }
-}

package/server/graphql/resolvers/arrival-notice/reject-arrival-notice.ts

@@ -1,105 +0,0 @@
-import { User } from '@things-factory/auth-base'
-import { getDomainUsers } from '@things-factory/biz-base'
-import { sendNotification } from '@things-factory/notification'
-import { Domain } from '@things-factory/shell'
-import { EntityManager } from 'typeorm'
-import { ORDER_PRODUCT_STATUS, ORDER_STATUS, ORDER_VAS_STATUS } from '../../../constants'
-import { ArrivalNotice, CollectionOrder, OrderProduct, OrderVas, ReleaseGood } from '../../../entities'
-import { rejectReleaseGood } from '../release-good/reject-release-good'
-
-export const rejectArrivalNoticeResolver = {
-  async rejectArrivalNotice(_: any, { name, patch: { remark } }, context: any) {
-    const { tx }: { tx: EntityManager } = context.state
-
-    const arrivalNotice: ArrivalNotice = await rejectArrivalNotice(tx, name, remark, context)
-
-    if (arrivalNotice.crossDocking) {
-      const { releaseGood }: { releaseGood: ReleaseGood } = await tx
-        .getRepository(ArrivalNotice)
-        .findOne(arrivalNotice.id, {
-          relations: ['releaseGood']
-        })
-
-      if (releaseGood.status !== ORDER_STATUS.REJECTED) {
-        await rejectReleaseGood(tx, releaseGood.name, remark, context)
-      }
-    }
-
-    return arrivalNotice
-  }
-}
-
-export async function rejectArrivalNotice(
-  tx: EntityManager,
-  name: string,
-  remark: string,
-  context: any
-): Promise<ArrivalNotice> {
-  const { user, domain }: { user: User; domain: Domain } = context.state
-
-  const foundArrivalNotice: ArrivalNotice = await tx.getRepository(ArrivalNotice).findOne({
-    where: { domain, name, status: ORDER_STATUS.PENDING_RECEIVE },
-    relations: ['bizplace', 'orderProducts', 'orderVass', 'collectionOrders']
-  })
-
-  if (!foundArrivalNotice) throw new Error(`Arrival notice doesn't exists.`)
-  if (!remark) throw new Error('Remark is not exist.')
-
-  let foundOPs: OrderProduct[] = foundArrivalNotice.orderProducts
-  let foundOVs: OrderVas[] = foundArrivalNotice.orderVass
-  let foundCOs: CollectionOrder[] = foundArrivalNotice.collectionOrders
-
-  // 1. Update status of order products (PENDING_RECEIVE => REJECTED)
-  foundOPs = foundOPs.map((op: OrderProduct) => {
-    op.status = ORDER_PRODUCT_STATUS.REJECTED
-    op.updater = user
-    return op
-  })
-  await tx.getRepository(OrderProduct).save(foundOPs)
-
-  // 2. Update status of order vass if it exists (PENDING_RECEIVE => REJECTED)
-  if (foundOVs && foundOVs.length) {
-    foundOVs = foundOVs.map((ov: OrderVas) => {
-      ov.status = ORDER_VAS_STATUS.REJECTED
-      ov.updater = user
-      return ov
-    })
-    await tx.getRepository(OrderVas).save(foundOVs)
-  }
-
-  // 3. If there's collection order, update status of collection order (PENDING_RECEIVE => REJECTED)
-  if (foundCOs) {
-    foundCOs = foundCOs.map((co: CollectionOrder) => {
-      co.status = ORDER_STATUS.REJECTED
-      co.updater = user
-      return co
-    })
-    await tx.getRepository(CollectionOrder).save(foundCOs)
-  }
-
-  foundArrivalNotice.remark = remark
-  foundArrivalNotice.status = ORDER_STATUS.REJECTED
-  foundArrivalNotice.updater = user
-  await tx.getRepository(ArrivalNotice).save(foundArrivalNotice)
-
-  // notification logics
-  const users: any[] = await getDomainUsers(foundArrivalNotice?.bizplace, tx)
-
-  // send notification to Customer Users
-  if (users?.length) {
-    const receivers: any[] = users.map(user => user.id)
-    const msg = {
-      title: `Latest status for ${foundArrivalNotice.name}`,
-      body: `Your GAN has been rejected.`,
-      url: context.header.referer,
-      data: { url: context.header.referer }
-    }
-
-    await sendNotification({
-      receivers,
-      message: { ...msg }
-    })
-  }
-
-  return foundArrivalNotice
-}

package/server/graphql/resolvers/claim/claim-order-detail.ts

@@ -1,34 +0,0 @@
-import { Claim, DeliveryOrder, CollectionOrder } from '../../../entities'
-import { Equal, getRepository, In, IsNull, Not } from 'typeorm'
-
-export const claimOrderDetailResolver = {
-  async claimOrderDetail(_: any, params: any, context: any) {
-    let claim = new Claim()
-    // let deliveryOrder = await getRepository(DeliveryOrder).findOne({
-    //   where: {
-    //     domain: context.state.domain,
-    //     name: params.filters[0].value
-    //   },
-    //   relations: ['domain', 'bizplace', 'transportDriver', 'transportVehicle', 'creator', 'updater']
-    // })
-
-    // let collectionOrder = await getRepository(CollectionOrder).findOne({
-    //   where: {
-    //     domain: context.state.domain,
-    //     name: params.filters[0].value
-    //   },
-    //   relations: ['domain', 'bizplace', 'transportDriver', 'transportVehicle', 'creator', 'updater']
-    // })
-    // var x = await getRepository(Claim).findOne({
-    //   where: {
-    //     domain: context.state.domain,
-    //     deliveryOrder: 'DO-201992495155390'
-    //   },
-    //   relations: ['deliveryOrder']
-    // })
-
-    // claim.deliveryOrder = deliveryOrder
-    // claim.collectionOrder = collectionOrder
-    return claim
-  }
-}

package/server/graphql/resolvers/claim/claim-order-list.ts

@@ -1,27 +0,0 @@
-import { Claim } from '../../../entities'
-import { Equal, getRepository, In, IsNull } from 'typeorm'
-
-export const claimOrderListResolver = {
-  async claimOrderList(_: any, { transportDriver, transportVehicle }, context: any) {
-    let domainId = context.state.domain.id
-    let arrOrders = []
-    if (transportDriver && transportVehicle && transportDriver !== '' && transportVehicle !== '') {
-      arrOrders = await getRepository(Claim).query(`
-        select delOrd.id, delOrd.name AS name from transport_order_details transportOrd
-          inner join delivery_orders delOrd on delOrd.id = transportord.delivery_order_id and delOrd.domain_id = transportOrd.domain_id
-          where delOrd.name NOT IN (SELECT name FROM claim_orders) AND 
-          truck_no IS NULL AND delOrd.domain_id = '${domainId}' AND
-          transport_driver_id = '${transportDriver}' and transport_vehicle_id = '${transportVehicle}'
-          AND status = 'DONE'
-        UNION
-        select colOrd.id, colOrd.name AS name from transport_order_details transportOrd
-          inner join collection_orders colOrd on colOrd.id = transportord.collection_order_id and colOrd.domain_id = transportOrd.domain_id
-          where colOrd.name NOT IN (SELECT name FROM claim_orders) AND 
-          truck_no IS NULL AND colOrd.domain_id = '${domainId}' AND
-          transport_driver_id = '${transportDriver}' and transport_vehicle_id = '${transportVehicle}'  
-          AND status = 'DONE'
-      `)
-    }
-    return arrOrders
-  }
-}

package/server/graphql/resolvers/claim/claim.ts

@@ -1,25 +0,0 @@
-import { getRepository } from 'typeorm'
-import { Claim } from '../../../entities'
-
-export const claimResolver = {
-  async claim(_: any, { id }, context: any) {
-    var data = await getRepository(Claim).findOne({
-      where: {
-        domain: context.state.domain,
-        id
-      },
-      relations: [
-        'domain',
-        'claimDetails',
-        'claimOrders',
-        'transportDriver',
-        'transportVehicle',
-        'bizplace',
-        'creator',
-        'updater'
-      ]
-    })
-
-    return data
-  }
-}

package/server/graphql/resolvers/claim/claims.ts

@@ -1,15 +0,0 @@
-import { ListParam, convertListParams } from '@things-factory/shell'
-import { getRepository } from 'typeorm'
-import { Claim } from '../../../entities'
-
-export const claimsResolver = {
-  async claims(_: any, params: ListParam, context: any) {
-    const convertedParams = convertListParams(params)
-    let [items, total] = await getRepository(Claim).findAndCount({
-      ...convertedParams,
-      relations: ['domain', 'creator', 'updater', 'bizplace', 'transportVehicle', 'transportDriver', 'claimDetails']
-    })
-
-    return { items, total }
-  }
-}

package/server/graphql/resolvers/claim/create-claim.ts

@@ -1,125 +0,0 @@
-import { EntityManager, getRepository, In, MoreThan } from 'typeorm'
-import { Claim, ClaimDetail, ClaimOrder, DeliveryOrder, CollectionOrder } from '../../../entities'
-import { TransportDriver, TransportVehicle } from '@things-factory/transport-base'
-import { Bizplace } from '@things-factory/biz-base'
-
-export const createClaim = {
-  async createClaim(_: any, { claim }, context: any) {
-    const { tx }: { tx: EntityManager } = context.state
-
-    let arrClaimOrdersName = claim.claimOrders.map(item => {
-      return item.name
-    })
-
-    let newClaimOrders = []
-    let deliveryOrder = await getRepository(DeliveryOrder).find({
-      where: { name: In(arrClaimOrdersName), domain: context.state.domain }
-    })
-
-    let collectionOrder = await getRepository(CollectionOrder).find({
-      where: { name: In(arrClaimOrdersName), domain: context.state.domain }
-    })
-
-    deliveryOrder.map(order => {
-      newClaimOrders.push({
-        name: order.name,
-        deliveryOrder: order
-      })
-    })
-
-    collectionOrder.map(order => {
-      newClaimOrders.push({
-        name: order.name,
-        collectionOrder: order
-      })
-    })
-
-    let bizplace = await getRepository(Bizplace).findOne({
-      where: {
-        domain: context.state.domain,
-        id: claim.bizplace
-      }
-    })
-
-    let transportDriver = await getRepository(TransportDriver).findOne({
-      where: {
-        domain: context.state.domain,
-        id: claim.transportDriver
-      }
-    })
-
-    let transportVehicle = await getRepository(TransportVehicle).findOne({
-      where: {
-        domain: context.state.domain,
-        id: claim.transportVehicle
-      }
-    })
-
-    // if (newClaimOrders.length > 0) {
-    //   await getRepository(ClaimOrder).findAndCount({
-    //     where: { deliveryOrder: In(), domain: context.state.domain }
-    //   })
-    //   throw new Error('Data Error')
-    // }
-
-    let today = new Date()
-    let year = today.getFullYear()
-    let month = today.getMonth()
-    let date = today.getDate()
-
-    const [items, total] = await getRepository(Claim).findAndCount({
-      createdAt: MoreThan(new Date(year, month, date))
-    })
-
-    let claimName =
-      'CLAIM' +
-      year.toString().substr(year.toString().length - 2) +
-      ('0' + month.toString()).substr(('0' + (month + 1).toString()).toString().length - 2) +
-      ('0' + date.toString()).substr(('0' + date.toString()).length - 2) +
-      '/' +
-      ('0000' + (total + 1).toString()).substr(('0000' + (total + 1).toString()).length - 4)
-
-    // //Save All Data//
-    const createdClaim: Claim = await tx.getRepository(Claim).save({
-      ...claim,
-      name: claimName,
-      bizplace: bizplace,
-      transportDriver: transportDriver,
-      transportVehicle: transportVehicle,
-      status: 'PENDING',
-      domain: context.state.domain,
-      creator: context.state.user,
-      updater: context.state.user
-    })
-
-    const claimOrders = await Promise.all(
-      newClaimOrders.map(async (ClaimOrder: ClaimOrder) => {
-        return {
-          ...ClaimOrder,
-          claim: createdClaim,
-          domain: context.state.domain,
-          creator: context.state.user,
-          updater: context.state.user
-        }
-      })
-    )
-
-    const claimDetails = await Promise.all(
-      claim.claimDetails.map(async (ClaimDetail: ClaimDetail) => {
-        return {
-          ...ClaimDetail,
-          claim: createdClaim,
-          domain: context.state.domain,
-          creator: context.state.user,
-          updater: context.state.user
-        }
-      })
-    )
-
-    await tx.getRepository(ClaimOrder).save(claimOrders)
-    await tx.getRepository(ClaimDetail).save(claimDetails)
-    //Save All Data//
-
-    return claim
-  }
-}