@things-factory/sales-base 4.0.0-alpha.6 → 4.0.0-beta.0

package/server/entities/vas.ts

@@ -1,63 +0,0 @@
-import { User } from '@things-factory/auth-base'
-import { Domain } from '@things-factory/shell'
-import { Column, CreateDateColumn, Entity, Index, ManyToOne, PrimaryGeneratedColumn, UpdateDateColumn } from 'typeorm'
-
-@Entity('vass')
-@Index('ix_vas_0', (vas: Vas) => [vas.domain, vas.name], { unique: true })
-export class Vas {
-  @PrimaryGeneratedColumn('uuid')
-  id: string
-
-  @ManyToOne(type => Domain)
-  domain: Domain
-
-  @Column()
-  name: string
-
-  @Column({
-    nullable: true
-  })
-  description: string
-
-  @Column()
-  currency: string
-
-  @Column({
-    nullable: true
-  })
-  uom: string
-
-  @Column({
-    nullable: true
-  })
-  type: string
-
-  @Column('float')
-  defaultPrice: number
-
-  @Column({
-    nullable: true
-  })
-  operationGuideType: string
-
-  @Column({
-    nullable: true
-  })
-  operationGuide: string
-
-  @CreateDateColumn()
-  createdAt: Date
-
-  @UpdateDateColumn()
-  updatedAt: Date
-
-  @ManyToOne(type => User, {
-    nullable: true
-  })
-  creator: User
-
-  @ManyToOne(type => User, {
-    nullable: true
-  })
-  updater: User
-}

package/server/graphql/index.ts

@@ -1,7 +0,0 @@
-import * as typeDefs from './types'
-import * as resolvers from './resolvers'
-
-export const schema = {
-  typeDefs,
-  resolvers
-}

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

@@ -1,21 +0,0 @@
-import { ArrivalNotice } from '../../../entities'
-import { generateArrivalNoticeFunction } from './generate-arrival-notice'
-import { confirmArrivalNoticeFunction } from './confirm-arrival-notice'
-import { EntityManager } from 'typeorm'
-
-const debug = require('debug')('things-factory:operato-wms:addArrivalNotice')
-
-export const addArrivalNotice = {
-  async addArrivalNotice(_: any, { arrivalNotice, file }, context: any) {
-    const { tx }: { tx: EntityManager } = context.state
-    const createdGAN: ArrivalNotice = await generateArrivalNoticeFunction(_, arrivalNotice, file, context, tx)
-
-    debug('createdGAN', createdGAN)
-
-    const confirmedGAN: ArrivalNotice = await confirmArrivalNoticeFunction(createdGAN.name, context, tx)
-
-    debug('confirmedGAN', confirmedGAN)
-
-    return confirmedGAN
-  }
-}

package/server/graphql/resolvers/arrival-notice/add-edit-arrival-notice-products.ts

