@things-factory/sales-base 4.0.37 → 4.0.41

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

@@ -21,17 +21,6 @@ import { PartnerSetting, Setting } from '@things-factory/setting-base'
 import { Domain } from '@things-factory/shell'
 import { Inventory } from '@things-factory/warehouse-base'
 
-import {
-  ArrivalNotice,
-  NewReleaseGood,
-  OrderInventory,
-  OrderProduct,
-  OrderVas,
-  ReleaseGoodPatch,
-  ShippingOrder,
-  ShippingOrderPatch,
-  Vas
-} from '../'
 import {
   ATTACHMENT_TYPE,
   ORDER_INVENTORY_STATUS,
@@ -46,7 +35,15 @@ import {
 import { EcommerceController, SellercraftController } from '../../controllers'
 import { ValidationError } from '../../errors'
 import { InventoryUtil, OrderNoGenerator } from '../../utils'
+import { ArrivalNotice } from '../arrival-notice/arrival-notice'
 import { confirmArrivalNoticeFunction, deleteArrivalNotice } from '../arrival-notice/arrival-notice-mutation'
+import { OrderInventory } from '../order-inventory/order-inventory'
+import { OrderProduct } from '../order-product/order-product'
+import { OrderVas } from '../order-vas/order-vas'
+import { NewReleaseGood, ReleaseGoodPatch } from '../release-good/release-good-types'
+import { ShippingOrder } from '../shipping-order/shipping-order'
+import { ShippingOrderPatch } from '../shipping-order/shipping-order-types'
+import { Vas } from '../vas/vas'
 import { ReleaseGood } from './release-good'
 import { bulkReleaseGoodsAvailableItemsFunction } from './release-good-query'
 
@@ -76,7 +73,7 @@ export class ReleaseGoodMutation {
 
     let releaseGoods: Partial<ReleaseGood[]> = extractRawReleaseGoods(rawReleaseGoods)
 
-    let errorsFound: any[] = []
+    let errorsCaught: any[] = []
     for (let i = 0, l = releaseGoods.length; i < l; i++) {
       // generate release good by group to avoid duplication
       // if this function is called simultaneously by different users
@@ -90,7 +87,7 @@ export class ReleaseGoodMutation {
               domain
             }
           })
-          if (existingReleaseGood) throw new Error('release good order is already exist in the system')
+          if (existingReleaseGood) throw new Error('this order is already exist in the system')
 
           let availableItems: any[] = await bulkReleaseGoodsAvailableItemsFunction(
             [...releaseGoods[i].orderInventories],
@@ -119,25 +116,30 @@ export class ReleaseGoodMutation {
 
           createdReleaseGoods.push(createdReleaseGood)
         })
-      } catch (e) {
-        errorsFound.push(e)
+      } catch (error) {
+        let rawReleaseGoods = formRawReleaseGoods(releaseGoods[i], error.message)
+        errorsCaught.push(...rawReleaseGoods)
       }
     }
 
     let confirmedReleaseGoods: ReleaseGood[] = []
-    try {
-      confirmedReleaseGoods = await bulkConfirmReleaseGoods(
-        createdReleaseGoods.map(rg => rg.name),
-        domain,
-        user,
-        context,
-        tx
-      )
-    } catch (e) {
-      errorsFound.push(e)
-    }
 
-    // if (errorsFound.length) { then ?? }
+    if (createdReleaseGoods.length)
+      try {
+        confirmedReleaseGoods = await bulkConfirmReleaseGoods(
+          createdReleaseGoods.map(rg => rg.name),
+          domain,
+          user,
+          context,
+          tx
+        )
+      } catch (error) {}
+
+    if (errorsCaught.length)
+      throw new ValidationError({
+        ...ValidationError.ERROR_CODES.INVALID_DATA_FOUND,
+        detail: { data: JSON.stringify(errorsCaught) }
+      })
 
     return confirmedReleaseGoods
   }
