@things-factory/sales-base 4.3.113-alpha.0 → 4.3.114

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

@@ -17,7 +17,7 @@ import { MarketplaceStore } from '@things-factory/integration-marketplace'
 import { Sellercraft, SellercraftStatus } from '@things-factory/integration-sellercraft'
 import { MarketplaceOrder, MarketplaceProductVariation } from '@things-factory/marketplace-base'
 // import { sendNotification } from '@things-factory/notification'
-import { Product, ProductBundleSetting, ProductDetail } from '@things-factory/product-base'
+import { Product, ProductBundleSetting } from '@things-factory/product-base'
 import { PartnerSetting, Setting } from '@things-factory/setting-base'
 import { Domain } from '@things-factory/shell'
 import { Inventory } from '@things-factory/warehouse-base'
@@ -126,17 +126,41 @@ export class ReleaseGoodMutation {
     }
 
     let confirmedReleaseGoods: ReleaseGood[] = []
+    await getConnection().transaction(async (childTx: EntityManager) => {
+      if (createdReleaseGoods.length)
+        try {
+          const bizplace: Bizplace = await childTx.getRepository(Bizplace).findOne({
+            where: { id: bizplaceId },
+            relations: ['domain']
+          })
 
-    if (createdReleaseGoods.length)
-      try {
-        confirmedReleaseGoods = await bulkConfirmReleaseGoods(
-          createdReleaseGoods.map(rg => rg.name),
-          domain,
-          user,
-          context,
-          tx
-        )
-      } catch (error) { }
+          const directReceiveSetting: Setting = await childTx.getRepository(Setting).findOne({
+            where: { domain, category: 'id-rule', name: 'enable-direct-receive-release-order' }
+          })
+
+          const partnerDirectReceiveSetting: PartnerSetting = await childTx.getRepository(PartnerSetting).findOne({
+            where: { setting: directReceiveSetting, domain, partnerDomain: bizplace?.domain }
+          })
+
+          let partnerDirectReceiveSettingValue = parseFloat(partnerDirectReceiveSetting?.value)
+
+          // If status of create RO is PENDING then directly CONFIRM -> RECEIVE
+          if (
+            !isNaN(partnerDirectReceiveSetting?.value) &&
+            !isNaN(parseFloat(partnerDirectReceiveSetting?.value)) &&
+            partnerDirectReceiveSettingValue > 0
+          ) {
+            confirmedReleaseGoods = await bulkConfirmOrReceiveReleaseGoods(
+              createdReleaseGoods.map(rg => rg.name),
+              domain,
+              user,
+              context,
+              partnerDirectReceiveSettingValue,
+              childTx
+            )
+          }
+        } catch (error) {}
+    })
 
     if (errorsCaught.length)
       throw new ValidationError({
@@ -628,8 +652,8 @@ export async function generateReleaseGoodFunction(
       orderMethod: releaseGood?.orderMethod
         ? releaseGood.orderMethod
         : releaseGood.orderInventories[0]?.inventory?.id
-          ? ORDER_METHOD.SELECT_BY_PALLET
-          : ORDER_METHOD.SELECT_BY_PRODUCT,
+        ? ORDER_METHOD.SELECT_BY_PALLET
+        : ORDER_METHOD.SELECT_BY_PRODUCT,
       status: ORDER_STATUS.PENDING,
       packageId: releaseGood?.packageId,
       storeName: releaseGood?.storeName,
@@ -676,7 +700,7 @@ export async function generateReleaseGoodFunction(
 
           const pbSettings: ProductBundleSetting[] = await tx.getRepository(ProductBundleSetting).find({
             where: { productBundle: oi.product.id },
-            relations: ['product', 'productBundle', 'productDetail']
+            relations: ['product', 'productBundle']
           })
 
           pbSettings.forEach(pbs => {
@@ -690,9 +714,6 @@ export async function generateReleaseGoodFunction(
                 id: pbs.product.id,
                 name: pbs.product.name,
                 groupType: PRODUCT_GROUP_TYPE.SINGLE
-              },
-              productDetail: {
-                id: pbs.productDetail.id
               }
             }
             splitBundleOIs.push(splitOI)
@@ -707,10 +728,6 @@ export async function generateReleaseGoodFunction(
     newReleaseGood = await tx.getRepository(ReleaseGood).save(newReleaseGood)
 
     for (let oi of orderInventories) {
-      let productDetail: any = await tx
-        .getRepository(ProductDetail)
-        .findOne(oi.productDetail.id, { relations: ['product'] })
-
       let newOrderInv: OrderInventory = Object.assign({}, oi)
       newOrderInv = {
         ...newOrderInv,
@@ -719,8 +736,7 @@ export async function generateReleaseGoodFunction(
         status: ORDER_INVENTORY_STATUS.PENDING,
         name: OrderNoGenerator.orderInventory(),
         releaseGood: newReleaseGood,
-        product: productDetail.product,
-        productDetail,
+        product: await tx.getRepository(Product).findOne(oi.product.id),
         creator: user,
         updater: user
       }
@@ -758,9 +774,9 @@ export async function generateReleaseGoodFunction(
         }
 
         let assignedOrderInventories: OrderInventory[] = await InventoryUtil.autoAssignInventoryForRelease(
+          newOrderInv.product,
           oi,
-          productDetail.product,
-          productDetail,
+          oi.packingType,
           locationSortingRules,
           bizplace,
           warehouseDomain,
@@ -1387,17 +1403,12 @@ export async function bulkGenerateReleaseGood(
         }
       }
 
-      let productDetail = oi.orderProduct?.productDetail
-      let product = oi.orderProduct?.product
-      if (!productDetail) {
-        productDetail = await tx.getRepository(ProductDetail).findOne(oi.productDetailId, { relations: ['product'] })
-        product = productDetail.product
-      }
+      const product: Product = await tx.getRepository(Product).findOne(oi.productId)
 
       let assignedResult = await InventoryUtil.autoAssignInventoryForRelease(
-        oi,
         product,
-        productDetail,
+        oi,
+        oi.packingType,
         locationSortingRules,
         bizplace,
         warehouseDomain,
@@ -1476,11 +1487,12 @@ export async function bulkGenerateReleaseGood(
   }
 }
 
-export async function bulkConfirmReleaseGoods(
+export async function bulkConfirmOrReceiveReleaseGoods(
   releaseGoodsNo: string[],
   domain: Domain,
   user: User,
   context: any,
+  partnerDirectReceiveSettingValue: Number,
   tx?: EntityManager
 ): Promise<ReleaseGood[]> {
   let foundReleaseGoods: ReleaseGood[] = await tx.getRepository(ReleaseGood).find({
@@ -1495,15 +1507,20 @@ export async function bulkConfirmReleaseGoods(
     where: { domain, releaseGood: In(foundReleaseGoods.map((rg: ReleaseGood) => rg.id)) }
   })
 
+  let orderStatus =
+    partnerDirectReceiveSettingValue == 1 ? ORDER_STATUS.PENDING_RECEIVE : ORDER_STATUS.PENDING_WORKSHEET
+
+  let orderInventoryStatus = partnerDirectReceiveSettingValue == 1 ? ORDER_INVENTORY_STATUS.PENDING_RECEIVE : ORDER_INVENTORY_STATUS.PENDING_WORKSHEET
+
   await tx
     .getRepository(ReleaseGood)
-    .update({ id: In(foundReleaseGoods.map(rg => rg.id)) }, { status: ORDER_STATUS.PENDING_RECEIVE, updater: user })
+    .update({ id: In(foundReleaseGoods.map(rg => rg.id)) }, { status: orderStatus, updater: user })
 
   await tx
     .getRepository(OrderInventory)
     .update(
       { id: In(foundOrderInventories.map(oi => oi.id)) },
-      { status: ORDER_INVENTORY_STATUS.PENDING_RECEIVE, updater: user }
+      { status: orderInventoryStatus, updater: user }
     )
 
   if (context?.state?.type != 'api') {
@@ -1549,7 +1566,7 @@ export async function bulkConfirmReleaseGoods(
       return {
         ...releaseGood,
         orderInventories: await tx.getRepository(OrderInventory).find({ where: releaseGood }),
-        status: ORDER_STATUS.PENDING_RECEIVE,
+        status: orderStatus,
         updater: user
       }
     })

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

@@ -133,6 +133,7 @@ export class ReleaseGoodQuery {
           'orderInventories.product',
           'orderInventories.inventory',
           'orderInventories.inventory.product',
+          'orderInventories.inventory.product.productDetails',
           'orderVass',
           'orderVass.vas',
           'creator',
@@ -196,7 +197,6 @@ export class ReleaseGoodQuery {
           .createQueryBuilder('oi')
           .leftJoinAndSelect('oi.inventory', 'inventory')
           .leftJoinAndSelect('oi.product', 'product')
-          .leftJoinAndSelect('oi.productDetail', 'productDetail')
           .leftJoinAndSelect('inventory.location', 'location')
           .where('oi.domain_id = :domainId', { domainId: domain.id })
           .andWhere('oi.release_good_id = :releaseGoodId', { releaseGoodId: releaseGood.id })
@@ -227,7 +227,6 @@ export class ReleaseGoodQuery {
                 batchIdRef: inventory.batchIdRef,
                 palletId: inventory.palletId,
                 product: orderInv.product,
-                productDetail: orderInv.productDetail,
                 productIdRef: orderInv.product.id,
                 productName: `${orderInv.product.name} (${orderInv.product.description})`,
                 packingType: orderInv.packingType,
@@ -769,7 +768,7 @@ export async function bulkReleaseGoodsAvailableItemsFunction(
           sku VARCHAR(150),
           product_info VARCHAR(250),
           packing_type VARCHAR(50),
-          packing_size INT,
+          packing_size FLOAT,
           uom VARCHAR(10),
           release_qty INT
         );
@@ -784,18 +783,18 @@ export async function bulkReleaseGoodsAvailableItemsFunction(
         js.sku,
         CASE WHEN p.description NOT IN (NULL, '', '-') THEN CONCAT(p.name, '(', p.description, ')')
           ELSE p.name END AS product_info,
-        CASE WHEN js.packing_type NOTNULL AND js.packing_size NOTNULL THEN js.packing_type ELSE pd.packing_type END,
-        CASE WHEN js.packing_type NOTNULL AND js.packing_size NOTNULL THEN js.packing_size ELSE pd.packing_size END,
-        CASE WHEN js.uom NOTNULL THEN js.uom ELSE pd.uom END
+        pd.packing_type,
+        pd.packing_size,
+        pd.uom
         FROM JSON_POPULATE_RECORDSET(NULL::raw_release_goods, $1) js
         LEFT JOIN products p ON LOWER(js.sku) = LOWER(p.sku) AND p.bizplace_id = $2
         LEFT JOIN product_details pd ON p.id = pd.product_id
         AND CASE WHEN js.packing_type NOTNULL AND js.packing_size NOTNULL AND js.uom NOTNULL
-          THEN pd.packing_type = js.packing_type AND pd.packing_size = js.packing_size AND pd.uom = js.uom 
+          THEN LOWER(pd.packing_type) = LOWER(js.packing_type) AND pd.packing_size = js.packing_size AND LOWER(pd.uom) = LOWER(js.uom) 
           WHEN js.packing_type NOTNULL AND js.packing_size NOTNULL AND js.uom ISNULL 	
-            THEN pd.packing_type = js.packing_type AND pd.packing_size = js.packing_size AND pd.is_default IS TRUE
+            THEN LOWER(pd.packing_type) = LOWER(js.packing_type) AND pd.packing_size = js.packing_size AND pd.is_default IS TRUE
             WHEN js.packing_type ISNULL AND js.packing_size ISNULL AND js.uom NOTNULL
-              THEN pd.uom = js.uom AND pd.is_default IS TRUE ELSE pd.is_default IS TRUE 
+              THEN LOWER(pd.uom) = LOWER(js.uom) AND pd.is_default IS TRUE ELSE pd.is_default IS TRUE 
         END;
       `,
     [json_oi, companyBizplaceId.id]
@@ -945,6 +944,8 @@ function _extractData(rawData, validatedData) {
           ? 'backdate is not allowed'
           : !raw.refNo
           ? 'ref no is empty'
+          : !Number.isInteger(raw.packingSize)
+          ? 'packing size must be an integer'
           : ''
     }
   })

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

@@ -1,6 +1,6 @@
 import { Field, Float, InputType, Int, ObjectType } from 'type-graphql'
 
-import { Product, ProductDetail } from '@things-factory/product-base'
+import { Product } from '@things-factory/product-base'
 import { ObjectRef } from '@things-factory/shell'
 import { Location } from '@things-factory/warehouse-base'
 
@@ -77,9 +77,6 @@ export class InventoryInfos {
   @Field(type => Product, { nullable: true })
   product?: Product
 
-  @Field(type => ProductDetail, { nullable: true })
-  productDetail?: ProductDetail
-
   @Field({ nullable: true })
   packingType?: string
 
@@ -188,6 +185,8 @@ export class NewReleaseGood {
   @Field({ nullable: true })
   orderMethod: string
 
+
+
   @Field({ nullable: true })
   collectionOrderNo: string
 

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

@@ -488,6 +488,16 @@ export class ReleaseGood {
   @RelationId((releaseGood: ReleaseGood) => releaseGood.manifestedBy)
   manifestedById: string
 
+  @ManyToOne(type => User)
+  @Field(type => User, { nullable: true })
+  sortedBy: User
+
+  @RelationId((releaseGood: ReleaseGood) => releaseGood.sortedBy)
+  sortedById: string
+
+  @Field({ nullable: true })
+  sortedByUser: String
+
   @Field({ nullable: true })
   orderRemark: Boolean
 

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

@@ -6,7 +6,7 @@ import { Attachment, createAttachments } from '@things-factory/attachment-base'
 import { Role, User } from '@things-factory/auth-base'
 import { Bizplace, getDomainUsers } from '@things-factory/biz-base'
 import { sendNotification } from '@things-factory/notification'
-import { Product, ProductDetail } from '@things-factory/product-base'
+import { Product } from '@things-factory/product-base'
 import { Domain } from '@things-factory/shell'
 import { Inventory } from '@things-factory/warehouse-base'
 
@@ -59,7 +59,6 @@ export class ReturnOrderMutation {
         itm =>
           itm.product.id === curr.product.id &&
           itm.packingType === curr.packingType &&
-          itm.productDetailId === curr.product.productDetailId &&
           itm.batchId === curr.batchId &&
           itm.packingSize === curr.packingSize
       )
@@ -69,7 +68,6 @@ export class ReturnOrderMutation {
       } else {
         existingItem.returnQty = existingItem.returnQty + curr.returnQty
         existingItem.returnUomValue = existingItem.returnUomValue + curr.returnUomValue
-        existingItem.remark = `${existingItem.remark} | ${curr.remark}`
       }
 
       return acc
@@ -101,7 +99,6 @@ export class ReturnOrderMutation {
       newOrderInv.name = OrderNoGenerator.orderInventory()
       newOrderInv.returnOrder = createdReturnOrder
       newOrderInv.product = await tx.getRepository(Product).findOne(moi.product.id)
-      newOrderInv.productDetail = await tx.getRepository(ProductDetail).findOne(moi.productDetail.id)
       newOrderInv.creator = user
       newOrderInv.updater = user
 

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

@@ -115,7 +115,6 @@ export class NewReturnOrder {
   @Field({ nullable: true })
   truckNo: string
 
-
   @Field({ nullable: true })
   deliveryOrderNo: string
 

package/server/service/reverse-kitting-order-inventory/reverse-kitting-order-inventory.ts

@@ -12,7 +12,7 @@ import {
 
 import { User } from '@things-factory/auth-base'
 import { Bizplace } from '@things-factory/biz-base'
-import { Product, ProductDetail } from '@things-factory/product-base'
+import { Product } from '@things-factory/product-base'
 import { Domain } from '@things-factory/shell'
 import { Inventory } from '@things-factory/warehouse-base'
 
@@ -127,10 +127,6 @@ export class ReverseKittingOrderInventory {
   @Field({ nullable: true })
   updatedAt?: Date
 
-  @ManyToOne(type => ProductDetail, { nullable: true })
-  @Field({ nullable: true })
-  productDetail: ProductDetail
-
   @ManyToOne(type => User, { nullable: true })
   @Field({ nullable: true })
   creator?: User