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

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

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

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

@@ -1,58 +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 { EntityManager, getRepository, Repository } from 'typeorm'
-import { GRN_STATUS, ORDER_NUMBER_RULE_TYPE, ORDER_NUMBER_SETTING_KEY } from '../../../constants'
-import { ArrivalNotice } from '../../../entities/arrival-notice'
-import { GoodsReceivalNote } from '../../../entities/goods-receival-note'
-import { OrderNoGenerator } from '../../../utils/order-no-generator'
-
-export const generateGoodsReceivalNoteResolver = {
-  async generateGoodsReceivalNote(_: any, { grn }, context: any) {
-    const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
-    return await generateGoodsReceivalNote(grn, domain, user, tx)
-  }
-}
-
-export async function generateGoodsReceivalNote(
-  grn: { refNo: string; customer: string },
-  domain: Domain,
-  user: User,
-  tx?: EntityManager
-): Promise<GoodsReceivalNote> {
-  // 1. Create grn
-  const grnRepo: Repository<GoodsReceivalNote> =
-    tx?.getRepository(GoodsReceivalNote) || getRepository(GoodsReceivalNote)
-  const bizplaceRepo: Repository<Bizplace> = tx?.getRepository(Bizplace) || getRepository(Bizplace)
-  const ganRepo: Repository<ArrivalNotice> = tx?.getRepository(ArrivalNotice) || getRepository(ArrivalNotice)
-  const settingRepo: Repository<Setting> = tx?.getRepository(Setting) || getRepository(Setting)
-  let orderNo: string = ''
-
-  const bizplace: Bizplace = await bizplaceRepo.findOne({ where: { id: grn.customer } })
-  const arrivalNotice: ArrivalNotice = await ganRepo.findOne({ where: { domain, name: grn.refNo } })
-  const grnNoSetting: Setting = await settingRepo.findOne({
-    where: {
-      domain,
-      name: ORDER_NUMBER_SETTING_KEY.GRN_NUMBER_RULE
-    }
-  })
-
-  if (grnNoSetting) {
-    orderNo = await generateId({ domain, type: ORDER_NUMBER_RULE_TYPE.GRN_NUMBER, seed: {} })
-  } else {
-    orderNo = OrderNoGenerator.goodsReceiveNote()
-  }
-
-  return await grnRepo.save({
-    ...grn,
-    name: orderNo,
-    domain,
-    bizplace,
-    arrivalNotice,
-    status: GRN_STATUS.PENDING_RECEIVE,
-    creator: user,
-    updater: user
-  })
-}

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

@@ -1,16 +0,0 @@
-import { Domain } from '@things-factory/shell'
-import { getRepository } from 'typeorm'
-import { GoodsReceivalNote } from '../../../entities/goods-receival-note'
-
-export const goodsReceivalNoteResolver = {
-  async goodsReceivalNote(_: any, { name }, context: any) {
-    const { domain }: { domain: Domain } = context.state
-    return await getRepository(GoodsReceivalNote).findOne({
-      where: {
-        domain,
-        name
-      },
-      relations: ['domain', 'bizplace', 'bizplace.company', 'arrivalNotice', 'creator', 'updater']
-    })
-  }
-}

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