@@ -1,110 +0,0 @@
-import { User } from '@things-factory/auth-base'
-import { getDomainUsers } from '@things-factory/biz-base'
-import { sendNotification } from '@things-factory/notification'
-import { Product } from '@things-factory/product-base'
-import { Domain } from '@things-factory/shell'
-import { ORDER_PRODUCT_STATUS, ORDER_STATUS } from '../../../constants'
-import { EntityManager, getRepository, Repository } from 'typeorm'
-import { ArrivalNotice, OrderProduct } from '../../../entities'
-import { OrderNoGenerator } from '../../../utils'
-
-const debug = require('debug')('things-factory:operato-wms:addEditArrivalNoticeProduct')
-
-export const addEditArrivalNoticeProductsResolver = {
-  async addEditArrivalNoticeProducts(
-    _: any,
-    { ganNo, newOrderProducts, existingOrderProducts },
-    context: any
-  ): Promise<void> {
-    const { user, domain, tx }: { user: User; domain: Domain; tx: EntityManager } = context.state
-
-    let arrivalNotice: ArrivalNotice = await tx.getRepository(ArrivalNotice).findOne({
-      where: { name: ganNo },
-      relations: ['bizplace', 'orderProducts']
-    })
-
-    arrivalNotice.status = ORDER_STATUS.PENDING_APPROVAL
-    arrivalNotice.updater = user
-    arrivalNotice = await tx.getRepository(ArrivalNotice).save(arrivalNotice)
-
-    debug('gan-new-order-products', ganNo, newOrderProducts)
-    if (newOrderProducts?.length > 0) await addArrivalNoticeProducts(domain, arrivalNotice, newOrderProducts, user, tx)
-
-    debug('gan-existing-order-products', ganNo, existingOrderProducts)
-    if (existingOrderProducts?.length > 0) await editArrivalNoticeProducts(existingOrderProducts, user, tx)
-
-    // notification logics
-    const users: any[] = await getDomainUsers(arrivalNotice?.bizplace, tx)
-    debug('users', users)
-
-    if (users?.length) {
-      const receivers: any[] = users.map(user => user.id)
-      const msg = {
-        title: `Products are added/edited for ${arrivalNotice.name}`,
-        body: `Warehouse need your review for changes to be approved`,
-        url: context.header.referer,
-        data: { url: context.header.referer }
-      }
-      await sendNotification({
-        receivers,
-        message: { ...msg }
-      })
-    }
-  }
-}
-
-export async function addArrivalNoticeProducts(
-  domain: Domain,
-  arrivalNotice: ArrivalNotice,
-  newOrderProducts: any[],
-  user: User,
-  tx?: EntityManager
-): Promise<void> {
-  const productRepo: Repository<Product> = tx?.getRepository(Product) || getRepository(Product)
-  const orderProductRepo: Repository<OrderProduct> = tx?.getRepository(OrderProduct) || getRepository(OrderProduct)
-
-  if (!arrivalNotice?.bizplace || !arrivalNotice?.orderProducts?.length) {
-    arrivalNotice = await tx.getRepository(ArrivalNotice).findOne({
-      where: { domain, name: arrivalNotice.name },
-      relations: ['bizplace', 'orderProducts']
-    })
-  }
-
-  const createdOrderProducts: OrderProduct[] = await Promise.all(
-    newOrderProducts.map(async (op: OrderProduct) => {
-      return {
-        ...op,
-        domain,
-        bizplace: arrivalNotice.bizplace,
-        name: OrderNoGenerator.orderProduct(),
-        product: await productRepo.findOne(op.product.id),
-        arrivalNotice,
-        creator: user
-      }
-    })
-  )
-
-  debug('gan-created-order-products', createdOrderProducts)
-  await orderProductRepo.save(createdOrderProducts)
-}
-
-export async function editArrivalNoticeProducts(
-  existingOrderProducts: OrderProduct[],
-  user: User,
-  tx?: EntityManager
-): Promise<void> {
-  const orderProductRepo: Repository<OrderProduct> = tx?.getRepository(OrderProduct) || getRepository(OrderProduct)
-
-  const updatedOrderProducts: OrderProduct[] = await Promise.all(
-    existingOrderProducts.map(async (op: OrderProduct) => {
-      return {
-        ...op,
-        status: ORDER_PRODUCT_STATUS.EDITED,
-        updater: user
-      }
-    })
-  )
-
-  debug('gan-updated-order-products', updatedOrderProducts)
-  await orderProductRepo.save(updatedOrderProducts)
-}

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

