@things-factory/sales-base 4.3.129 → 4.3.132

package/package.json

@@ -1,10 +1,9 @@
 {
   "name": "@things-factory/sales-base",
-  "version": "4.3.129",
+  "version": "4.3.132",
   "main": "dist-server/index.js",
   "browser": "client/index.js",
   "things-factory": true,
-  "license": "MIT",
   "author": "",
   "description": "Module to handle orders",
   "publishConfig": {
@@ -24,18 +23,18 @@
     "migration:create": "node ../../node_modules/typeorm/cli.js migration:create -d ./server/migrations"
   },
   "dependencies": {
-    "@things-factory/attachment-base": "^4.3.122",
-    "@things-factory/auth-base": "^4.3.122",
-    "@things-factory/biz-base": "^4.3.122",
-    "@things-factory/code-base": "^4.3.122",
-    "@things-factory/integration-accounting": "^4.3.123",
-    "@things-factory/integration-sftp": "^4.3.123",
-    "@things-factory/notification": "^4.3.122",
-    "@things-factory/product-base": "^4.3.122",
-    "@things-factory/setting-base": "^4.3.122",
-    "@things-factory/shell": "^4.3.122",
-    "@things-factory/transport-base": "^4.3.122",
-    "@things-factory/warehouse-base": "^4.3.129"
+    "@things-factory/attachment-base": "^4.3.131",
+    "@things-factory/auth-base": "^4.3.131",
+    "@things-factory/biz-base": "^4.3.131",
+    "@things-factory/code-base": "^4.3.131",
+    "@things-factory/integration-accounting": "^4.3.131",
+    "@things-factory/integration-sftp": "^4.3.131",
+    "@things-factory/notification": "^4.3.131",
+    "@things-factory/product-base": "^4.3.131",
+    "@things-factory/setting-base": "^4.3.131",
+    "@things-factory/shell": "^4.3.131",
+    "@things-factory/transport-base": "^4.3.131",
+    "@things-factory/warehouse-base": "^4.3.132"
   },
-  "gitHead": "e34b57b1a0974f4bcc4ef92e63e2327b800613b3"
+  "gitHead": "4eb399665fdb2475691201409c7574bc95de3d95"
 }

package/server/constants/order.ts

@@ -201,3 +201,8 @@ export const DRAFT_RELEASE_ORDER_STATUS = {
   SUBMITTED: 'SUBMITTED',
   CANCELLED: 'CANCELLED'
 }
+
+export const ORDER_SOURCE_TYPE = {
+  XILNEX_PO: 'XILNEX_PO',
+  XILNEX_TRANSFER_NOTE: 'XILNEX_TRANSFER_NOTE'
+}

package/server/service/arrival-notice/arrival-notice.ts

@@ -152,6 +152,10 @@ export class ArrivalNotice {
   @Field({ nullable: true })
   source: string
 
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  orderSourceType: string
+
   @OneToOne(type => PurchaseOrder, { nullable: true })
   @JoinColumn()
   @Field(type => PurchaseOrder, { nullable: true })

package/server/service/delivery-order/delivery-order-mutation.ts

@@ -3,11 +3,11 @@ import { Arg, Ctx, Directive, Mutation, Resolver } from 'type-graphql'
 import { EntityManager, getRepository, In, Repository } from 'typeorm'
 
 import { Attachment, createAttachment, deleteAttachment } from '@things-factory/attachment-base'
-import { User } from '@things-factory/auth-base'
+import { ApplicationType, User } from '@things-factory/auth-base'
 import { Bizplace, ContactPoint, getPermittedBizplaceIds } from '@things-factory/biz-base'
-// import { logger } from '@things-factory/env'
+import { logger } from '@things-factory/env'
 import { generateId } from '@things-factory/id-rule-base'
-// import { Account, AccountingAPI } from '@things-factory/integration-accounting'
+import { Account, AccountingAPI } from '@things-factory/integration-accounting'
 import { Product } from '@things-factory/product-base'
 import { Setting } from '@things-factory/setting-base'
 import { Domain, ObjectRef } from '@things-factory/shell'
@@ -423,33 +423,33 @@ export class DeliveryOrderMutation {
         updater: user
       })
 