@@ -1,66 +0,0 @@
-import { User } from '@things-factory/auth-base'
-import { Bizplace, getPermittedBizplaceIds } from '@things-factory/biz-base'
-import { convertListParams, Domain, ListParam } from '@things-factory/shell'
-import { getRepository, In, IsNull } from 'typeorm'
-import { ArrivalNotice } from '../../../entities/arrival-notice'
-import { GoodsReceivalNote } from '../../../entities/goods-receival-note'
-
-export const goodsReceivalNotesResolver = {
-  async goodsReceivalNotes(_: any, params: ListParam, context: any) {
-    const { domain, user }: { domain: Domain; user: User } = context.state
-
-    const convertedParams = convertListParams(params)
-
-    const arrivalNoticeParam: any = params.filters.find((param: any) => param.name === 'arrivalNoticeNo')
-    const arrivalNoticeRefNoParam = params.filters.find(param => param.name === 'arrivalNoticeRefNo')
-
-    const bizplaceParam = params.filters.find(param => param.name === 'bizplaceName')
-    if (bizplaceParam) {
-      const foundBizplaces: Bizplace[] = await getRepository(Bizplace).find({
-        where: {
-          ...convertListParams({ filters: [{ ...bizplaceParam, name: 'name' }] }).where
-        }
-      })
-
-      // remove non-column params
-      delete convertedParams.where.bizplaceName
-
-      if (foundBizplaces && foundBizplaces.length) {
-        convertedParams.where.bizplace = In(foundBizplaces.map((foundBizplace: Bizplace) => foundBizplace.id))
-      } else {
-        convertedParams.where.bizplace = IsNull()
-      }
-    } else {
-      convertedParams.where.bizplace = In(await getPermittedBizplaceIds(domain, user))
-      convertedParams.where.domain = domain
-    }
-
-    if (arrivalNoticeParam || arrivalNoticeRefNoParam) {
-      let arrFilters = []
-      if (arrivalNoticeParam) {
-        arrFilters.push({ ...arrivalNoticeParam, name: 'name' })
-      }
-      if (arrivalNoticeRefNoParam) arrFilters.push({ ...arrivalNoticeRefNoParam, name: 'refNo' })
-      const foundArrivalNotices: ArrivalNotice[] = await getRepository(ArrivalNotice).find({
-        ...convertListParams({ filters: arrFilters })
-      })
-
-      // remove non-column params
-      delete convertedParams.where.arrivalNoticeNo
-      delete convertedParams.where.arrivalNoticeRefNo
-
-      if (foundArrivalNotices && foundArrivalNotices.length) {
-        convertedParams.where.arrivalNotice = In(foundArrivalNotices.map((foundAN: ArrivalNotice) => foundAN.id))
-      } else {
-        convertListParams.where.arrivalNotice = IsNull()
-      }
-    }
-
-    let [items, total] = await getRepository(GoodsReceivalNote).findAndCount({
-      ...convertedParams,
-      relations: ['domain', 'arrivalNotice', 'bizplace', 'creator', 'updater']
-    })
-
-    return { items, total }
-  }
-}

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

@@ -1,21 +0,0 @@
-import { goodsReceivalNoteResolver } from './goods-receival-note'
-import { goodsReceivalNotesResolver } from './goods-receival-notes'
-
-import { deleteGoodsReceivalNote } from './delete-goods-receival-note'
-import { deleteGoodsReceivalNotes } from './delete-goods-receival-notes'
-import { generateGoodsReceivalNoteResolver } from './generate-goods-receival-note'
-import { receivedGoodsReceivalNote } from './received-goods-receival-note'
-import { sendGoodsReceivalNote } from './send-goods-receival-note'
-
-export const Query = {
-  ...goodsReceivalNotesResolver,
-  ...goodsReceivalNoteResolver
-}
-
-export const Mutation = {
-  ...deleteGoodsReceivalNote,
-  ...deleteGoodsReceivalNotes,
-  ...generateGoodsReceivalNoteResolver,
-  ...receivedGoodsReceivalNote,
-  ...sendGoodsReceivalNote
-}

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

@@ -1,22 +0,0 @@
-import { User } from '@things-factory/auth-base'
-import { Domain } from '@things-factory/shell'
-import { EntityManager } from 'typeorm'
-import { GRN_STATUS } from '../../../constants'
-import { GoodsReceivalNote } from '../../../entities/goods-receival-note'
-
-export const receivedGoodsReceivalNote = {
-  async receivedGoodsReceivalNote(_: any, { name }, context: any) {
-    const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
-
-    const goodsReceivalNote = await tx.getRepository(GoodsReceivalNote).findOne({
-      where: { domain, name }
-    })
-
-    return await tx.getRepository(GoodsReceivalNote).save({
-      ...goodsReceivalNote,
-      status: GRN_STATUS.RECEIVED,
-      customerStatus: GRN_STATUS.RECEIVED,
-      updater: user
-    })
-  }
-}

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

