@things-factory/sales-base 5.0.13 → 6.0.0-alpha.1

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

@@ -1,7 +1,7 @@
 import type { FileUpload } from 'graphql-upload/GraphQLUpload.js'
 import GraphQLUpload from 'graphql-upload/GraphQLUpload.js'
 import { Arg, Ctx, Directive, Mutation, Resolver } from 'type-graphql'
-import { EntityManager, getConnection, getRepository, In, IsNull, Repository } from 'typeorm'
+import { EntityManager, getConnection, In, IsNull, Repository } from 'typeorm'
 
 import { Attachment, createAttachments, deleteAttachmentsByRef } from '@things-factory/attachment-base'
 import { User } from '@things-factory/auth-base'
@@ -9,7 +9,7 @@ import { Bizplace, getPermittedBizplaces } from '@things-factory/biz-base'
 import { generateId } from '@things-factory/id-rule-base'
 import { Product, ProductBundle, ProductDetail } from '@things-factory/product-base'
 import { Setting } from '@things-factory/setting-base'
-import { Domain } from '@things-factory/shell'
+import { Domain, getRepository } from '@things-factory/shell'
 
 // import { Location } from '@things-factory/warehouse-base'
 import { DraftReleaseGood, DraftReleaseGoodPatch, NewDraftReleaseGood, OrderProduct } from '../'