-      // const orderSource: string = foundReleaseGood.source
-      // switch (orderSource) {
-      //   case ApplicationType.XILNEX:
-      //     if (foundDeliveryOrder.status === ORDER_STATUS.READY_TO_DISPATCH) {
-      //       const xilnex: Account = await tx.getRepository(Account).findOne({
-      //         domain: foundDeliveryOrder.bizplace.domain,
-      //         status: 'active',
-      //         platform: 'xilnex'
-      //       })
-
-      //       if (xilnex) {
-      //         try {
-      //           await AccountingAPI.createTransferNote(xilnex, {
-      //             releaseGood: foundReleaseGood,
-      //             deliveryOrder: foundDeliveryOrder,
-      //             orderInventories
-      //           })
-      //         } catch (error) {
-      //           logger.error(`delivery-order-mutation[dispatchDeliveryOrder]: ${error}`)
-      //         }
-      //       }
-      //     }
-      //     break
-
-      //   default:
-      //     break
-      // }
+      const orderSource: string = foundReleaseGood.source
+      switch (orderSource) {
+        case ApplicationType.XILNEX:
+          if (foundDeliveryOrder.status === ORDER_STATUS.READY_TO_DISPATCH) {
+            const xilnex: Account = await tx.getRepository(Account).findOne({
+              domain: foundDeliveryOrder.bizplace.domain,
+              status: 'active',
+              platform: 'xilnex'
+            })
+
+            if (xilnex) {
+              try {
+                await AccountingAPI.createTransferNote(xilnex, {
+                  releaseGood: foundReleaseGood,
+                  deliveryOrder: foundDeliveryOrder,
+                  orderInventories
+                })
+              } catch (error) {
+                logger.error(`delivery-order-mutation[dispatchDeliveryOrder]: ${error}`)
+              }
+            }
+          }
+          break
+
+        default:
+          break
+      }
 
       return foundDeliveryOrder
     } catch (e) {

package/server/service/draft-release-good/draft-release-good-mutation.ts

@@ -1,6 +1,7 @@
 import { FileUpload, GraphQLUpload } from 'graphql-upload'
 import { Arg, Ctx, Directive, Mutation, Resolver } from 'type-graphql'
 import { EntityManager, getConnection, getRepository, In, IsNull, Repository } from 'typeorm'
+import { logger } from '@things-factory/env'
 
 import { Attachment, createAttachments, deleteAttachmentsByRef } from '@things-factory/attachment-base'
 import { User } from '@things-factory/auth-base'
@@ -185,240 +186,250 @@ export class DraftReleaseGoodMutation {
     // @Arg('bizplaceId', type => String) bizplaceId: string
   ): Promise<boolean> {
     const { domain, user, tx } = context.state
-
-    const updatableDraftOrders = await tx.getRepository(DraftReleaseGood).find({
-      where: {
-        domain,
-        id: In(ids),
-        status: DRAFT_RELEASE_ORDER_STATUS.DRAFT
-      },
-      relations: [
-        'orderProducts',
-        'orderProducts.product',
-        'orderProducts.productBundle',
-        'shippingOrder',
-        'bizplace',
-        'bizplace.domain',
-        'domain',
-        'creator',
-        'updater'
-      ]
-    })
-    if (updatableDraftOrders.length > 0) {
-      let createdReleaseGoods: ReleaseGood[] = []
-      const settingRepo: Repository<Setting> = tx?.getRepository(Setting) || getRepository(Setting)
-
-      const roNoSetting: Setting = await settingRepo.findOne({
+    try {
+      const updatableDraftOrders = await tx.getRepository(DraftReleaseGood).find({
         where: {
           domain,
-          name: ORDER_NUMBER_SETTING_KEY.RO_NUMBER_RULE
-        }
+          id: In(ids),
+          status: DRAFT_RELEASE_ORDER_STATUS.DRAFT
+        },
+        relations: [
+          'orderProducts',
+          'orderProducts.product',
+          'orderProducts.productBundle',
+          'shippingOrder',
+          'bizplace',
+          'bizplace.domain',
+          'domain',
+          'creator',
+          'updater'
+        ]
       })
 
-      for (let index = 0; index < updatableDraftOrders.length; index++) {
-        await getConnection().transaction(async (parentTx: EntityManager) => {
-          const draftOrder = updatableDraftOrders[index]
-
-          let foundPermittedBizplace: Bizplace
-          let companyBizplace: Bizplace
+      if (updatableDraftOrders.length > 0) {
+        let createdReleaseGoods: ReleaseGood[] = []
+        const settingRepo: Repository<Setting> = tx?.getRepository(Setting) || getRepository(Setting)
 
-          if (draftOrder?.bizplace?.id) {
-            foundPermittedBizplace = await parentTx.getRepository(Bizplace).findOne(draftOrder.bizplace.id, {
-              relations: ['company', 'company.domain']
-            })
-            const companyDomain: Domain = foundPermittedBizplace.company.domain
-            companyBizplace = await parentTx.getRepository(Bizplace).findOne({ where: { domain: companyDomain } })
-          } else {
-            return false
+        const roNoSetting: Setting = await settingRepo.findOne({
+          where: {
+            domain,
+            name: ORDER_NUMBER_SETTING_KEY.RO_NUMBER_RULE
           }
+        })
 
-          const bizplaces: Bizplace[] = [foundPermittedBizplace, companyBizplace]
+        for (let index = 0; index < updatableDraftOrders.length; index++) {
+          await getConnection().transaction(async (parentTx: EntityManager) => {
+            const draftOrder = updatableDraftOrders[index]
 
-          let productInventory = await InventoryUtil.bizplaceProductInventory(
-            bizplaces,
-            {
-              filters: [
-                {
-                  name: 'productId',
-                  operator: 'in',
-                  value: [
-                    ...draftOrder.orderProducts
-                      .filter(itm => itm?.product)
-                      .map(itm => {
-                        return itm.product.id
-                      }),
-                    ...draftOrder.orderProducts
-                      .filter(itm => itm?.productBundle)
-                      .map(itm => {
-                        return itm.productBundle.id
-                      })
-                  ]
-                }
-              ]
-            },
-            context,
-            parentTx
-          )
-
-          draftOrder.orderProducts = draftOrder.orderProducts.map(itm => {
-            let foundProductInv = productInventory.items.find(
-              i =>
-                (i.productId == itm?.product?.id || i.productId == itm?.productBundle?.id) &&
-                i.packingType == itm.packingType &&
-                i.packingSize == itm.packingSize &&
-                i.uom == itm.uom &&
-                itm.releaseQty <= i.remainQty
-            )
-            return {
-              ...itm,
-              releaseUomValue: (foundProductInv.remainUomValue / foundProductInv.remainQty) * itm.releaseQty,
-              status: foundProductInv ? 'suffice' : 'insufficient'
+            let foundPermittedBizplace: Bizplace
+            let companyBizplace: Bizplace
+
+            if (draftOrder?.bizplace?.id) {
+              foundPermittedBizplace = await parentTx.getRepository(Bizplace).findOne(draftOrder.bizplace.id, {
+                relations: ['company', 'company.domain']
+              })
+              const companyDomain: Domain = foundPermittedBizplace.company.domain
+              companyBizplace = await parentTx.getRepository(Bizplace).findOne({ where: { domain: companyDomain } })
+            } else {
+              return false
             }
-          })
 
-          let insufficient = draftOrder.orderProducts.find(op => op.status == 'insufficient')
-          if (!insufficient) {
-            //create RO
-            let releaseGood = { ...draftOrder }
-            delete releaseGood.id
-            delete releaseGood.name
-            delete releaseGood.createdAt
-            delete releaseGood.createdBy
-            delete releaseGood.updatedAt
-            delete releaseGood.updatedBy
-
-            let orderInventories = []
-
-            for (let index = 0; index < draftOrder.orderProducts.length; index++) {
-              const itm: Partial<OrderProduct> = draftOrder.orderProducts[index]
-              let data = []
-              if (itm.productBundle) {
-                let bundle: ProductBundle = await parentTx.getRepository(ProductBundle).findOne({
-                  where: { id: itm.productBundle.id },
-                  relations: [
-                    'productBundleSettings',
-                    'productBundleSettings.productDetail',
-                    'productBundleSettings.product'
-                  ]
-                })
+            const bizplaces: Bizplace[] = [foundPermittedBizplace, companyBizplace]
 
-                for (let index2 = 0; index2 < bundle.productBundleSettings.length; index2++) {
-                  const objProductBundleSetting = bundle.productBundleSettings[index2]
-                  data.push({
-                    sku: objProductBundleSetting.product.sku,
-                    packingType: objProductBundleSetting.productDetail.packingType,
-                    packingSize: objProductBundleSetting.productDetail.packingSize,
-                    uom: objProductBundleSetting.productDetail.uom,
-                    releaseQty: objProductBundleSetting.bundleQty * itm.releaseQty,
-                    assignedQty: undefined,
-                    assignedUomValue: undefined,
-                    releaseUomValue: objProductBundleSetting.bundleQty * itm.releaseQty * itm.releaseUomValue
-                  })
-                }
-              } else {
-                data = [
-                  {
-                    sku: itm.product.sku,
-                    packingType: itm.packingType,
-                    packingSize: itm.packingSize,
-                    uom: itm.uom,
-                    releaseQty: itm.releaseQty,
-                    assignedQty: undefined,
-                    assignedUomValue: undefined,
-                    releaseUomValue: itm.releaseUomValue
-                  }
-                ]
-              }
+            let loggerJson = JSON.stringify({ refNo: draftOrder.refNo, bizplaceId: draftOrder.bizplace.id, domain })
+            try {
+              console.time(`creating_order:${loggerJson}`)
 
-              data.forEach(data => {
-                let existingOI = orderInventories.find(
-                  itm =>
-                    itm.sku == data.sku &&
-                    itm.packingType == data.packingType &&
-                    itm.packingSize == data.packingSize &&
-                    itm.uom == data.uom
+              let productInventory = await InventoryUtil.bizplaceProductInventory(
+                bizplaces,
+                {
+                  filters: [
+                    {
+                      name: 'productId',
+                      operator: 'in',
+                      value: [
+                        ...draftOrder.orderProducts
+                          .filter(itm => itm?.product)
+                          .map(itm => {
+                            return itm.product.id
+                          }),
+                        ...draftOrder.orderProducts
+                          .filter(itm => itm?.productBundle)
+                          .map(itm => {
+                            return itm.productBundle.id
+                          })
+                      ]
+                    }
+                  ]
+                },
+                context,
+                parentTx
+              )
+
+              draftOrder.orderProducts = draftOrder.orderProducts.map(itm => {
+                let foundProductInv = productInventory.items.find(
+                  i =>
+                    (i.productId == itm?.product?.id || i.productId == itm?.productBundle?.id) &&
+                    i.packingType == itm.packingType &&
+                    i.packingSize == itm.packingSize &&
+                    i.uom == itm.uom &&
+                    itm.releaseQty <= i.remainQty
                 )
-
-                if (existingOI) {
-                  existingOI.releaseQty = existingOI.releaseQty + data.releaseQty
-                  existingOI.releaseUomValue = existingOI.releaseUomValue + data.uomValue
-                  existingOI.uomValue = existingOI.uomValue + data.uomValue
-                } else {
-                  orderInventories.push({ ...data, orderProduct: itm })
+                return {
+                  ...itm,
+                  releaseUomValue: (foundProductInv.remainUomValue / foundProductInv.remainQty) * itm.releaseQty,
+                  status: foundProductInv ? 'suffice' : 'insufficient'
                 }
               })
-            }
-            try {
-              await getConnection().transaction(async (childTx: EntityManager) => {
-                let availableItems: any[] = await bulkReleaseGoodsAvailableItemsFunction(
-                  orderInventories,
-                  draftOrder.bizplace.id,
-                  context,
-                  childTx
-                )
-                if (availableItems.some(item => !item.releaseQty || item.releaseQty > item.assignedQty))
-                  throw new ValidationError({
-                    ...ValidationError.ERROR_CODES.INSUFFICIENT_STOCK,
-                    detail: { data: JSON.stringify(availableItems) }
-                  })
-                // update orderInventories if availableItems are valid
-                releaseGood.orderInventories = availableItems.map(itm => {
-                  return {
-                    ...itm,
-                    releaseQty: itm.releaseQty,
-                    releaseUomValue: itm.releaseUomValue,
-                    uomValue: itm.uomValue
+
+              let insufficient = draftOrder.orderProducts.find(op => op.status == 'insufficient')
+              if (!insufficient) {
+                //create RO
+                let releaseGood = { ...draftOrder }
+                delete releaseGood.id
+                delete releaseGood.name
+                delete releaseGood.createdAt
+                delete releaseGood.createdBy
+                delete releaseGood.updatedAt
+                delete releaseGood.updatedBy
+
+                let orderInventories = []
+
+                for (let index = 0; index < draftOrder.orderProducts.length; index++) {
+                  const itm: Partial<OrderProduct> = draftOrder.orderProducts[index]
+                  let data = []
+                  if (itm.productBundle) {
+                    let bundle: ProductBundle = await parentTx.getRepository(ProductBundle).findOne({
+                      where: { id: itm.productBundle.id },
+                      relations: [
+                        'productBundleSettings',
+                        'productBundleSettings.productDetail',
+                        'productBundleSettings.product'
+                      ]
+                    })
+
+                    for (let index2 = 0; index2 < bundle.productBundleSettings.length; index2++) {
+                      const objProductBundleSetting = bundle.productBundleSettings[index2]
+                      data.push({
+                        sku: objProductBundleSetting.product.sku,
+                        packingType: objProductBundleSetting.productDetail.packingType,
+                        packingSize: objProductBundleSetting.productDetail.packingSize,
+                        uom: objProductBundleSetting.productDetail.uom,
+                        releaseQty: objProductBundleSetting.bundleQty * itm.releaseQty,
+                        assignedQty: undefined,
+                        assignedUomValue: undefined,
+                        releaseUomValue: objProductBundleSetting.bundleQty * itm.releaseQty * itm.releaseUomValue
+                      })
+                    }
+                  } else {
+                    data = [
+                      {
+                        sku: itm.product.sku,
+                        packingType: itm.packingType,
+                        packingSize: itm.packingSize,
+                        uom: itm.uom,
+                        releaseQty: itm.releaseQty,
+                        assignedQty: undefined,
+                        assignedUomValue: undefined,
+                        releaseUomValue: itm.releaseUomValue
+                      }
+                    ]
                   }
-                })
-                let createdReleaseGood: ReleaseGood = await bulkGenerateReleaseGood(
-                  releaseGood,
-                  releaseGood.bizplace.id,
-                  roNoSetting,
-                  domain,
-                  user,
-                  childTx
-                )
-                await childTx
-                  .getRepository(DraftReleaseGood)
-                  .update(
-                    { id: draftOrder.id },
-                    { releaseGood: createdReleaseGood, status: DRAFT_RELEASE_ORDER_STATUS.SUBMITTED }
-                  )
 
-                const directReceiveSetting: Setting = await tx.getRepository(Setting).findOne({
-                  where: { domain, category: 'id-rule', name: 'enable-direct-receive-release-order' }
-                })
+                  data.forEach(data => {
+                    let existingOI = orderInventories.find(
+                      itm =>
+                        itm.sku == data.sku &&
+                        itm.packingType == data.packingType &&
+                        itm.packingSize == data.packingSize &&
+                        itm.uom == data.uom
+                    )
+
+                    if (existingOI) {
+                      existingOI.releaseQty = existingOI.releaseQty + data.releaseQty
+                      existingOI.releaseUomValue = existingOI.releaseUomValue + data.uomValue
+                      existingOI.uomValue = existingOI.uomValue + data.uomValue
+                    } else {
+                      orderInventories.push({ ...data, orderProduct: itm })
+                    }
+                  })
+                }
+                await getConnection().transaction(async (childTx: EntityManager) => {
+                  let availableItems: any[] = await bulkReleaseGoodsAvailableItemsFunction(
+                    orderInventories,
+                    draftOrder.bizplace.id,
+                    context,
+                    childTx
+                  )
+                  if (availableItems.some(item => !item.releaseQty || item.releaseQty > item.assignedQty))
+                    throw new ValidationError({
+                      ...ValidationError.ERROR_CODES.INSUFFICIENT_STOCK,
+                      detail: { data: JSON.stringify(availableItems) }
+                    })
+                  // update orderInventories if availableItems are valid
+                  releaseGood.orderInventories = availableItems.map(itm => {
+                    return {
+                      ...itm,
+                      releaseQty: itm.releaseQty,
+                      releaseUomValue: itm.releaseUomValue,
+                      uomValue: itm.uomValue
+                    }
+                  })
+                  let createdReleaseGood: ReleaseGood = await bulkGenerateReleaseGood(
+                    releaseGood,
+                    releaseGood.bizplace.id,
+                    roNoSetting,
+                    domain,
+                    user,
+                    childTx
+                  )
+                  await childTx
+                    .getRepository(DraftReleaseGood)
+                    .update(
+                      { id: draftOrder.id },
+                      { releaseGood: createdReleaseGood, status: DRAFT_RELEASE_ORDER_STATUS.SUBMITTED }
+                    )
+
+                  const directReceiveSetting: Setting = await tx.getRepository(Setting).findOne({
+                    where: { domain, category: 'id-rule', name: 'enable-direct-receive-release-order' }
+                  })
 
-                const partnerDirectReceiveSetting: PartnerSetting = await tx.getRepository(PartnerSetting).findOne({
-                  where: { setting: directReceiveSetting, domain, partnerDomain: draftOrder.bizplace?.domain }
-                })
+                  const partnerDirectReceiveSetting: PartnerSetting = await tx.getRepository(PartnerSetting).findOne({
+                    where: { setting: directReceiveSetting, domain, partnerDomain: draftOrder.bizplace?.domain }
+                  })
 
-                let settingValue
+                  let settingValue
 
-                if (
-                  !isNaN(partnerDirectReceiveSetting?.value) &&
-                  !isNaN(parseFloat(partnerDirectReceiveSetting?.value))
-                ) {
-                  settingValue = parseFloat(partnerDirectReceiveSetting.value)
-                } else {
-                  settingValue = parseFloat(directReceiveSetting.value)
-                }
+                  if (
+                    !isNaN(partnerDirectReceiveSetting?.value) &&
+                    !isNaN(parseFloat(partnerDirectReceiveSetting?.value))
+                  ) {
+                    settingValue = parseFloat(partnerDirectReceiveSetting.value)
+                  } else {
+                    settingValue = parseFloat(directReceiveSetting.value)
+                  }
 
-                createdReleaseGood = await confirmReleaseGood(createdReleaseGood.name, context, childTx)
+                  createdReleaseGood = await confirmReleaseGood(createdReleaseGood.name, context, childTx)
 
-                if (settingValue > 1) {
-                  createdReleaseGood = await receiveReleaseGood(createdReleaseGood.name, context, childTx)
-                }
-              })
-            } catch (error) {
-              console.error(error)
+                  if (settingValue > 1) {
+                    createdReleaseGood = await receiveReleaseGood(createdReleaseGood.name, context, childTx)
+                  }
+                })
+              }
+            } catch (e) {
+              logger.error(`draft-release-good-mutation[generateReleaseGoodsFromDraft:${loggerJson}]: ${e?.message}`)
+            } finally {
+              console.timeEnd(`creating_order:${loggerJson}`)
             }
-          }
-        })
+          })
+        }
       }
+
+      return true
+    } catch (e) {
+      logger.error(`draft-release-good-mutation[generateReleaseGoodsFromDraft]: ${e?.message}`)
     }
 
-    return true
   }
 }
 
@@ -761,8 +772,8 @@ export async function upsertDraftReleaseGoodProducts(
         updatePatch['packingType'] = op?.packingType
           ? op.packingType
           : product?.packingType
-          ? product.packingType
-          : productBundle.packingType
+            ? product.packingType
+            : productBundle.packingType
         updatePatch['uom'] = op?.uom ? op.uom : product?.primaryUnit ? product.primaryUnit : 'UNIT'
         updatePatch['uomValue'] = op?.uomValue ? op.uomValue : product?.primaryValue ? product.primaryValue : 0
 

package/server/service/goods-receival-note/goods-receival-note-mutation.ts

@@ -3,9 +3,7 @@ import { EntityManager, getRepository, In, Repository } from 'typeorm'
 
 import { User } from '@things-factory/auth-base'
 import { Bizplace } from '@things-factory/biz-base'
-// import { logger } from '@things-factory/env'
 import { generateId } from '@things-factory/id-rule-base'
-// import { Account, AccountingAPI } from '@things-factory/integration-accounting'
 import { Setting } from '@things-factory/setting-base'
 import { Domain } from '@things-factory/shell'
 
@@ -129,30 +127,5 @@ export async function generateGoodsReceivalNote(
     updater: user
   })
 
-  // const orderSource: string = arrivalNotice.source
-  // switch (orderSource) {
-  //   case ApplicationType.XILNEX:
-  //     const xilnex: Account = await tx.getRepository(Account).findOne({
-  //       domain: arrivalNotice.bizplace.domain,
-  //       status: 'active',
-  //       platform: 'xilnex'
-  //     })
-
-  //     if (xilnex) {
-  //       try {
-  //         await AccountingAPI.createGoodsReceivedNote(xilnex, {
-  //           arrivalNotice,
-  //           orderProducts: arrivalNotice.orderProducts
-  //         })
-  //       } catch (error) {
-  //         logger.error(`goods-receival-note-mutation[generateGoodsReceivalNote]: ${error}`)
-  //       }
-  //     }
-  //     break
-
-  //   default:
-  //     break
-  // }
-
   return goodReceiveNote
 }