@@ -1,22 +0,0 @@
-import { User } from '@things-factory/auth-base'
-import { Domain } from '@things-factory/shell'
-import { EntityManager } from 'typeorm'
-import { GRN_STATUS } from '../../../constants'
-import { GoodsReceivalNote } from '../../../entities/goods-receival-note'
-
-export const sendGoodsReceivalNote = {
-  async sendGoodsReceivalNote(_: any, { name }, context: any) {
-    const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
-
-    const goodsReceivalNote = await tx.getRepository(GoodsReceivalNote).findOne({
-      where: { domain, name }
-    })
-
-    return await tx.getRepository(GoodsReceivalNote).save({
-      ...goodsReceivalNote,
-      status: GRN_STATUS.SENT,
-      customerStatus: GRN_STATUS.PENDING_RECEIVE,
-      updater: user
-    })
-  }
-}

package/server/graphql/resolvers/index.ts

@@ -1,75 +0,0 @@
-import * as ArrivalNotice from './arrival-notice'
-import * as CollectionOrder from './collection-order'
-import * as DeliveryOrder from './delivery-order'
-import * as Invoice from './invoice'
-import * as InventoryCheck from './inventory-check'
-import * as JobSheet from './job-sheet'
-import * as OrderProduct from './order-product'
-import * as OrderInventory from './order-inventory'
-import * as OrderVas from './order-vas'
-import * as PurchaseOrder from './purchase-order'
-import * as PurchaseOrderOtherCharge from './purchase-order-other-charge'
-import * as ShippingOrder from './shipping-order'
-import * as ReleaseGood from './release-good'
-import * as ReturnOrder from './return-order'
-import * as RetailReplenishmentOrder from './retail-replenishment-order'
-import * as TransferOrder from './transfer-order'
-import * as Vas from './vas'
-import * as Claim from './claim'
-import * as ClaimDetail from './claim-detail'
-import * as ClaimOrder from './claim-order'
-import * as VasOrder from './vas-order'
-import * as GoodsReceivalNote from './goods-receival-note'
-import * as Others from './others'
-
-export const queries = [
-  Invoice.Query,
-  InventoryCheck.Query,
-  JobSheet.Query,
-  PurchaseOrder.Query,
-  PurchaseOrderOtherCharge.Query,
-  DeliveryOrder.Query,
-  ShippingOrder.Query,
-  CollectionOrder.Query,
-  Vas.Query,
-  ArrivalNotice.Query,
-  OrderProduct.Query,
-  OrderInventory.Query,
-  OrderVas.Query,
-  ReleaseGood.Query,
-  ReturnOrder.Query,
-  RetailReplenishmentOrder.Query,
-  TransferOrder.Query,
-  Claim.Query,
-  ClaimDetail.Query,
-  ClaimOrder.Query,
-  VasOrder.Query,
-  GoodsReceivalNote.Query,
-  Others.Query
-]
-
-export const mutations = [
-  Invoice.Mutation,
-  JobSheet.Mutation,
-  InventoryCheck.Mutation,
-  PurchaseOrder.Mutation,
-  PurchaseOrderOtherCharge.Mutation,
-  DeliveryOrder.Mutation,
-  ShippingOrder.Mutation,
-  CollectionOrder.Mutation,
-  Vas.Mutation,
-  ArrivalNotice.Mutation,
-  OrderProduct.Mutation,
-  OrderInventory.Mutation,
-  OrderVas.Mutation,
-  ReleaseGood.Mutation,
-  ReturnOrder.Mutation,
-  RetailReplenishmentOrder.Mutation,
-  TransferOrder.Mutation,
-  Claim.Mutation,
-  ClaimDetail.Mutation,
-  ClaimOrder.Mutation,
-  VasOrder.Mutation,
-  GoodsReceivalNote.Mutation,
-  Others.Mutation
-]

package/server/graphql/resolvers/inventory-check/create-inventory-check.ts

@@ -1,14 +0,0 @@
-import { EntityManager } from 'typeorm'
-import { InventoryCheck } from '../../../entities'
-
-export const createInventoryCheck = {
-  async createInventoryCheck(_: any, { inventoryCheck }, context: any) {
-    const { tx }: { tx: EntityManager } = context.state
-    return await tx.getRepository(InventoryCheck).save({
-      ...inventoryCheck,
-      domain: context.state.domain,
-      creator: context.state.user,
-      updater: context.state.user
-    })
-  }
-}