@@ -1,71 +0,0 @@
-import { User } from '@things-factory/auth-base'
-import { getPermittedBizplaceIds } from '@things-factory/biz-base'
-import { buildQuery, Domain, ListParam } from '@things-factory/shell'
-import { getRepository, SelectQueryBuilder } from 'typeorm'
-import { ORDER_STATUS } from '../../../constants'
-import { ArrivalNotice } from '../../../entities'
-
-export const arrivalNoticeRequestsResolver = {
-  async arrivalNoticeRequests(_: any, params: ListParam, context: any) {
-    try {
-      const { domain, user }: { domain: Domain; user: User } = context.state
-      const statusFilter = params.filters.some(e => e.name === 'status')
-      const bizplaceFilter = params.filters.find(param => param.name === 'bizplaceId')
-
-      if (!statusFilter) {
-        params.filters.push({
-          name: 'status',
-          operator: 'notin',
-          value: [ORDER_STATUS.PENDING, ORDER_STATUS.EDITING],
-          relation: false
-        })
-      }
-
-      if (!bizplaceFilter) {
-        params.filters.push({
-          name: 'bizplaceId',
-          operator: 'in',
-          value: await getPermittedBizplaceIds(domain, user),
-          relation: false
-        })
-      }
-
-      const qb: SelectQueryBuilder<ArrivalNotice> = getRepository(ArrivalNotice).createQueryBuilder('an')
-      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" = "an"."status"')
-          .andWhere('"ccd"."domain_id" = "an"."domain_id"')
-          .andWhere('"cc"."name" = \'ORDER_STATUS\'')
-      }, 'rank')
-      qb.leftJoinAndSelect('an.domain', 'domain')
-      qb.leftJoinAndSelect('an.bizplace', 'bizplace')
-      qb.leftJoinAndSelect('an.releaseGood', 'rg')
-      qb.leftJoinAndSelect('an.creator', 'creator')
-      qb.leftJoinAndSelect('an.updater', 'updater')
-      qb.leftJoinAndSelect('an.acceptedBy', 'acceptedBy')
-
-      const arrChildSortData = ['bizplace']
-      const sort = (params.sortings || []).reduce(
-        (acc, sort) => ({
-          ...acc,
-          [arrChildSortData.indexOf(sort.name) >= 0 ? sort.name + '.name' : 'an.' + 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 }
-    } catch (error) {
-      throw error
-    }
-  }
-}

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

@@ -1,86 +0,0 @@
-import { Attachment } from '@things-factory/attachment-base'
-import { User } from '@things-factory/auth-base'
-import { Bizplace, getPermittedBizplaceIds } from '@things-factory/biz-base'
-import { Domain } from '@things-factory/shell'
-import { getRepository, In } from 'typeorm'
-import { ATTACHMENT_TYPE } from '../../../constants/attachment-type'
-import { ArrivalNotice } from '../../../entities'
-
-export const arrivalNoticeResolver = {
-  async arrivalNotice(_: any, { name }, context: any) {
-    const { domain, user, bizplace }: { domain: Domain; user: User; bizplace: Bizplace } = context.state
-
-    let foundGAN: ArrivalNotice
-
-    if (context?.state?.bizplace) {
-      foundGAN = await getRepository(ArrivalNotice).findOne({
-        where: {
-          domain,
-          name,
-          bizplace
-        },
-        relations: [
-          'domain',
-          'bizplace',
-          'releaseGood',
-          'purchaseOrder',
-          'purchaseOrder.bufferLocation',
-          'orderProducts',
-          'orderProducts.product',
-          'orderVass',
-          'orderVass.vas',
-          'orderVass.targetProduct',
-          'supplier',
-          'creator',
-          'updater'
-        ]
-      })
-    } else {
-      foundGAN = await getRepository(ArrivalNotice).findOne({
-        where: {
-          domain,
-          name,
-          bizplace: In(await getPermittedBizplaceIds(domain, user))
-        },
-        relations: [
-          'domain',
-          'bizplace',
-          'releaseGood',
-          'purchaseOrder',
-          'purchaseOrder.bufferLocation',
-          'orderProducts',
-          'orderProducts.product',
-          'orderVass',
-          'orderVass.vas',
-          'orderVass.targetProduct',
-          'creator',
-          'updater'
-        ]
-      })
-    }
-
-    if (!foundGAN?.id) throw new Error(`Failed to find arrival notice with ${name}`)
-
-    const foundAttachments: Attachment[] = await getRepository(Attachment).find({
-      where: {
-        domain,
-        refBy: foundGAN.id,
-        category: ATTACHMENT_TYPE.GAN
-      }
-    })
-
-    const foundPOAttachments: Attachment[] = foundGAN?.purchaseOrder?.id ? await getRepository(Attachment).find({
-        where: {
-          domain,
-          refBy: foundGAN.purchaseOrder.id,
-          category: ATTACHMENT_TYPE.PO
-        }
-      }): []
-    
-
-    return {
-      ...foundGAN,
-      attachment: [...foundPOAttachments, ...foundAttachments]
-    }
-  }
-}

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

@@ -1,25 +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 } from 'typeorm'
-import { ArrivalNotice } from '../../../entities'
-
-export const arrivalNoticesResolver = {
-  async arrivalNotices(_: any, params: ListParam, context: any) {
-    const { domain, user }: { domain: Domain; user: User } = context.state
-
-    const convertedParams = convertListParams(params)
-
-    if (!params.filters.find((filter: any) => filter.name === 'bizplace')) {
-      convertedParams.where.bizplace = In(await getPermittedBizplaceIds(domain, user))
-      convertedParams.where.domain = domain
-    }
-
-    const [items, total] = await getRepository(ArrivalNotice).findAndCount({
-      ...convertedParams,
-      relations: ['domain', 'bizplace', 'releaseGood', 'orderProducts', 'orderVass', 'creator', 'updater', 'acceptedBy']
-    })
-
-    return { items, total }
-  }
-}

