@things-factory/sales-base 4.3.60 → 4.3.64

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

@@ -268,7 +268,7 @@ export class DraftReleaseGoodMutation {
                 i.uom == itm.uom &&
                 itm.releaseQty <= i.remainQty
             )
-            return { ...itm, status: foundProductInv ? 'suffice' : 'insufficient' }
+            return { ...itm, releaseUomValue: (foundProductInv.remainUomValue / foundProductInv.remainQty) * itm.releaseQty, status: foundProductInv ? 'suffice' : 'insufficient' }
           })
 
           let insufficient = draftOrder.orderProducts.find(op => op.status == 'insufficient')
@@ -285,7 +285,7 @@ export class DraftReleaseGoodMutation {
             let orderInventories = []
 
             for (let index = 0; index < draftOrder.orderProducts.length; index++) {
-              const itm = draftOrder.orderProducts[index]
+              const itm: Partial<OrderProduct> = draftOrder.orderProducts[index]
               let data = []
               if (itm.productBundle) {
                 let bundle: ProductBundle = await parentTx.getRepository(ProductBundle).findOne({
@@ -301,26 +301,26 @@ export class DraftReleaseGoodMutation {
                   const objProductBundleSetting = bundle.productBundleSettings[index2]
                   data.push({
                     sku: objProductBundleSetting.product.sku,
-                    packing_type: objProductBundleSetting.productDetail.packingType,
-                    packing_size: objProductBundleSetting.productDetail.packingSize,
+                    packingType: objProductBundleSetting.productDetail.packingType,
+                    packingSize: objProductBundleSetting.productDetail.packingSize,
                     uom: objProductBundleSetting.productDetail.uom,
-                    release_qty: objProductBundleSetting.bundleQty * itm.releaseQty,
+                    releaseQty: objProductBundleSetting.bundleQty * itm.releaseQty,
                     assignedQty: undefined,
                     assignedUomValue: undefined,
-                    releaseUomValue: undefined
+                    releaseUomValue: objProductBundleSetting.bundleQty * itm.releaseQty * itm.releaseUomValue
                   })
                 }
               } else {
                 data = [
                   {
                     sku: itm.product.sku,
-                    packing_type: itm.packingType,
-                    packing_size: itm.packingSize,
+                    packingType: itm.packingType,
+                    packingSize: itm.packingSize,
                     uom: itm.uom,
-                    release_qty: itm.releaseQty,
+                    releaseQty: itm.releaseQty,
                     assignedQty: undefined,
                     assignedUomValue: undefined,
-                    releaseUomValue: undefined
+                    releaseUomValue: itm.releaseUomValue
                   }
                 ]
               }
@@ -329,15 +329,17 @@ export class DraftReleaseGoodMutation {
                 let existingOI = orderInventories.find(
                   itm =>
                     itm.sku == data.sku &&
-                    itm.packing_type == data.packing_type &&
-                    itm.packing_size == data.packing_size &&
+                    itm.packingType == data.packingType &&
+                    itm.packingSize == data.packingSize &&
                     itm.uom == data.uom
                 )
 
                 if (existingOI) {
-                  existingOI.release_qty = existingOI.release_qty + data.release_qty
+                  existingOI.releaseQty = existingOI.releaseQty + data.releaseQty
+                  existingOI.releaseUomValue = existingOI.releaseUomValue + data.uomValue
+                  existingOI.uomValue = existingOI.uomValue + data.uomValue
                 } else {
-                  orderInventories.push(data)
+                  orderInventories.push({ ...data, orderProduct: itm })
                 }
               })
             }
@@ -349,7 +351,7 @@ export class DraftReleaseGoodMutation {
                   context,
                   childTx
                 )
-                if (availableItems.some(item => !item.release_qty || item.release_qty > item.assignedQty))
+                if (availableItems.some(item => !item.releaseQty || item.releaseQty > item.assignedQty))
                   throw new ValidationError({
                     ...ValidationError.ERROR_CODES.INSUFFICIENT_STOCK,
                     detail: { data: JSON.stringify(availableItems) }
@@ -358,7 +360,9 @@ export class DraftReleaseGoodMutation {
                 releaseGood.orderInventories = availableItems.map(itm => {
                   return {
                     ...itm,
-                    releaseQty: itm.release_qty
+                    releaseQty: itm.releaseQty,
+                    releaseUomValue: itm.releaseUomValue,
+                    uomValue: itm.uomValue
                   }
                 })
                 let createdReleaseGood: ReleaseGood = await bulkGenerateReleaseGood(
@@ -469,7 +473,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,
@@ -479,7 +497,8 @@ export async function createDraftReleaseGoodFunction(
     updater: user
   })
 
-  // // 2. Create draft release good product
+
+  // // 3. Create draft release good product
   await upsertDraftReleaseGoodProducts(
     domain,
     draftReleaseGood.bizplace,
@@ -489,7 +508,7 @@ export async function createDraftReleaseGoodFunction(
     tx
   )
 
-  // // 3. Create Attachments
+  // // 4. Create Attachments
   if (files?.length) {
     const attachments: Attachment[] = files.map(attachment => {
       return {
@@ -554,7 +573,7 @@ export async function updateDraftReleaseGoodFunction(
     ...existingDraftReleaseGood,
     ...draftReleaseGood,
     domain,
-    creator: user,
+    creator: existingDraftReleaseGood.creator,
     updater: user
   })
 
@@ -714,8 +733,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/manifest/manifest-mutation.ts

@@ -44,7 +44,9 @@ export class ManifestMutation {
     if (removeOrders?.length > 0) {
       //check if user removing all tracking no, if yes then delete
       let totalTrackingNo = await tx.getRepository(ReleaseGood).count({ where: { manifest: manifestId } })
-      await tx.getRepository(ReleaseGood).update({ domain, refNo: In(removeOrders) }, { manifest: null })
+      await tx
+        .getRepository(ReleaseGood)
+        .update({ domain, refNo: In(removeOrders) }, { manifest: null, manifestedBy: null, manifestedAt: null })
       if (removeOrders.length == totalTrackingNo) {
         await tx.getRepository(Manifest).delete(manifestId)
         return false
@@ -101,6 +103,8 @@ export class ManifestMutation {
             .findOne({ domain, refNo: item.refNo, trackingNo: item.trackingNo })
           releaseOrder.manifest = manifest
           releaseOrder.updater = user
+          releaseOrder.manifestedBy = user.id
+          releaseOrder.manifestedAt = new Date()
           await tx.getRepository(ReleaseGood).save(releaseOrder)
         })
       )
@@ -117,7 +121,7 @@ export class ManifestMutation {
     @Arg('shippingProvider', { nullable: true }) shippingProvider: string,
     @Ctx() context: any
   ): Promise<boolean> {
-    const { domain, tx } = context.state
+    const { domain, user, tx } = context.state
     const releaseGoodRepo = tx.getRepository(ReleaseGood)
     //check if order belongs to same shipping provider
     let foundReleaseOrder = await releaseGoodRepo.findOne({ where: { trackingNo }, relations: ['manifest'] })
@@ -134,7 +138,10 @@ export class ManifestMutation {
       throw new Error(i18next.t('error.tracking_no_belongs_to_x', { x: foundReleaseOrder.transporter }))
     }
 
-    await releaseGoodRepo.update({ id: foundReleaseOrder.id }, { manifest: manifestId })
+    await releaseGoodRepo.update(
+      { id: foundReleaseOrder.id },
+      { manifest: manifestId, manifestedAt: new Date(), manifestedBy: user }
+    )
 
     return true
   }

package/server/service/order-inventory/order-inventory-query.ts

@@ -1,11 +1,11 @@
-import { Arg, Args, Ctx, FieldResolver, Query, Resolver, Root, Directive } from 'type-graphql'
+import { Arg, Args, Ctx, Directive, FieldResolver, Query, Resolver, Root } from 'type-graphql'
 import { Brackets, EntityManager, getRepository, Like, SelectQueryBuilder } from 'typeorm'
 
 import { User } from '@things-factory/auth-base'
 import { getPermittedBizplaceIds } from '@things-factory/biz-base'
 import { Product } from '@things-factory/product-base'
 import { buildQuery, convertListParams, Domain, Filter, ListParam, Pagination, Sorting } from '@things-factory/shell'
-import { Inventory, InventoryPatch, Location } from '@things-factory/warehouse-base'
+import { Inventory, InventoryPatch } from '@things-factory/warehouse-base'
 
 import { ORDER_INVENTORY_STATUS, ORDER_STATUS } from '../../constants'
 import { ArrivalNotice } from '../arrival-notice/arrival-notice'
@@ -23,58 +23,90 @@ export class OrderInventoryQuery {
   @Query(returns => OrderInventoryList)
   async orderInventories(@Ctx() context: any, @Args() params: ListParam): Promise<OrderInventoryList> {
     const { domain }: { domain: Domain } = context.state
-    let filters = params.filters
+    const arrivalNoticeNoParam: any = params.filters.find((param: any) => param.name === 'arrivalNoticeNo')
+    const releaseGoodNoParam: any = params.filters.find((param: any) => param.name === 'releaseGoodNo')
 
-    // in case client side passes arrival notice or release good number as filter (single value only)
-    const anParam = filters.find(
-      (filter: filterInterface) => filter.name === 'arrivalNoticeNo' && filter.operator === 'eq'
-    )
-    const rgParam = filters.find(
-      (filter: filterInterface) => filter.name === 'releaseGoodNo' && filter.operator === 'eq'
-    )
-
-    if (anParam && !filters.some((filter: filterInterface) => filter.name === 'arrivalNotice')) {
+    if (arrivalNoticeNoParam && arrivalNoticeNoParam?.value) {
       const foundArrivalNotice: ArrivalNotice = await getRepository(ArrivalNotice).findOne({
         where: {
-          name: anParam.value,
+          name: arrivalNoticeNoParam.value,
           domain
         }
       })
 
       if (foundArrivalNotice) {
-        filters = params.filters.filter((filter: filterInterface) => filter.name !== 'arrivalNoticeNo')
-        params.filters = [...filters, { name: 'arrivalNotice', operator: 'eq', value: foundArrivalNotice.id }]
-      } else throw new Error(`Cannot find result for order "${anParam.value}"`)
+        params.filters.splice(
+          params.filters.findIndex(item => item.name == 'arrivalNoticeNo'),
+          1
+        )
+        params.filters.push({ name: 'arrivalNoticeId', operator: 'eq', value: foundArrivalNotice.id })
+      } else {
+        throw new Error(`Cannot find result for order "${arrivalNoticeNoParam.value}"`)
+      }
     }
 
-    if (rgParam && !filters.some(filter => filter.name === 'releaseGood')) {
+    if (releaseGoodNoParam && releaseGoodNoParam?.value) {
       const foundReleaseGood: ReleaseGood = await getRepository(ReleaseGood).findOne({
         where: {
-          name: rgParam.value,
+          name: releaseGoodNoParam.value,
           domain
         }
       })
 
       if (foundReleaseGood) {
-        filters = params.filters.filter(filter => filter.name !== 'releaseGoodNo')
-        params.filters = [...filters, { name: 'releaseGood', operator: 'eq', value: foundReleaseGood.id }]
-      } else throw new Error(`Cannot find result for order "${rgParam.value}"`)
+        params.filters.splice(
+          params.filters.findIndex(item => item.name == 'releaseGoodNo'),
+          1
+        )
+        params.filters.push({ name: 'releaseGoodId', operator: 'eq', value: foundReleaseGood.id })
+      } else {
+        throw new Error(`Cannot find result for order "${releaseGoodNoParam.value}"`)
+      }
     }
 
-    const convertedParams = convertListParams(params)
-    const [items, total] = await getRepository(OrderInventory).findAndCount({
-      ...convertedParams,
-      relations: [
-        'domain',
-        'arrivalNotice',
-        'inventory',
-        'inventory.product',
-        'releaseGood',
-        'deliveryOrder',
-        'creator',
-        'updater'
-      ]
-    })
+    const qb: SelectQueryBuilder<OrderInventory> = getRepository(OrderInventory).createQueryBuilder('oi')
+    buildQuery(qb, params, context)
+
+    qb.leftJoinAndSelect('oi.domain', 'domain')
+    qb.leftJoinAndSelect('oi.arrivalNotice', 'arrivalNotice')
+    qb.leftJoinAndSelect('oi.orderProduct', 'orderProduct')
+    qb.leftJoinAndSelect('oi.inventory', 'inventory')
+    qb.leftJoinAndSelect('inventory.product', 'product')
+    qb.leftJoinAndSelect('inventory.location', 'location')
+    qb.leftJoinAndSelect('oi.releaseGood', 'releaseGood')
+    qb.leftJoinAndSelect('oi.deliveryOrder', 'deliveryOrder')
+    qb.leftJoinAndSelect('oi.creator', 'creator')
+    qb.leftJoinAndSelect('oi.updater', 'updater')
+
+    let sort = {}
+    if (params?.sortings) {
+      if (params.sortings.some(e => e.name === 'inventoryPalletId')) {
+        // overwrite the worksheet status sorting since inventory check status is needed
+        sort = {
+          'inventory.palletId': params.sortings[params.sortings.findIndex(item => item.name == 'inventoryPalletId')]
+            .desc
+            ? 'DESC'
+            : 'ASC',
+          'oi.createdAt': params.sortings[params.sortings.findIndex(item => item.name == 'createdAt')]?.desc
+            ? 'DESC'
+            : 'ASC'
+        }
+      } else if (params.sortings.some(e => e.name === 'createdAt')) {
+        sort = {
+          ...sort,
+          'oi.createdAt': params.sortings[params.sortings.findIndex(item => item.name == 'createdAt')]?.desc
+            ? 'DESC'
+            : 'ASC'
+        }
+      }
+    } else {
+      sort = { 'oi.createdAt': 'ASC' }
+    }
+
+    qb.orderBy(sort)
+
+    let [items, total] = await qb.getManyAndCount()
+
     return { items, total }
   }
 
@@ -457,7 +489,7 @@ export class OrderInventoryQuery {
       let sort = ''
       let prioritySort = ''
       let releaseOrderIdQuery = ''
-      
+
       // Require further evaluation. Potential performance issue.
       if (mergedPageParam) {
         releaseOrderIdQuery = `

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

@@ -5,6 +5,7 @@ import {
   Entity,
   Index,
   ManyToOne,
+  OneToMany,
   PrimaryGeneratedColumn,
   RelationId,
   UpdateDateColumn
@@ -20,6 +21,7 @@ import { ArrivalNotice } from '../arrival-notice/arrival-notice'
 import { DeliveryOrder } from '../delivery-order/delivery-order'
 import { InventoryCheck } from '../inventory-check/inventory-check'
 import { OrderProduct } from '../order-product/order-product'
+import { OrderToteItem } from '../order-tote-item/order-tote-item'
 import { ReleaseGood } from '../release-good/release-good'
 import { ReturnOrder } from '../return-order/return-order'
 import { TransferOrder } from '../transfer-order/transfer-order'
@@ -62,6 +64,7 @@ import { TransferOrder } from '../transfer-order/transfer-order'
   orderInventory.releaseQty,
   orderInventory.uom
 ])
+@Index('ix_order-inventory_5', (orderInventory: OrderInventory) => [orderInventory.releaseGood])
 @ObjectType()
 export class OrderInventory {
   @PrimaryGeneratedColumn('uuid')
@@ -182,6 +185,10 @@ export class OrderInventory {
   @RelationId((orderInventory: OrderInventory) => orderInventory.orderProduct)
   orderProductId: string
 
+  @OneToMany(type => OrderToteItem, orderToteItem => orderToteItem.orderInventory, { nullable: true })
+  @Field(type => [OrderToteItem], { nullable: true })
+  orderToteItems: OrderToteItem[]
+
   @Column({ type: 'uuid', nullable: true })
   @Field({ nullable: true })
   refWorksheetId: string
@@ -334,9 +341,8 @@ export class OrderInventory {
   @Field({ nullable: true })
   loadedAt: Date
 
-  @Column({ nullable: true })
   @Field({ nullable: true })
-  shippedAt: Date
+  dispatchedAt: Date
 
   @CreateDateColumn()
   @Field()

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

@@ -1,7 +1,9 @@
-import { User } from '@things-factory/auth-base'
-import { convertListParams, Domain, Filter, Pagination, Sorting } from '@things-factory/shell'
 import { Arg, Ctx, FieldResolver, Query, Resolver, Root } from 'type-graphql'
-import { getRepository } from 'typeorm'
+import { Brackets, getRepository, SelectQueryBuilder } from 'typeorm'
+
+import { User } from '@things-factory/auth-base'
+import { Domain, Filter, Pagination, Sorting } from '@things-factory/shell'
+
 import { OrderProductList } from '../'
 import { OrderProduct } from './order-product'
 
@@ -14,11 +16,46 @@ export class OrderProductQuery {
     @Arg('pagination', type => Pagination, { nullable: true }) pagination?: Pagination,
     @Arg('sortings', type => [Sorting], { nullable: true }) sortings?: Sorting[]
   ): Promise<OrderProductList> {
-    const convertedParams = convertListParams({ filters, pagination, sortings })
-    const [items, total] = await getRepository(OrderProduct).findAndCount({
-      ...convertedParams,
-      relations: ['domain', 'bizplace', 'bizplace.company', 'arrivalNotice', 'product', 'creator', 'updater']
-    })
+    const { domain, user }: { domain: Domain; user: User } = context.state
+    const params = { filters, pagination }
+
+    const releaseGoodFilters = params.filters.filter(x => x.name == 'releaseGood')
+    const productFilters = params.filters.filter(x => x.name == 'productInfo')
+    const productFilterColumns = ['sku', 'brand_sku', 'name', 'description', 'brand', 'sub_brand']
+    params.filters = params.filters.filter(x => x.name != 'productInfo')
+
+    let qb: SelectQueryBuilder<OrderProduct> = await getRepository(OrderProduct).createQueryBuilder('op')
+    qb.leftJoinAndSelect('op.product', 'product')
+      .leftJoinAndSelect('op.domain', 'domain')
+      .leftJoinAndSelect('op.bizplace', 'bizplace')
+      .leftJoinAndSelect('bizplace.company', 'company')
+      .leftJoinAndSelect('op.arrivalNotice', 'an')
+      .leftJoinAndSelect('op.releaseGood', 'rg')
+      .leftJoinAndSelect('op.creator', 'creator')
+      .leftJoinAndSelect('op.updater', 'updater')
+      .andWhere('op.domain_id = :domainId', { domainId: domain.id })
+      .andWhere('op.release_good_id IN (:...releaseGoodId)', { releaseGoodId: releaseGoodFilters[0].value })
+
+    if (productFilters && productFilters.length > 0) {
+      let productInfo = productFilters[0]
+      let productValue = productInfo.value
+        .toLowerCase()
+        .split(',')
+        .map(prod => {
+          return "'%" + prod.trim().replace(/'/g, "''") + "%'"
+        })
+        .join(',')
+      qb.andWhere(
+        new Brackets(qb2 => {
+          productFilterColumns.forEach(filter => {
+            qb2.orWhere(`Lower("product"."${filter}") LIKE ANY(ARRAY[${productValue}])`)
+          })
+        })
+      )
+    }
+
+    let [items, total] = await qb.getManyAndCount()
+
     return { items, total }
   }
 

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

@@ -1,11 +1,21 @@
 import { Field, ObjectType } from 'type-graphql'
-import { Column, Entity, Index, ManyToOne, PrimaryGeneratedColumn, RelationId, UpdateDateColumn } from 'typeorm'
+import {
+  Column,
+  Entity,
+  Index,
+  ManyToOne,
+  OneToMany,
+  PrimaryGeneratedColumn,
+  RelationId,
+  UpdateDateColumn
+} from 'typeorm'
 
 import { User } from '@things-factory/auth-base'
 import { Domain } from '@things-factory/shell'
 import { Tote } from '@things-factory/warehouse-base'
-import { ReleaseGood } from '../release-good/release-good'
+
 import { OrderToteSeal } from '../order-tote-seal/order-tote-seal'
+import { ReleaseGood } from '../release-good/release-good'
 
 @Entity()
 @Index('ix_order_tote_0', (orderTote: OrderTote) => [orderTote.id], { unique: true })
@@ -57,6 +67,7 @@ export class OrderTote {
   @RelationId((orderTote: OrderTote) => orderTote.updater)
   updaterId: string
 
+  @OneToMany(type => OrderToteSeal, orderToteSeal => orderToteSeal.orderTote, { nullable: true })
   @Field(type => [OrderToteSeal], { nullable: true })
   orderToteSeals?: OrderToteSeal[]
 }