package/server/graphql/resolvers/inventory-check/delete-inventory-check.ts

@@ -1,10 +0,0 @@
-import { EntityManager } from 'typeorm'
-import { InventoryCheck } from '../../../entities'
-
-export const deleteInventoryCheck = {
-  async deleteInventoryCheck(_: any, { name }, context: any) {
-    const { tx }: { tx: EntityManager } = context.state
-    await tx.getRepository(InventoryCheck).delete({ domain: context.state.domain, name })
-    return true
-  }
-}

package/server/graphql/resolvers/inventory-check/delete-inventory-checks.ts

@@ -1,13 +0,0 @@
-import { EntityManager, In } from 'typeorm'
-import { InventoryCheck } from '../../../entities'
-
-export const deleteInventoryChecks = {
-  async deleteInventoryChecks(_: any, { names }, context: any) {
-    const { tx }: { tx: EntityManager } = context.state
-    await tx.getRepository(InventoryCheck).delete({
-      domain: context.state.domain,
-      name: In(names)
-    })
-    return true
-  }
-}

package/server/graphql/resolvers/inventory-check/generate-cycle-count.ts

@@ -1,34 +0,0 @@
-import { User } from '@things-factory/auth-base'
-import { Bizplace } from '@things-factory/biz-base'
-import { Domain } from '@things-factory/shell'
-import { EntityManager } from 'typeorm'
-import { ORDER_STATUS, ORDER_TYPES } from '../../../constants'
-import { InventoryCheck } from '../../../entities'
-import { OrderNoGenerator } from '../../../utils'
-
-export const generateCycleCountResolver = {
-  async generateCycleCount(_: any, { executionDate, customerId }, context: any) {
-    const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
-    return await generateCycleCount(tx, domain, user, executionDate, customerId)
-  }
-}
-
-export async function generateCycleCount(
-  tx: EntityManager,
-  domain: Domain,
-  user: User,
-  executionDate: string,
-  customerId: string
-): Promise<InventoryCheck> {
-  const customerBizplace: Bizplace = await tx.getRepository(Bizplace).findOne(customerId)
-
-  return tx.getRepository(InventoryCheck).save({
-    name: OrderNoGenerator.cycleCount(),
-    executionDate,
-    type: ORDER_TYPES.CYCLE_COUNT,
-    status: ORDER_STATUS.PENDING,
-    bizplace: customerBizplace,
-    domain,
-    updater: user
-  })
-}

package/server/graphql/resolvers/inventory-check/index.ts

@@ -1,23 +0,0 @@
-import { inventoryCheckResolver } from './inventory-check'
-import { inventoryChecksResolver } from './inventory-checks'
-
-import { updateInventoryCheck } from './update-inventory-check'
-import { updateMultipleInventoryCheck } from './update-multiple-inventory-check'
-import { generateCycleCountResolver } from './generate-cycle-count'
-import { createInventoryCheck } from './create-inventory-check'
-import { deleteInventoryCheck } from './delete-inventory-check'
-import { deleteInventoryChecks } from './delete-inventory-checks'
-
-export const Query = {
-  ...inventoryChecksResolver,
-  ...inventoryCheckResolver
-}
-
-export const Mutation = {
-  ...updateInventoryCheck,
-  ...updateMultipleInventoryCheck,
-  ...generateCycleCountResolver,
-  ...createInventoryCheck,
-  ...deleteInventoryCheck,
-  ...deleteInventoryChecks
-}

package/server/graphql/resolvers/inventory-check/inventory-check.ts

@@ -1,14 +0,0 @@
-import { getRepository } from 'typeorm'
-import { InventoryCheck } from '../../../entities'
-
-export const inventoryCheckResolver = {
-  async inventoryCheck(_: any, { name }, context: any) {
-    const repository = getRepository(InventoryCheck)
-
-    return await getRepository(InventoryCheck).findOne({
-      where: { domain: context.state.domain, name }, 
-      relations: ['domain', 'creator', 'updater']
-    })
-  }
-}
-

package/server/graphql/resolvers/inventory-check/inventory-checks.ts