package/server/graphql/resolvers/arrival-notice/check-arrived-notice.ts

@@ -1,98 +0,0 @@
-import { EntityManager } from 'typeorm'
-import { User } from '@things-factory/auth-base'
-import { Domain } from '@things-factory/shell'
-import { getDomainUsers } from '@things-factory/biz-base'
-import { sendNotification } from '@things-factory/notification'
-import { ORDER_PRODUCT_STATUS, ORDER_STATUS, ORDER_VAS_STATUS } from '../../../constants'
-import { ArrivalNotice, CollectionOrder, OrderProduct, OrderVas } from '../../../entities'
-
-const debug = require('debug')('things-factory:operato-wms:checkArrivedNotice')
-
-export const checkArrivedNotice = {
-  async checkArrivedNotice(_: any, { name }, context: any) {
-    const { tx }: { tx: EntityManager } = context.state
-
-    return await checkArrivedNoticeFunction(name, context, tx)
-  }
-}
-
-export async function checkArrivedNoticeFunction(
-  name: string,
-  context: any,
-  tx?: EntityManager
-): Promise<ArrivalNotice> {
-  const { user, domain }: { user: User; domain: Domain } = context.state
-  try {
-    const foundArrivalNotice: ArrivalNotice = await tx.getRepository(ArrivalNotice).findOne({
-      where: { domain, name, status: ORDER_STATUS.INTRANSIT },
-      relations: ['bizplace', 'collectionOrders', 'orderProducts', 'orderVass']
-    })
-
-    debug('ganNo', name, foundArrivalNotice)
-
-    if (!foundArrivalNotice) throw new Error(`Arrival notice doesn't exists.`)
-
-    // 1. Check wheter related collection order is done or not
-    const foundCOs: CollectionOrder[] = foundArrivalNotice.collectionOrders
-    if (foundCOs && foundCOs.length) {
-      foundCOs.map((co: CollectionOrder) => {
-        if (co.status !== ORDER_STATUS.DONE) {
-          throw new Error(`Collection Order: ${co.name} is not finished yet.`)
-        }
-      })
-    }
-
-    let foundOPs: OrderProduct[] = foundArrivalNotice.orderProducts
-    let foundOVs: OrderVas[] = foundArrivalNotice.orderVass
-
-    // 2. Update status of order products (INTRANSIT => ARRIVED)
-    foundOPs = foundOPs.map((op: OrderProduct) => {
-      return {
-        ...op,
-        status: ORDER_PRODUCT_STATUS.ARRIVED,
-        updater: user
-      }
-    })
-    await tx.getRepository(OrderProduct).save(foundOPs)
-
-    // 3. Update status of order vass if it exists (INTRANSIT => ARRIVED)
-    if (foundOVs && foundOVs.length) {
-      foundOVs = foundOVs.map((ov: OrderVas) => {
-        return {
-          ...ov,
-          status: ORDER_VAS_STATUS.ARRIVED,
-          updater: user
-        }
-      })
-      await tx.getRepository(OrderVas).save(foundOVs)
-    }
-
-    // 4. Update status of arrival notice (INTRANSIT => ARRIVED)
-    await tx.getRepository(ArrivalNotice).save({
-      ...foundArrivalNotice,
-      status: ORDER_STATUS.ARRIVED,
-      updater: user
-    })
-
-    // notification logics
-    const users: any[] = await getDomainUsers(foundArrivalNotice?.bizplace, tx)
-
-    if (users?.length) {
-      const receivers: any[] = users.map(user => user.id)
-      const msg = {
-        title: `Latest status for ${foundArrivalNotice.name}`,
-        body: `Your goods has safely arrived at ${domain.name}`,
-        url: context.header.referer,
-        data: { url: context.header.referer }
-      }
-      await sendNotification({
-        receivers,
-        message: { ...msg }
-      })
-    }
-
-    return foundArrivalNotice
-  } catch (e) {
-    throw e
-  }
-}

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