@@ -815,11 +817,9 @@ export async function confirmReleaseGood(name: string, context: any, tx?: Entity
         if (foundMarketplaceProductVariations) {
           await Promise.all(
             foundMarketplaceProductVariations.map(async variation => {
-              if (variation.marketplaceProduct.marketplaceStore.id != matchedMarketplaceStore.id) {
-                variation.reserveQty -= oi.releaseQty
+              variation.reserveQty -= oi.releaseQty
 
-                await tx.getRepository(MarketplaceProductVariation).save(variation)
-              }
+              await tx.getRepository(MarketplaceProductVariation).save(variation)
             })
           )
         }
@@ -1252,29 +1252,15 @@ export async function bulkConfirmReleaseGoods(
 ): Promise<ReleaseGood[]> {
   let foundReleaseGoods: ReleaseGood[] = await tx.getRepository(ReleaseGood).find({
     where: { name: In(releaseGoodsNo), status: ORDER_STATUS.PENDING },
-    relations: [
-      'domain',
-      'bizplace',
-      'bizplace.domain',
-      'bizplace.company',
-      'bizplace.company.domain',
-      'orderProducts',
-      'orderProducts.product',
-      'orderInventories',
-      'orderInventories.product',
-      'orderVass'
-    ]
+    relations: ['bizplace']
   })
 
   if (!foundReleaseGoods.length) throw new Error(`release good order doesn't exists.`)
   let customerBizplace: Bizplace = foundReleaseGoods[0].bizplace
 
-  let foundOrderInventories: OrderInventory[] = foundReleaseGoods
-    .map((releaseGood: ReleaseGood) => releaseGood.orderInventories)
-    .reduce((orderInventories, currOIs) => {
-      orderInventories.push(...currOIs)
-      return orderInventories
-    }, [])
+  let foundOrderInventories: OrderInventory[] = await tx.getRepository(OrderInventory).find({
+    where: { domain, releaseGood: In(foundReleaseGoods.map((rg: ReleaseGood) => rg.id)) }
+  })
 
   await tx
     .getRepository(ReleaseGood)
@@ -1307,7 +1293,7 @@ export async function bulkConfirmReleaseGoods(
     // send notification to Office Admin Users
     if (users?.length) {
       const receivers: any[] = users.map(user => user.id)
-      const msg = {
+      const message = {
         title: `New Release Order from ${customerBizplace.name}`,
         body: `New incoming bulk release orders are pending for receiving`,
         url: context.header.referer,
@@ -1315,18 +1301,21 @@ export async function bulkConfirmReleaseGoods(
       }
       await sendNotification({
         receivers,
-        message: { ...msg }
+        message
       })
     }
   }
 
-  return foundReleaseGoods.map((releaseGood: ReleaseGood) => {
-    return {
-      ...releaseGood,
-      status: ORDER_STATUS.PENDING_RECEIVE,
-      updater: user
-    }
-  })
+  return Promise.all(
+    foundReleaseGoods.map(async (releaseGood: ReleaseGood) => {
+      return {
+        ...releaseGood,
+        orderInventories: await tx.getRepository(OrderInventory).find({ where: releaseGood }),
+        status: ORDER_STATUS.PENDING_RECEIVE,
+        updater: user
+      }
+    })
+  )
 }
 
 function extractRawReleaseGoods(rawReleaseGoods): Partial<ReleaseGood[]> {
@@ -1413,3 +1402,20 @@ function extractRawReleaseGoods(rawReleaseGoods): Partial<ReleaseGood[]> {
     return releaseGoods
   }, [])
 }
+
+function formRawReleaseGoods(releaseGood, errorMsg) {
+  let rawReleaseGoods = []
+  for (let i = 0, l = releaseGood.orderInventories.length; i < l; i++) {
+    let rawReleaseGood = {
+      ...releaseGood,
+      ...releaseGood.orderInventories[i],
+      errorMsg
+    }
+
+    delete rawReleaseGood.orderInventories
+    delete rawReleaseGood.product
+
+    rawReleaseGoods.push(rawReleaseGood)
+  }
+  return rawReleaseGoods
+}

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

@@ -9,16 +9,11 @@ import { Product } from '@things-factory/product-base'
 import { buildQuery, Domain, Filter, ListParam, Pagination, Sorting } from '@things-factory/shell'
 import { Inventory, LOCATION_TYPE } from '@things-factory/warehouse-base'
 
-import {
-  InventoryInfos,
-  NewReleaseGood,
-  OrderInventory,
-  ReleasableInventoryList,
-  ReleaseGoodList,
-  ShippingOrder
-} from '../'
 import { ATTACHMENT_TYPE, ORDER_INVENTORY_STATUS, ORDER_STATUS } from '../../constants'
+import { OrderInventory } from '../order-inventory/order-inventory'
+import { ShippingOrder } from '../shipping-order/shipping-order'
 import { ReleaseGood } from './release-good'
+import { InventoryInfos, NewReleaseGood, ReleasableInventoryList, ReleaseGoodList } from './release-good-types'
 
 @Resolver(ReleaseGood)
 export class ReleaseGoodQuery {
@@ -648,7 +643,7 @@ export async function bulkReleaseGoodsAvailableItemsFunction(
   let availableItems = await tx.query(
     `
         WITH inv AS (
-        SELECT i.product_id, foo.product_detail_id, foo.sku, foo.product_info, i.batch_id, i.packing_type, i.packing_size, i.uom,
+        SELECT i.product_id, foo.product_detail_id, foo.sku, foo.product_info, i.packing_type, i.packing_size, i.uom,
           SUM(i.qty - COALESCE(i.locked_qty, 0)) - COALESCE(
             (
               SELECT SUM(oi.release_qty) FROM order_inventories oi 
@@ -686,7 +681,7 @@ export async function bulkReleaseGoodsAvailableItemsFunction(
         AND i.domain_id = $1
         AND i.bizplace_id = $2
         WHERE l.type NOT IN ($3, $4)
-        GROUP BY i.product_id, foo.product_detail_id, foo.sku,foo.product_info, i.batch_id, i.packing_type, i.packing_size, i.uom
+        GROUP BY i.product_id, foo.product_detail_id, foo.sku,foo.product_info, i.packing_type, i.packing_size, i.uom
         ORDER BY foo.sku, remain_qty
       ) SELECT * FROM inv WHERE remain_qty > 0
       `,
@@ -701,7 +696,6 @@ export async function bulkReleaseGoodsAvailableItemsFunction(
       productDetailId: item.product_detail_id,
       productInfo: item.product_info,
       sku: item.sku,
-      batchId: item.batch_id,
       packingType: item.packing_type,
       packingSize: Number(item.packing_size || 0),
       uom: item.uom,
@@ -762,10 +756,10 @@ function _extractData(rawData, validatedData) {
 
       raw.productId = validatedData[idx].productId
       raw.productDetailId = validatedData[idx].productDetailId
+      raw.productInfo = validatedData[idx].productInfo
       raw.packingType = validatedData[idx].packingType
       raw.packingSize = validatedData[idx].packingSize
       raw.uom = validatedData[idx].uom
-      raw.batchId = validatedData[idx].batchId
     } else {
       raw.assignedQty = 0
       raw.assignedUomValue = 0

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

@@ -45,6 +45,8 @@ export enum DispatchmentStatus {
 }
 @Entity()
 @Index('ix_release-good_0', (releaseGood: ReleaseGood) => [releaseGood.domain, releaseGood.name], { unique: true })
+@Index('ix_release-good_1', (releaseGood: ReleaseGood) => [releaseGood.domain, releaseGood.refNo])
+@Index('ix_release-good_2', (releaseGood: ReleaseGood) => [releaseGood.domain, releaseGood.refNo2])
 @ObjectType()
 export class ReleaseGood {
   @PrimaryGeneratedColumn('uuid')

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

@@ -1,3 +1,7 @@
+import { FileUpload, GraphQLUpload } from 'graphql-upload'
+import { Arg, Ctx, Directive, Mutation, Resolver } from 'type-graphql'
+import { EntityManager, In } from 'typeorm'
+
 import { Attachment, createAttachments } from '@things-factory/attachment-base'
 import { Role, User } from '@things-factory/auth-base'
 import { Bizplace, getDomainUsers } from '@things-factory/biz-base'
@@ -5,10 +9,7 @@ import { sendNotification } from '@things-factory/notification'
 import { Product } from '@things-factory/product-base'
 import { Domain } from '@things-factory/shell'
 import { Inventory } from '@things-factory/warehouse-base'
-import { FileUpload, GraphQLUpload } from 'graphql-upload'
-import { TransferOrderMutation } from 'server'
-import { Arg, Ctx, Directive, Mutation, Resolver } from 'type-graphql'
-import { EntityManager, In } from 'typeorm'
+
 import { NewOrderInventory, NewReturnOrder, OrderInventory, OrderVas, ReturnOrderPatch } from '../'
 import { ATTACHMENT_TYPE, ORDER_INVENTORY_STATUS, ORDER_STATUS, ORDER_VAS_STATUS } from '../../constants'
 import { OrderNoGenerator } from '../../utils'

package/server/utils/order-no-generator.ts

@@ -58,6 +58,10 @@ export class OrderNoGenerator {
     return `OP-${uuid()}`
   }
 
+  static invoiceProduct() {
+    return `IP-${uuid()}`
+  }
+
   static orderVas() {
     return `OV-${uuid()}`
   }
@@ -121,4 +125,11 @@ export class OrderNoGenerator {
       currentDate.getMonth() + 1
     }${currentDate.getDate()}${currentDate.getHours()}${currentDate.getMinutes()}${currentDate.getSeconds()}${currentDate.getMilliseconds()}`
   }
+
+  static invoice() {
+    const currentDate = new Date()
+    return `INV-${currentDate.getFullYear()}${
+      currentDate.getMonth() + 1
+    }${currentDate.getDate()}${currentDate.getHours()}${currentDate.getMinutes()}${currentDate.getSeconds()}${currentDate.getMilliseconds()}`
+  }
 }