@@ -1,14 +0,0 @@
-import { ListParam, convertListParams } from '@things-factory/shell'
-import { getRepository } from 'typeorm'
-import { InventoryCheck } from '../../../entities'
-
-export const inventoryChecksResolver = {
-  async inventoryChecks(_: any, params: ListParam, context: any) {
-    const convertedParams = convertListParams(params)
-    const [items, total] = await getRepository(InventoryCheck).findAndCount({
-      ...convertedParams,
-      relations: ['domain', 'creator', 'updater']
-    })
-    return { items, total }
-  }
-}

package/server/graphql/resolvers/inventory-check/update-inventory-check.ts

@@ -1,19 +0,0 @@
-import { EntityManager } from 'typeorm'
-import { InventoryCheck } from '../../../entities'
-
-export const updateInventoryCheck = {
-  async updateInventoryCheck(_: any, { name, patch }, context: any) {
-    const { tx }: { tx: EntityManager } = context.state
-
-    const repository = tx.getRepository(InventoryCheck)
-    const inventoryCheck = await repository.findOne({
-      where: { domain: context.state.domain, name }
-    })
-
-    return await repository.save({
-      ...inventoryCheck,
-      ...patch,
-      updater: context.state.user
-    })
-  }
-}

package/server/graphql/resolvers/inventory-check/update-multiple-inventory-check.ts

@@ -1,45 +0,0 @@
-import { EntityManager } from 'typeorm'
-import { InventoryCheck } from '../../../entities'
-
-export const updateMultipleInventoryCheck = {
-  async updateMultipleInventoryCheck(_: any, { patches }, context: any) {
-    const { tx }: { tx: EntityManager } = context.state
-
-    let results = []
-    const _createRecords = patches.filter((patch: any) => patch.cuFlag.toUpperCase() === '+')
-    const _updateRecords = patches.filter((patch: any) => patch.cuFlag.toUpperCase() === 'M')
-    const inventoryCheckRepo = tx.getRepository(InventoryCheck)
-
-    if (_createRecords.length > 0) {
-      for (let i = 0; i < _createRecords.length; i++) {
-        const newRecord = _createRecords[i]
-
-        const result = await inventoryCheckRepo.save({
-          ...newRecord,
-          domain: context.state.domain,
-          creator: context.state.user,
-          updater: context.state.user
-        })
-
-        results.push({ ...result, cuFlag: '+' })
-      }
-    }
-
-    if (_updateRecords.length > 0) {
-      for (let i = 0; i < _updateRecords.length; i++) {
-        const newRecord = _updateRecords[i]
-        const inventoryCheck = await inventoryCheckRepo.findOne(newRecord.id)
-
-        const result = await inventoryCheckRepo.save({
-          ...inventoryCheck,
-          ...newRecord,
-          updater: context.state.user
-        })
-
-        results.push({ ...result, cuFlag: 'M' })
-      }
-    }
-
-    return results
-  }
-}

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

@@ -1,17 +0,0 @@
-import { User } from '@things-factory/auth-base'
-import { Domain } from '@things-factory/shell'
-import { EntityManager } from 'typeorm'
-import { Invoice } from '../../../entities'
-
-export const createInvoice = {
-  async createInvoice(_: any, { invoice }, context: any) {
-    const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
-
-    return await tx.getRepository(Invoice).save({
-      domain,
-      ...invoice,
-      creator: user,
-      updater: user
-    })
-  }
-}

package/server/graphql/resolvers/invoice/delete-invoice.ts

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

package/server/graphql/resolvers/invoice/index.ts

@@ -1,16 +0,0 @@
-import { createInvoice } from './create-invoice'
-import { deleteInvoice } from './delete-invoice'
-import { invoiceResolver } from './invoice'
-import { invoicesResolver } from './invoices'
-import { updateInvoice } from './update-invoice'
-
-export const Query = {
-  ...invoicesResolver,
-  ...invoiceResolver
-}
-
-export const Mutation = {
-  ...updateInvoice,
-  ...createInvoice,
-  ...deleteInvoice
-}

package/server/graphql/resolvers/invoice/invoice.ts

