@things-factory/sales-base 4.3.638 → 4.3.642

package/server/service/order-product/order-product-types.ts

@@ -132,25 +132,25 @@ export class OrderProductPatch {
   @Field(type => Float, { nullable: true })
   unpackUomValue: number
 
-  @Field(type => Int, { nullable: true })
+  @Field(type => Float, { nullable: true })
   packQty: number
 
-  @Field(type => Int, { nullable: true })
+  @Field(type => Float, { nullable: true })
   adjustedPackQty: number
 
-  @Field(type => Int, { nullable: true })
+  @Field(type => Float, { nullable: true })
   actualPackQty: number
 
-  @Field(type => Int, { nullable: true })
+  @Field(type => Float, { nullable: true })
   unpackQty: number
 
-  @Field(type => Int, { nullable: true })
+  @Field(type => Float, { nullable: true })
   palletQty: number
 
-  @Field(type => Int, { nullable: true })
+  @Field(type => Float, { nullable: true })
   actualPalletQty: number
 
-  @Field(type => Int, { nullable: true })
+  @Field(type => Float, { nullable: true })
   adjustedPalletQty: number
 
   @Field({ nullable: true })
@@ -162,7 +162,7 @@ export class OrderProductPatch {
   @Field({ nullable: true })
   totalUomValue: string
 
-  @Field(type => Int, { nullable: true })
+  @Field(type => Float, { nullable: true })
   releaseQty: number
 
   @Field(type => Float, { nullable: true })
@@ -282,37 +282,37 @@ export class NewOrderProduct {
   @Field(type => Float, { nullable: true })
   unpackUomValue: number
 
-  @Field(type => Int, { nullable: true })
+  @Field(type => Float, { nullable: true })
   packQty: number
 
-  @Field(type => Int, { nullable: true })
+  @Field(type => Float, { nullable: true })
   adjustedPackQty: number
 
-  @Field(type => Int, { nullable: true })
+  @Field(type => Float, { nullable: true })
   actualPackQty: number
 
-  @Field(type => Int, { nullable: true })
+  @Field(type => Float, { nullable: true })
   unpackQty: number
 
-  @Field(type => Int, { nullable: true })
+  @Field(type => Float, { nullable: true })
   palletQty: number
 
-  @Field(type => Int, { nullable: true })
+  @Field(type => Float, { nullable: true })
   actualPalletQty: number
 
-  @Field(type => Int, { nullable: true })
+  @Field(type => Float, { nullable: true })
   adjustedPalletQty: number
 
   @Field({ nullable: true })
-  palletId: string
+  adjustedTotalUomValue: string
 
   @Field({ nullable: true })
-  adjustedTotalUomValue: string
+  palletId: string
 
   @Field({ nullable: true })
   totalUomValue: string
 
-  @Field(type => Int, { nullable: true })
+  @Field(type => Float, { nullable: true })
   releaseQty: number
 
   @Field(type => Float, { nullable: true })

package/server/service/order-product/order-product.ts

@@ -254,25 +254,101 @@ export class OrderProduct {
   @Field({ nullable: true })
   adjustedUomValue: number
 
-  @Column('float', { nullable: true })
+  @Column({
+    nullable: true,
+    type: 'decimal',
+    scale: 3,
+    transformer: {
+      to: (value: string | null) => value,
+      from: (value: string | null) => {
+        if (value === null || value === undefined) return null
+        const parsed = parseFloat(value)
+        return isNaN(parsed) ? null : parsed
+      }
+    }
+  })
+  @Field({ nullable: true })
+  unpackQty: number
+
+  @Column({
+    nullable: true,
+    type: 'decimal',
+    scale: 3,
+    transformer: {
+      to: (value: string | null) => value,
+      from: (value: string | null) => {
+        if (value === null || value === undefined) return null
+        const parsed = parseFloat(value)
+        return isNaN(parsed) ? null : parsed
+      }
+    }
+  })
   @Field({ nullable: true })
   unpackUomValue: number
 
-  @Column()
-  @Field()
+  @Column({
+    nullable: true,
+    type: 'decimal',
+    scale: 3,
+    transformer: {
+      to: (value: string | null) => value,
+      from: (value: string | null) => {
+        if (value === null || value === undefined) return null
+        const parsed = parseFloat(value)
+        return isNaN(parsed) ? null : parsed
+      }
+    }
+  })
+  @Field({ nullable: true })
   packQty: number
 
-  @Column({ nullable: true })
+  @Column({
+    nullable: true,
+    type: 'decimal',
+    scale: 3,
+    transformer: {
+      to: (value: string | null) => value,
+      from: (value: string | null) => {
+        if (value === null || value === undefined) return null
+        const parsed = parseFloat(value)
+        return isNaN(parsed) ? null : parsed
+      }
+    }
+  })
   @Field({ nullable: true })
   adjustedPackQty: number
 
-  @Column({ nullable: true })
+  @Column({
+    nullable: true,
+    type: 'decimal',
+    scale: 3,
+    transformer: {
+      to: (value: string | null) => value,
+      from: (value: string | null) => {
+        if (value === null || value === undefined) return null
+        const parsed = parseFloat(value)
+        return isNaN(parsed) ? null : parsed
+      }
+    }
+  })
   @Field({ nullable: true })
   actualPackQty: number
 
-  @Column('float', { nullable: true })
+  @Column({
+    nullable: true,
+    type: 'decimal',
+    scale: 3,
+    transformer: {
+      to: (value: string | null) => value,
+      from: (value: string | null) => {
+        if (value === null || value === undefined) return null
+        const parsed = parseFloat(value)
+        return isNaN(parsed) ? null : parsed
+      }
+    }
+  })
   @Field({ nullable: true })
-  unpackQty: number
+  releaseUomValue: number
 
   @Column('float', { nullable: true })
   @Field({ nullable: true })
@@ -326,14 +402,22 @@ export class OrderProduct {
   @Field({ nullable: true })
   adjustedTotalUomValue: string
 
-  @Column({ nullable: true })
+  @Column({
+    nullable: true,
+    type: 'decimal',
+    scale: 3,
+    transformer: {
+      to: (value: string | null) => value,
+      from: (value: string | null) => {
+        if (value === null || value === undefined) return null
+        const parsed = parseFloat(value)
+        return isNaN(parsed) ? null : parsed
+      }
+    }
+  })
   @Field({ nullable: true })
   releaseQty: number
 
-  @Column({ nullable: true, type: 'float' })
-  @Field({ nullable: true })
-  releaseUomValue: number
-
   @Column({ nullable: true })
   @Field({ nullable: true })
   remark: string

package/server/service/order-tote-item/order-tote-item-types.ts

@@ -1,4 +1,4 @@
-import { Field, InputType, Int, ObjectType } from 'type-graphql'
+import { Field, Float, InputType, Int, ObjectType } from 'type-graphql'
 
 import { ObjectRef } from '@things-factory/shell'
 
@@ -30,7 +30,7 @@ export class NewOrderToteItem {
   @Field(type => ObjectRef, { nullable: true })
   orderTote: ObjectRef
 
-  @Field(type => Int)
+  @Field(type => Float, { nullable: true })
   qty: number
 }
 
@@ -51,6 +51,6 @@ export class OrderToteItemPatch {
   @Field(type => ObjectRef, { nullable: true })
   orderTote: ObjectRef
 
-  @Field(type => Int)
+  @Field(type => Float, { nullable: true })
   qty: number
 }

package/server/service/order-tote-item/order-tote-item.ts

@@ -47,7 +47,20 @@ export class OrderToteItem {
   @RelationId((orderToteItem: OrderToteItem) => orderToteItem.orderTote)
   orderToteId: string
 
-  @Column('int')
+  @Column({
+    type: 'decimal',
+    scale: 3,
+    default: 0,
+    nullable: true,
+    transformer: {
+      to: (value: string | null) => value,
+      from: (value: string | null) => {
+        if (value === null || value === undefined) return null
+        const parsed = parseFloat(value)
+        return isNaN(parsed) ? null : parsed
+      }
+    }
+  })
   @Field({ nullable: true })
   qty?: number
 

package/server/service/others/other-query.ts

@@ -212,11 +212,11 @@ export class OtherQuery {
         productDetail: availableItem ? { id: availableItem.productDetailId } : null,
         inventory: availableItem
           ? {
-              ...availableItem,
-              remainQty: availableItem ? availableItem.remainQty : null,
-              remainUomValue: availableItem ? availableItem.remainUomValue : null,
-              remainUomValueWithUom: availableItem ? availableItem.remainUomValueWithUom : ''
-            }
+          ...availableItem,
+          remainQty: availableItem.remainQty,
+          remainUomValue: availableItem.remainUomValue,
+          remainUomValueWithUom: availableItem.remainUomValueWithUom || ''
+        }
           : null,
         productId: availableItem ? availableItem.productId : null,
         productDetailID: availableItem ? availableItem.productDetailId : null,
@@ -231,13 +231,13 @@ export class OtherQuery {
         packingType: availableItem ? availableItem.packingType : orderInventory.packingType,
         packingSize: availableItem ? availableItem.packingSize : 1,
         releaseQty: orderInventory.releaseQty
-          ? Number.isInteger(orderInventory.releaseQty)
+          ? !Number.isNaN(orderInventory.releaseQty)
             ? orderInventory.releaseQty
             : null
           : null,
         releaseUomValue: availableItem
-          ? Number.isInteger(orderInventory.releaseQty)
-            ? parseFloat((orderInventory.releaseQty * packageUomValue).toFixed(2))
+          ? !Number.isNaN(orderInventory.releaseQty)
+            ? parseFloat((orderInventory.releaseQty * packageUomValue).toFixed(3))
             : null
           : null,
         groupType: availableItem ? availableItem.groupType : null,

package/server/service/others/other-types.ts

@@ -37,22 +37,25 @@ export class InventoryProductGroup {
   @Field({ nullable: true })
   productBrand: string
 
+  @Field({ nullable: true })
+  isInventoryDecimal: boolean
+
   @Field({ nullable: true })
   packingType: string
 
   @Field(type => Float, { nullable: true })
   packingSize: number
 
-  @Field(type => Int, { nullable: true })
+  @Field(type => Float, { nullable: true })
   packQty: number
 
-  @Field(type => Int, { nullable: true })
+  @Field(type => Float, { nullable: true })
   totalQty: number
 
-  @Field(type => Int, { nullable: true })
+  @Field(type => Float, { nullable: true })
   totalLockedQty: number
 
-  @Field(type => Int, { nullable: true })
+  @Field(type => Float, { nullable: true })
   totalLockedUomValue: number
 
   @Field(type => Int, { nullable: true })

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

@@ -64,6 +64,41 @@ import { ShippingOrderPatch } from '../shipping-order/shipping-order-types'
 import { editVas } from '../vas'
 import { ReleaseGood } from './release-good'
 import { bulkReleaseGoodsAvailableItemsFunction } from './release-good-query'
+import { getTmsService } from '@things-factory/integration-lmd'
+
+// Utility function for safe decimal arithmetic
+function safeDecimalOperation(value1: number, value2: number, operation: 'add' | 'subtract' | 'multiply'): number {
+  // Convert to string with fixed precision to avoid floating point issues
+  const num1 = parseFloat(value1.toFixed(3))
+  const num2 = parseFloat(value2.toFixed(3))
+
+  let result: number
+  switch (operation) {
+    case 'add':
+      result = num1 + num2
+      break
+    case 'subtract':
+      result = num1 - num2
+      break
+    case 'multiply':
+      result = num1 * num2
+      break
+    default:
+      throw new Error('Invalid operation')
+  }
+
+  // Ensure result is within valid range and has correct precision
+  if (result < 0) {
+    throw new Error('Decimal value cannot be negative')
+  }
+
+  // Check if result exceeds maximum precision (10 digits total with 3 decimal places)
+  if (result > 9999999.999) {
+    throw new Error('Decimal value exceeds maximum allowed precision')
+  }
+
+  return parseFloat(result.toFixed(3))
+}
 
 @Resolver(ReleaseGood)
 export class ReleaseGoodMutation {
@@ -444,8 +479,8 @@ export async function deleteReleaseGood(tx: EntityManager, name: string, user: U
 
         await tx.getRepository(Inventory).save({
           ...oi.inventory,
-          lockedQty: oi.inventory.lockedQty - oi.releaseQty,
-          lockedUomValue: oi.inventory.lockedUomValue - oi.releaseUomValue,
+          lockedQty: safeDecimalOperation(oi.inventory.lockedQty, oi.releaseQty, 'subtract'),
+          lockedUomValue: safeDecimalOperation(oi.inventory.lockedUomValue, oi.releaseUomValue, 'subtract'),
           updater: user
         })
       }
@@ -539,6 +574,11 @@ export async function generateReleaseGoodFunction(
     let warehouseDomain: Domain = domain
     let finalOrderInventories: OrderInventory[] = []
 
+    /** Validate for b2b order that uses LMD */
+    if (releaseGood.type === 'b2b' && !releaseGood.ownTransport) {
+      releaseGood = await validateB2BLmdOrder(releaseGood, warehouseDomain, tx, shippingOrderInfo)
+    }
+
     /** Validate user permitted Bizplace */
     if (releaseGood.warehouseId) {
       bizplace = await getOutletBizplace(releaseGood.warehouseId)
@@ -669,9 +709,10 @@ export async function generateReleaseGoodFunction(
     let lmd: any = null
     if (releaseGood?.lmdOption) {
       const geoCountryRepo: Repository<GeoCountry> = tx?.getRepository(GeoCountry) || getRepository(GeoCountry)
-      let deliveryCountry: GeoCountry = releaseGood?.country
+      const countryNameOrDescription: string = releaseGood?.country || shippingOrderInfo?.country // shippingOrderInfo?.country when using lmd/tms for b2b orders
+      let deliveryCountry: GeoCountry = countryNameOrDescription
         ? await geoCountryRepo.findOne({
-            where: [{ name: ILike(releaseGood?.country) }, { description: ILike(releaseGood?.country) }]
+            where: [{ name: ILike(countryNameOrDescription) }, { description: ILike(countryNameOrDescription) }]
           })
         : null
 
@@ -806,8 +847,12 @@ export async function generateReleaseGoodFunction(
           pbSettings.forEach(pbs => {
             splitOI = {
               ...oi,
-              releaseQty: oi.releaseQty * pbs.bundleQty,
-              releaseUomValue: oi.releaseUomValue * pbs.bundleQty * pbs.product.primaryValue,
+              releaseQty: safeDecimalOperation(oi.releaseQty, pbs.bundleQty, 'multiply'),
+              releaseUomValue: safeDecimalOperation(
+                safeDecimalOperation(oi.releaseUomValue, pbs.bundleQty, 'multiply'),
+                pbs.product.primaryValue,
+                'multiply'
+              ),
               packingType: pbs.product.packingType,
               batchId: '',
               product: {
@@ -1313,6 +1358,16 @@ export async function receiveReleaseGood(name: string, context: any, tx: EntityM
     await tx.getRepository(OrderVas).save(foundOVs)
   }
 
+  if (foundReleaseGood?.lmdOption && foundReleaseGood?.lastMileDelivery?.isTms) {
+    const lastMileDeliveries: LastMileDelivery = foundReleaseGood.lastMileDelivery
+
+    let data = foundReleaseGood
+
+    const tmsService = getTmsService(lastMileDeliveries?.platform)
+
+    tmsService.createShipment([data])
+  }
+
   // notification logics
   // get Office Admin Users
   if (context?.state?.type != 'api') {
@@ -1397,8 +1452,8 @@ export async function rejectReleaseGood(
 
             await tx.getRepository(Inventory).save({
               ...oi.inventory,
-              lockedQty: oi.inventory.lockedQty - oi.releaseQty,
-              lockedUomValue: oi.inventory.lockedUomValue - oi.releaseUomValue,
+              lockedQty: safeDecimalOperation(oi.inventory.lockedQty, oi.releaseQty, 'subtract'),
+              lockedUomValue: safeDecimalOperation(oi.inventory.lockedUomValue, oi.releaseUomValue, 'subtract'),
               updater: user
             })
           }
@@ -1530,6 +1585,10 @@ export async function bulkGenerateReleaseGood(
         })
       : null
 
+    if (releaseGood.type == 'b2b') {
+      releaseGood = await validateB2BLmdOrder(releaseGood, domain, tx)
+    }
+
     let lmd: any = null
     if (releaseGood?.lmdOption) {
       //Assign LMD
@@ -1773,7 +1832,7 @@ export async function bulkConfirmOrReceiveReleaseGoods(
 ): Promise<ReleaseGood[]> {
   let foundReleaseGoods: ReleaseGood[] = await tx.getRepository(ReleaseGood).find({
     where: { name: In(releaseGoodsNo), status: ORDER_STATUS.PENDING },
-    relations: ['bizplace']
+    relations: ['bizplace', 'lastMileDelivery']
   })
 
   if (!foundReleaseGoods.length) throw new Error(`release good order doesn't exists.`)
@@ -1837,16 +1896,27 @@ export async function bulkConfirmOrReceiveReleaseGoods(
     }
   }
 
-  return Promise.all(
-    foundReleaseGoods.map(async (releaseGood: ReleaseGood) => {
-      return {
-        ...releaseGood,
-        orderInventories: await tx.getRepository(OrderInventory).find({ where: releaseGood }),
-        status: orderStatus,
-        updater: user
-      }
-    })
-  )
+  let roTMS: ReleaseGood[] = foundReleaseGoods.filter(rg => {
+    rg.lastMileDelivery?.isTms && rg.lmdOption
+  })
+
+  if (roTMS?.length) {
+    const tmsService = getTmsService(roTMS[0].lastMileDelivery?.platform)
+
+    tmsService.createShipment(roTMS)
+  }
+
+  if (foundReleaseGoods)
+    return Promise.all(
+      foundReleaseGoods.map(async (releaseGood: ReleaseGood) => {
+        return {
+          ...releaseGood,
+          orderInventories: await tx.getRepository(OrderInventory).find({ where: releaseGood }),
+          status: orderStatus,
+          updater: user
+        }
+      })
+    )
 }
 
 function extractRawReleaseGoods(rawReleaseGoods): Partial<ReleaseGood[]> {
@@ -1889,7 +1959,11 @@ function extractRawReleaseGoods(rawReleaseGoods): Partial<ReleaseGood[]> {
 
       // if there is duplicated SKU, merge them and sum up the releaseQty
       if (duplicateSkuIdx >= 0) {
-        releaseGoods[idx].orderInventories[duplicateSkuIdx].releaseQty += item.releaseQty
+        releaseGoods[idx].orderInventories[duplicateSkuIdx].releaseQty = safeDecimalOperation(
+          releaseGoods[idx].orderInventories[duplicateSkuIdx].releaseQty,
+          item.releaseQty,
+          'add'
+        )
       } else {
         releaseGoods[idx].orderInventories.push({
           sku: item.sku,
@@ -1897,8 +1971,8 @@ function extractRawReleaseGoods(rawReleaseGoods): Partial<ReleaseGood[]> {
           packingType: item.packingType,
           packingSize: item.packingSize,
           uom: item.uom,
-          releaseQty: item.releaseQty,
-          releaseUomValue: item.releaseUomValue
+          releaseQty: Math.round(parseFloat(item.releaseQty) * 1000) / 1000,
+          releaseUomValue: Math.round(parseFloat(item.releaseUomValue) * 1000) / 1000,
         })
       }
     } else {
@@ -2050,3 +2124,55 @@ async function autoAssignLmd(domain, countryId, postalCode, bizplace) {
 
   return lmdResult
 }
+
+async function validateB2BLmdOrder(releaseGood, domain, tx, shippingOrderInfo?) {
+  const tms: LastMileDelivery = await tx.getRepository(LastMileDelivery).find({
+    where: { domain, status: 'active', isTms: true }
+  })
+
+  if (tms.length > 0) {
+    const checkShipmentFields = shippingOrderInfo => {
+      if (
+        !shippingOrderInfo?.deliveryAddress1 &&
+        !shippingOrderInfo?.postalCode &&
+        !shippingOrderInfo?.state &&
+        !shippingOrderInfo?.city &&
+        !shippingOrderInfo?.attentionTo &&
+        !shippingOrderInfo?.phone1
+      ) {
+        throw new Error('please fill in the shipping information in shipment tab')
+      }
+
+      if (!shippingOrderInfo?.attentionTo) {
+        throw new Error('attention to is empty please fill in the data before proceed create order')
+      }
+
+      if (!shippingOrderInfo?.postalCode) {
+        throw new Error('zip/postal code is empty please fill in the data before proceed create order')
+      }
+
+      if (!shippingOrderInfo?.state) {
+        throw new Error('state is empty please fill in the data before proceed create order')
+      }
+
+      if (!shippingOrderInfo?.city) {
+        throw new Error('city is empty please fill in the data before proceed create order')
+      }
+
+      if (!shippingOrderInfo?.deliveryAddress1) {
+        throw new Error('delivery address is empty please fill in the data before proceed create order')
+      }
+
+      if (!shippingOrderInfo?.phone1) {
+        throw new Error('contact is empty please fill in the data before proceed create order')
+      }
+    }
+
+    checkShipmentFields(shippingOrderInfo)
+    releaseGood.lmdOption = true
+
+    return releaseGood
+  }
+
+  return releaseGood
+}