@@ -42,14 +42,14 @@ export class DraftReleaseGoodMutation {
   @Directive('@transaction')
   @Mutation(returns => DraftReleaseGood)
   async upsertDraftReleaseGood(
-    @Ctx() context: any,
+    @Ctx() context: ResolverContext,
     @Arg('draftReleaseGood', type => DraftReleaseGoodPatch) draftReleaseGood: DraftReleaseGoodPatch,
     @Arg('orderProducts', type => [OrderProductPatch]) orderProducts: [OrderProductPatch],
     @Arg('files', type => [GraphQLUpload], { nullable: true }) files?: FileUpload[],
     @Arg('shippingOrder', type => ShippingOrderPatch, { nullable: true }) shippingOrder?: ShippingOrderPatch
   ): Promise<DraftReleaseGood> {
     try {
-      const { tx }: { tx: EntityManager } = context.state
+      const { tx } = context.state
       const createdDraftReleaseGood: DraftReleaseGood = await upsertDraftReleaseGoodFunction(
         null,
         draftReleaseGood,
@@ -70,12 +70,12 @@ export class DraftReleaseGoodMutation {
   @Mutation(returns => DraftReleaseGood, { description: 'To create new DraftReleaseGood' })
   async createDraftReleaseGood(
     @Arg('draftReleaseGood', type => NewDraftReleaseGood, { nullable: true }) draftReleaseGood: NewDraftReleaseGood,
-    @Ctx() context: any
+    @Ctx() context: ResolverContext
   ): Promise<DraftReleaseGood> {
     const { domain, user, tx } = context.state
 
     let drg = await tx.getRepository(DraftReleaseGood).save({
-      ...draftReleaseGood,
+      ...(draftReleaseGood as any),
       domain,
       status: 'INSUFFICIENT',
       creator: user,
@@ -92,18 +92,18 @@ export class DraftReleaseGoodMutation {
   async updateDraftReleaseGood(
     @Arg('id') id: string,
     @Arg('patch', type => DraftReleaseGoodPatch) patch: DraftReleaseGoodPatch,
-    @Ctx() context: any
+    @Ctx() context: ResolverContext
   ): Promise<DraftReleaseGood> {
     const { domain, user, tx } = context.state
 
     const repository = tx.getRepository(DraftReleaseGood)
     const draftReleaseGood = await repository.findOne({
-      where: { domain, id }
+      where: { domain: { id: domain.id }, id }
     })
 
     return await repository.save({
       ...draftReleaseGood,
-      ...patch,
+      ...(patch as any),
       updater: user
     })
   }
@@ -112,7 +112,7 @@ export class DraftReleaseGoodMutation {
   @Mutation(returns => [DraftReleaseGood], { description: "To modify multiple DraftReleaseGoods' information" })
   async updateMultipleDraftReleaseGood(
     @Arg('patches', type => [DraftReleaseGoodPatch]) patches: DraftReleaseGoodPatch[],
-    @Ctx() context: any
+    @Ctx() context: ResolverContext
   ): Promise<DraftReleaseGood[]> {
     const { domain, user, tx } = context.state
 
@@ -126,7 +126,7 @@ export class DraftReleaseGoodMutation {
         const newRecord = _createRecords[i]
 
         const result = await draftReleaseGoodRepo.save({
-          ...newRecord,
+          ...(newRecord as any),
           domain,
           creator: user,
           updater: user
@@ -139,11 +139,11 @@ export class DraftReleaseGoodMutation {
     if (_updateRecords.length > 0) {
       for (let i = 0; i < _updateRecords.length; i++) {
         const newRecord = _updateRecords[i]
-        const draftReleaseGood = await draftReleaseGoodRepo.findOne(newRecord.id)
+        const draftReleaseGood = await draftReleaseGoodRepo.findOneBy({ id: newRecord.id })
 
         const result = await draftReleaseGoodRepo.save({
           ...draftReleaseGood,
-          ...newRecord,
+          ...(newRecord as any),
           updater: user
         })
 
@@ -156,20 +156,23 @@ export class DraftReleaseGoodMutation {
 
   @Directive('@transaction')
   @Mutation(returns => Boolean, { description: 'To delete DraftReleaseGood' })
-  async deleteDraftReleaseGood(@Arg('id') id: string, @Ctx() context: any): Promise<boolean> {
+  async deleteDraftReleaseGood(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<boolean> {
     const { domain, tx } = context.state
 
-    await tx.getRepository(DraftReleaseGood).delete({ domain, id })
+    await tx.getRepository(DraftReleaseGood).delete({ domain: { id: domain.id }, id })
     return true
   }
 
   @Directive('@transaction')
   @Mutation(returns => Boolean, { description: 'To delete multiple draftReleaseGoods' })
-  async deleteDraftReleaseGoods(@Arg('ids', type => [String]) ids: string[], @Ctx() context: any): Promise<boolean> {
+  async deleteDraftReleaseGoods(
+    @Arg('ids', type => [String]) ids: string[],
+    @Ctx() context: ResolverContext
+  ): Promise<boolean> {
     const { domain, tx } = context.state
 
     await tx.getRepository(DraftReleaseGood).delete({
-      domain,
+      domain: { id: domain.id },
       id: In(ids)
     })
 
@@ -180,7 +183,7 @@ export class DraftReleaseGoodMutation {
   @Directive('@transaction')
   @Mutation(returns => Boolean, { description: 'To generate Release Goods from Draft' })
   async generateReleaseGoodsFromDraft(
-    @Ctx() context: any,
+    @Ctx() context: ResolverContext,
     @Arg('ids', type => [String]) ids: string[]
     // @Arg('rawReleaseGoods', type => [NewReleaseGood], { nullable: true }) rawReleaseGoods: NewReleaseGood[],
     // @Arg('bizplaceId', type => String) bizplaceId: string
@@ -189,7 +192,7 @@ export class DraftReleaseGoodMutation {
 
     const updatableDraftOrders = await tx.getRepository(DraftReleaseGood).find({
       where: {
-        domain,
+        domain: { id: domain.id },
         id: In(ids),
         status: DRAFT_RELEASE_ORDER_STATUS.DRAFT
       },
@@ -210,183 +213,190 @@ export class DraftReleaseGoodMutation {
 
       const roNoSetting: Setting = await settingRepo.findOne({
         where: {
-          domain,
+          dodomain: { id: domain.id },
           name: ORDER_NUMBER_SETTING_KEY.RO_NUMBER_RULE
         }
       })
 
       for (let index = 0; index < updatableDraftOrders.length; index++) {
-        const draftOrder = updatableDraftOrders[index]
+        await getConnection().transaction(async (parentTx: EntityManager) => {
+          const draftOrder = updatableDraftOrders[index]
 
-        let foundPermittedBizplace: Bizplace
-        let companyBizplace: Bizplace
+          let foundPermittedBizplace: Bizplace
+          let companyBizplace: Bizplace
 
-        if (draftOrder?.bizplace?.id) {
-          foundPermittedBizplace = await tx.getRepository(Bizplace).findOne(draftOrder.bizplace.id, {
-            relations: ['company', 'company.domain']
-          })
-          const companyDomain: Domain = foundPermittedBizplace.company.domain
-          companyBizplace = await tx.getRepository(Bizplace).findOne({ where: { domain: companyDomain } })
-        } else {
-          return false
-        }
-
-        const bizplaces: Bizplace[] = [foundPermittedBizplace, companyBizplace]
-
-        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,
-          tx
-        )
-
-        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, status: foundProductInv ? 'suffice' : 'insufficient' }
-        })
+          if (draftOrder?.bizplace?.id) {
+            foundPermittedBizplace = await parentTx.getRepository(Bizplace).findOne({
+              where: { id: 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 = draftOrder.orderProducts[index]
-            let data = []
-            if (itm.productBundle) {
-              let bundle = await tx.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,
-                  packing_type: objProductBundleSetting.productDetail.packingType,
-                  packing_size: objProductBundleSetting.productDetail.packingSize,
-                  uom: objProductBundleSetting.productDetail.uom,
-                  release_qty: objProductBundleSetting.bundleQty * itm.releaseQty,
-                  assignedQty: undefined,
-                  assignedUomValue: undefined,
-                  releaseUomValue: undefined
-                })
-              }
-            } else {
-              data = [
+          let productInventory = await InventoryUtil.bizplaceProductInventory(
+            bizplaces,
+            {
+              filters: [
                 {
-                  sku: itm.product.sku,
-                  packing_type: itm.packingType,
-                  packing_size: itm.packingSize,
-                  uom: itm.uom,
-                  release_qty: itm.releaseQty,
-                  assignedQty: undefined,
-                  assignedUomValue: undefined,
-                  releaseUomValue: undefined
+                  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'
             }
+          })
 
-            data.forEach(data => {
-              let existingOI = orderInventories.find(
-                itm =>
-                  itm.sku == data.sku &&
-                  itm.packing_type == data.packing_type &&
-                  itm.packing_size == data.packing_size &&
-                  itm.uom == data.uom
-              )
-
-              if (existingOI) {
-                existingOI.release_qty = existingOI.release_qty + data.release_qty
+          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 as any).createdBy
+            delete releaseGood.updatedAt
+            delete (releaseGood as any).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 {
-                orderInventories.push(data)
+                data = [
+                  {
+                    sku: itm.product.sku,
+                    packingType: itm.packingType,
+                    packingSize: itm.packingSize,
+                    uom: itm.uom,
+                    releaseQty: itm.releaseQty,
+                    assignedQty: undefined,
+                    assignedUomValue: undefined,
+                    releaseUomValue: itm.releaseUomValue
+                  }
+                ]
               }
-            })
-          }
-          try {
-            await getConnection().transaction(async (childTx: EntityManager) => {
-              let availableItems: any[] = await bulkReleaseGoodsAvailableItemsFunction(
-                orderInventories,
-                draftOrder.bizplace.id,
-                context,
-                childTx
-              )
-
-              if (availableItems.some(item => !item.release_qty || item.release_qty > 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.release_qty
+              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 })
                 }
               })
-
-              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 }
+            }
+            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) }
+                  })
+                }
 
-              createdReleaseGood = await confirmReleaseGood(createdReleaseGood.name, context, childTx)
-            })
-          } catch (error) {
-            console.error(error)
+                // update orderInventories if availableItems are valid
+                ;(releaseGood as any).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 }
+                  )
+                createdReleaseGood = await confirmReleaseGood(createdReleaseGood.name, context, childTx)
+              })
+            } catch (error) {
+              console.error(error)
+            }
           }
-        }
+        })
       }
     }
 
@@ -437,7 +447,7 @@ export async function createDraftReleaseGoodFunction(
   context: any,
   tx?: EntityManager
 ): Promise<DraftReleaseGood> {
-  const { domain, user }: { domain: Domain; user: User } = context.state
+  const { domain, user } = context.state
 
   let myBizplace: Bizplace
   let orderNo: string = ''
@@ -463,7 +473,7 @@ export async function createDraftReleaseGoodFunction(
   // // find DRO number rule setting
   const droNoSetting: Setting = await settingRepo.findOne({
     where: {
-      domain,
+      domain: { id: domain.id },
       name: ORDER_NUMBER_SETTING_KEY.DO_NUMBER_RULE
     }
   })
@@ -474,7 +484,21 @@ export async function createDraftReleaseGoodFunction(
     orderNo = OrderNoGenerator.draftReleaseGood()
   }
 
-  // // 1. Create draft release good
+  // // 1. Create shipping order if found
+  if (shippingOrder) {
+    let newShippingOrder: ShippingOrder = await tx.getRepository(ShippingOrder).save({
+      ...shippingOrder,
+      name: OrderNoGenerator.shippingOrder(),
+      domain,
+      bizplace: draftReleaseGood.bizplace,
+      status: ORDER_STATUS.PENDING,
+      creator: user,
+      updater: user
+    })
+    draftReleaseGood.shippingOrder = newShippingOrder
+  }
+
+  // // 2. Create draft release good
   const createdDraftReleaseGood: DraftReleaseGood = await tx.getRepository(DraftReleaseGood).save({
     ...draftReleaseGood,
     name: orderNo,
@@ -484,7 +508,7 @@ export async function createDraftReleaseGoodFunction(
     updater: user
   })
 
-  // // 2. Create draft release good product
+  // // 3. Create draft release good product
   await upsertDraftReleaseGoodProducts(
     domain,
     draftReleaseGood.bizplace,
@@ -494,7 +518,7 @@ export async function createDraftReleaseGoodFunction(
     tx
   )
 
-  // // 3. Create Attachments
+  // // 4. Create Attachments
   if (files?.length) {
     const attachments: Attachment[] = files.map(attachment => {
       return {
@@ -519,7 +543,7 @@ export async function updateDraftReleaseGoodFunction(
   context: any,
   tx?: EntityManager
 ): Promise<DraftReleaseGood> {
-  const { domain, user }: { domain: Domain; user: User } = context.state
+  const { domain, user } = context.state
 
   let existingDraftReleaseGood: any = await getDraftReleaseGoodFunction(_, draftReleaseGood.name, context, tx)
 
@@ -560,7 +584,7 @@ export async function updateDraftReleaseGoodFunction(
     ...existingDraftReleaseGood,
     ...draftReleaseGood,
     domain,
-    creator: user,
+    creator: existingDraftReleaseGood.creator,
     updater: user
   })
 
@@ -570,7 +594,7 @@ export async function updateDraftReleaseGoodFunction(
   // // 3. Remove Purchase Order Attachment
   const foundAttachments: Attachment[] = await getRepository(Attachment).find({
     where: {
-      domain,
+      domain: { id: domain.id },
       refBy: draftReleaseGood.id,
       category: ATTACHMENT_TYPE.DGRN
     }
@@ -636,7 +660,8 @@ export async function upsertDraftReleaseGoodProducts(
 
     if (removeOP.length > 0) await orderProductRepo.delete(removeOP.map(itm => itm.id))
 
-    bizplace = await bizplaceRepo.findOne(bizplace.id, {
+    bizplace = await bizplaceRepo.findOne({
+      where: { id: bizplace.id },
       relations: ['domain', 'company', 'company.domain']
     })