@@ -1,14 +0,0 @@
-import { Domain } from '@things-factory/shell'
-import { getRepository } from 'typeorm'
-import { Invoice } from '../../../entities'
-
-export const invoiceResolver = {
-  async invoice(_: any, { name }, context: any) {
-    const { domain }: { domain: Domain } = context.state
-
-    return await getRepository(Invoice).findOne({
-      where: { domain, name },
-      relations: ['domain', 'customer', 'purchaseOrder', 'creator', 'updater']
-    })
-  }
-}

package/server/graphql/resolvers/invoice/invoices.ts

@@ -1,19 +0,0 @@
-import { buildQuery, ListParam } from '@things-factory/shell'
-import { getRepository } from 'typeorm'
-import { Invoice } from '../../../entities'
-
-export const invoicesResolver = {
-  async invoices(_: any, params: ListParam, context: any) {
-    const queryBuilder = getRepository(Invoice).createQueryBuilder()
-    buildQuery(queryBuilder, params, context)
-    const [items, total] = await queryBuilder
-      .leftJoinAndSelect('Invoice.domain', 'Domain')
-      .leftJoinAndSelect('Invoice.customer', 'Bizplace')
-      .leftJoinAndSelect('Invoice.purchaseOrder', 'PurchaseOrder')
-      .leftJoinAndSelect('Invoice.creator', 'Creator')
-      .leftJoinAndSelect('Invoice.updater', 'Updater')
-      .getManyAndCount()
-
-    return { items, total }
-  }
-}

package/server/graphql/resolvers/invoice/update-invoice.ts

@@ -1,21 +0,0 @@
-import { User } from '@things-factory/auth-base'
-import { Domain } from '@things-factory/shell'
-import { EntityManager } from 'typeorm'
-import { Invoice } from '../../../entities'
-
-export const updateInvoice = {
-  async updateInvoice(_: any, { name, patch }, context: any) {
-    const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
-
-    const repository = tx.getRepository(Invoice)
-    const invoice = await repository.findOne({
-      where: { domain, name }
-    })
-
-    return await repository.save({
-      ...invoice,
-      ...patch,
-      updater: user
-    })
-  }
-}

package/server/graphql/resolvers/job-sheet/generate-job-sheet.ts

@@ -1,49 +0,0 @@
-import { User } from '@things-factory/auth-base'
-import { Domain } from '@things-factory/shell'
-import { EntityManager, getRepository, Repository } from 'typeorm'
-import { ArrivalNotice, JobSheet } from '../../../entities'
-import { OrderNoGenerator } from '../../../utils/order-no-generator'
-
-export const generateJobSheetResolver = {
-  async generateJobSheet(_: any, { arrivalNotice }, context: any) {
-    const { domain, user, tx }: { domain: Domain; user: User; tx: EntityManager } = context.state
-    return await generateJobSheet(domain, user, arrivalNotice, tx)
-  }
-}
-
-export async function generateJobSheet(
-  domain: Domain,
-  user: User,
-  arrivalNotice: ArrivalNotice,
-  tx?: EntityManager
-): Promise<JobSheet> {
-  const jobSheetRepo: Repository<JobSheet> = tx?.getRepository(JobSheet) || getRepository(JobSheet)
-
-  let foundJS: JobSheet = null
-  if (arrivalNotice?.refNo) {
-    foundJS = await jobSheetRepo.findOne({
-      where: { domain, name: arrivalNotice.refNo, bizplace: arrivalNotice.bizplace }
-    })
-  }
-
-  let jobName: any = null
-  if (foundJS) {
-    jobName = OrderNoGenerator.jobSheet(domain.name)
-  } else {
-    jobName = arrivalNotice?.refNo
-  }
-
-  // 1. Create job sheet
-  const createdJobSheet: JobSheet = await jobSheetRepo.save({
-    name: jobName ? jobName : OrderNoGenerator.jobSheet(domain.name),
-    domain,
-    bizplace: arrivalNotice.bizplace,
-    containerSize: arrivalNotice?.containerSize ? arrivalNotice.containerSize : null,
-    containerNo: arrivalNotice?.containerNo ? arrivalNotice.containerNo : null,
-    arrivalNoticeRefNo: arrivalNotice.name,
-    creator: user,
-    updater: user
-  })
-
-  return createdJobSheet
-}