@things-factory/sales-base 4.3.59 → 4.3.62

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

@@ -38,7 +38,7 @@ export class DraftReleaseGoodQuery {
   @Query(returns => DraftReleaseGoodList, { description: 'To fetch multiple DraftReleaseGoods' })
   async draftReleaseGoods(@Args() params: ListParam, @Ctx() context: any): Promise<DraftReleaseGoodList> {
     try {
-      const { domain, user, tx }: { domain: Domain; user: User, tx: EntityManager } = context.state
+      const { domain, user, tx }: { domain: Domain; user: User; tx: EntityManager } = context.state
 
       const statusFilter = params.filters.find(e => e.name === 'status')
       const bizplaceFilter = params.filters.find(param => param.name === 'bizplaceId')
@@ -55,7 +55,9 @@ export class DraftReleaseGoodQuery {
         })
       }
 
-      params.filters = params.filters.filter(itm => itm.name !== 'noOfItems' && itm.name !== 'sku' && itm.name !== 'status')
+      params.filters = params.filters.filter(
+        itm => itm.name !== 'noOfItems' && itm.name !== 'sku' && itm.name !== 'status'
+      )
 
       if (orderRemarkFilter) {
         const orderRemarkIdx = params.filters.findIndex(param => param.name === 'orderRemark')
@@ -104,7 +106,8 @@ export class DraftReleaseGoodQuery {
         })
       }
 
-      tx.query(`
+      tx.query(
+        `
         create temp table temp_op_calculation on commit drop as (
           select drg1.id, sum(case when wboi."remainQty" >= op.release_qty then 0 else 1 end) as insufficient_count, count(*) as total_row 
           from draft_release_goods drg1
@@ -119,12 +122,17 @@ export class DraftReleaseGoodQuery {
           where op.domain_id = $1 and drg1.status ='DRAFT'
           group by drg1.id
         )
-      `, [domain.id])
+      `,
+        [domain.id]
+      )
 
       const qb: SelectQueryBuilder<DraftReleaseGood> = tx.getRepository(DraftReleaseGood).createQueryBuilder('drg')
       buildQuery(qb, params, context)
       qb.addSelect('COALESCE("cc".rank, 99999)', 'rank')
-      qb.addSelect(`CASE WHEN "drg".status = 'DRAFT' and (tmp_calc.insufficient_count > 0 or tmp_calc.total_row = 0) then 'INSUFFICIENT' else "drg".status END`, 'computed_status')
+      qb.addSelect(
+        `CASE WHEN "drg".status = 'DRAFT' and (tmp_calc.insufficient_count > 0 or tmp_calc.total_row = 0) then 'INSUFFICIENT' else "drg".status END`,
+        'computed_status'
+      )
       qb.leftJoin(`temp_op_calculation`, 'tmp_calc', 'tmp_calc.id = drg.id')
       qb.leftJoinAndSelect('drg.domain', 'domain')
       qb.leftJoinAndSelect('drg.bizplace', 'bizplace')
@@ -205,10 +213,11 @@ export class DraftReleaseGoodQuery {
       )
 
       qb.orderBy(sort)
+      qb.offset((params.pagination.page - 1) * params.pagination.limit)
+      qb.limit(params.pagination.limit)
 
       let [items, total] = await Promise.all([qb.getRawMany(), qb.getCount()])
 
-
       items = items.map(itm => {
         return {
           id: itm.drg_id,
@@ -234,7 +243,6 @@ export class DraftReleaseGoodQuery {
     } catch (error) {
       throw error
     }
-
   }
 }
 
@@ -260,7 +268,6 @@ export async function getDraftReleaseGoodFunction(_: any, name: any, context: an
 
     if (!result?.id) throw new Error(`Failed to find draft release good ${name}`)
 
-
     let foundPermittedBizplace: Bizplace
     let companyBizplace: Bizplace
 
@@ -282,17 +289,53 @@ export async function getDraftReleaseGoodFunction(_: any, name: any, context: an
 
     let productInventory
     if (result.orderProducts.length > 0)
-      productInventory = await InventoryUtil.bizplaceProductInventory(bizplaces, { filters: [{ name: 'bizplaceId', operator: 'eq', value: result.bizplace.id }, { name: 'productId', operator: 'in', value: [...result.orderProducts.filter(itm => itm?.product).map(itm => { return itm.product.id }), ...result.orderProducts.filter(itm => itm?.productBundle).map(itm => { return itm.productBundle.id })] }] }, context, tx)
+      productInventory = await InventoryUtil.bizplaceProductInventory(
+        bizplaces,
+        {
+          filters: [
+            { name: 'bizplaceId', operator: 'eq', value: result.bizplace.id },
+            {
+              name: 'productId',
+              operator: 'in',
+              value: [
+                ...result.orderProducts
+                  .filter(itm => itm?.product)
+                  .map(itm => {
+                    return itm.product.id
+                  }),
+                ...result.orderProducts
+                  .filter(itm => itm?.productBundle)
+                  .map(itm => {
+                    return itm.productBundle.id
+                  })
+              ]
+            }
+          ]
+        },
+        context,
+        tx
+      )
 
     result.orderProducts = result.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)
+      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
+      )
       return {
         ...itm,
-        product: itm.product || { id: foundProductInv.productId, name: foundProductInv.productName, brand: foundProductInv.productBrand, sku: foundProductInv.productSKU },
+        product: itm.product || {
+          id: foundProductInv.productId,
+          name: foundProductInv.productName,
+          brand: foundProductInv.productBrand,
+          sku: foundProductInv.productSKU
+        },
         groupType: foundProductInv ? foundProductInv.groupType : 'SINGLE',
         remainQty: foundProductInv ? foundProductInv.remainQty : 0,
         remainUomValue: foundProductInv ? foundProductInv.remainUomValue : 0,
-        remainUomValueWithUom: foundProductInv ? foundProductInv.remainUomValueWithUom : 0,
+        remainUomValueWithUom: foundProductInv ? foundProductInv.remainUomValueWithUom : 0
       }
     })
     const foundAttachments: Attachment[] = await tx.getRepository(Attachment).find({
@@ -307,8 +350,7 @@ export async function getDraftReleaseGoodFunction(_: any, name: any, context: an
       ...result,
       attachment: foundAttachments
     }
-
   } catch (error) {
     console.error(error)
   }
-}
+}

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

@@ -62,6 +62,9 @@ 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')
@@ -334,9 +337,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 }
   }