@@ -1,112 +0,0 @@
-import { Role, User } from '@things-factory/auth-base'
-import { Bizplace } 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, OrderProduct, OrderVas } from '../../../entities'
-import { confirmReleaseGood } from '../release-good/confirm-release-good'
-
-export const confirmArrivalNoticeResolver = {
-  async confirmArrivalNotice(_: any, { name }, context: any) {
-    const { tx }: { tx: EntityManager } = context.state
-    const arrivalNotice: ArrivalNotice = await confirmArrivalNoticeFunction(name, context, tx)
-
-    // If current GAN has cross docking
-    if (arrivalNotice.crossDocking) {
-      const { releaseGood } = await tx.getRepository(ArrivalNotice).findOne(arrivalNotice.id, {
-        relations: ['releaseGood']
-      })
-
-      // If status of related RO is not equal to PENDING_RECEIVE (i.e. Wasn't confirmed yet.)
-      if (releaseGood.status !== ORDER_STATUS.PENDING_RECEIVE) {
-        await confirmReleaseGood(releaseGood.name, context)
-      }
-    }
-
-    return arrivalNotice
-  }
-}
-
-export async function confirmArrivalNoticeFunction(name: string, context: any, tx?: EntityManager): 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 },
-    relations: [
-      'bizplace',
-      'releaseGood',
-      'orderProducts',
-      'orderProducts.product',
-      'orderVass',
-      'orderVass.vas',
-      'creator',
-      'updater'
-    ]
-  })
-
-  let foundOPs: OrderProduct[] = foundArrivalNotice.orderProducts
-  let foundOVs: OrderVas[] = foundArrivalNotice.orderVass
-  let customerBizplace: Bizplace = foundArrivalNotice.bizplace
-
-  if (!foundArrivalNotice) throw new Error(`Arrival notice doesn't exists.`)
-
-  // 1. GAN Status change (PENDING => PENDING_RECEIVE)
-  const arrivalNotice: ArrivalNotice = await tx.getRepository(ArrivalNotice).save({
-    ...foundArrivalNotice,
-    status: ORDER_STATUS.PENDING_RECEIVE,
-    updater: user
-  })
-
-  foundOPs = foundOPs.map((op: OrderProduct) => {
-    return { ...op, status: ORDER_PRODUCT_STATUS.PENDING_RECEIVE }
-  })
-  await tx.getRepository(OrderProduct).save(foundOPs)
-
-  // 2. Update order vas status if it exists.
-  if (foundOVs && foundOVs.length) {
-    foundOVs = foundOVs.map((ov: OrderVas) => {
-      return { ...ov, status: ORDER_VAS_STATUS.PENDING_RECEIVE }
-    })
-
-    await tx.getRepository(OrderVas).save(foundOVs)
-  }
-
-  // notification logics
-  // get Office Admin Users
-  if (context?.state?.type != 'api') {
-    const users: any[] = await tx
-      .getRepository('users_roles')
-      .createQueryBuilder('ur')
-      .select('ur.users_id', 'id')
-      .where(qb => {
-        const subQuery = qb
-          .subQuery()
-          .select('role.id')
-          .from(Role, 'role')
-          .where("role.name = 'Office Admin'")
-          .andWhere('role.domain_id = :domain', { domain: domain.id })
-          .getQuery()
-        return 'ur.roles_id IN ' + subQuery
-      })
-      .getRawMany()
-
-    // send notification to Office Admin Users
-    if (users?.length) {
-      const receivers: any[] = users.map(user => user.id)
-      const msg = {
-        title: `New Arrival Notice from ${customerBizplace.name}`,
-        body: `New incoming order, ${foundArrivalNotice.name} is pending for receiving`,
-        url: context.header.referer,
-        data: { url: context.header.referer }
-      }
-
-      await sendNotification({
-        receivers,
-        message: { ...msg }
-      })
-    }
-  }
-
-  return arrivalNotice
-}

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
-}