@things-factory/sales-base 4.3.38 → 4.3.41

package/server/service/goods-receival-note/goods-receival-note-query.ts

@@ -1,12 +1,20 @@
+import { PurchaseOrder } from './../purchase-order/purchase-order'
 import { Arg, Args, Ctx, FieldResolver, Query, Resolver, Root } from 'type-graphql'
 import { getRepository, SelectQueryBuilder } from 'typeorm'
+import { IsNull, Not, In } from 'typeorm'
 
 import { User } from '@things-factory/auth-base'
 import { getPermittedBizplaceIds } from '@things-factory/biz-base'
 import { buildQuery, Domain, ListParam } from '@things-factory/shell'
-
+import { InventoryItem } from '@things-factory/warehouse-base'
 import { GoodsReceivalNoteList } from '../'
 import { GoodsReceivalNote } from './goods-receival-note'
+import { ArrivalNotice } from '../arrival-notice/arrival-notice'
+import { Partner } from '@things-factory/auth-base'
+import { Bizplace, ContactPoint } from '@things-factory/biz-base'
+import { OrderProduct } from '../order-product/order-product'
+import { ReducedInventoryHistory } from '@things-factory/warehouse-base'
+import { DateTimeConverter } from '../../utils/datetime-util'
 
 @Resolver(GoodsReceivalNote)
 export class GoodsReceivalNoteQuery {
@@ -123,12 +131,12 @@ export class GoodsReceivalNoteQuery {
         [arrChildSortData.indexOf(sort.name) >= 0
           ? 'arrivalNotice.' + sort.name
           : arrNameSortData.indexOf(sort.name) >= 0
-          ? sort.name + '.name'
-          : arrGanStatusSortData.indexOf(sort.name) >= 0
-          ? 'arrivalNotice.status'
-          : arrGrnStatuSortData.indexOf(sort.name) >= 0
-          ? 'grn.status'
-          : 'grn.' + sort.name]: sort.desc ? 'DESC' : 'ASC'
+            ? sort.name + '.name'
+            : arrGanStatusSortData.indexOf(sort.name) >= 0
+              ? 'arrivalNotice.status'
+              : arrGrnStatuSortData.indexOf(sort.name) >= 0
+                ? 'grn.status'
+                : 'grn.' + sort.name]: sort.desc ? 'DESC' : 'ASC'
       }),
       !params.sortings.some(e => e.name === 'status') ? { rank: 'ASC' } : {}
     )
@@ -141,12 +149,114 @@ export class GoodsReceivalNoteQuery {
   }
 
   @Query(returns => GoodsReceivalNote)
-  async goodsReceivalNote(@Arg('name') name: string, @Ctx() context: any): Promise<GoodsReceivalNote> {
+  async goodsReceivalNote(
+    @Arg('name') name: string,
+    @Arg('timezoneOffSet') timezoneOffSet: string,
+    @Ctx() context: any
+  ): Promise<any> {
     const { domain }: { domain: Domain } = context.state
-    return await getRepository(GoodsReceivalNote).findOne({
+
+    const foundGRN: GoodsReceivalNote = await getRepository(GoodsReceivalNote).findOne({
       where: { domain, name },
-      relations: ['domain', 'bizplace', 'bizplace.company', 'arrivalNotice', 'creator', 'updater']
+      relations: [
+        'domain',
+        'bizplace',
+        'bizplace.domain',
+        'bizplace.company',
+        'arrivalNotice',
+        'arrivalNotice.purchaseOrder'
+      ]
+    })
+
+    const foundGAN: ArrivalNotice = foundGRN.arrivalNotice
+    const ownRefNo = foundGAN.refNo
+
+    const partnerBiz: Bizplace = foundGRN.bizplace
+
+    const partnerDomain: Partner = await getRepository(Partner).findOne({
+      where: { partnerDomain: partnerBiz.domain, domain },
+      relations: ['domain']
+    })
+
+    const domainOwner: Domain = partnerDomain.domain
+    const domainBizplace: Bizplace = await getRepository(Bizplace).findOne({
+      where: { domain: domainOwner },
+      relations: ['company']
     })
+
+    const qbReducedInventory = await getRepository(ReducedInventoryHistory)
+      .createQueryBuilder('ivh')
+      .select('product_id', 'productId')
+      .addSelect('batch_id', 'batchId')
+      .addSelect('reusable_pallet_id', 'reusablePalletId')
+      .addSelect('packing_type', 'packingType')
+      .addSelect('sum(qty)', 'qty')
+      .addSelect('sum(uom_value)', 'uomValue')
+      .addSelect('uom', 'uom')
+      .addSelect('count(distinct pallet_id)', 'pallet')
+      .addSelect(`string_agg(distinct expiration_date::varchar,', ' order by expiration_date::varchar)`, 'expiryDate')
+      .addSelect(`string_agg(distinct pallet_id::varchar,', ' order by pallet_id::varchar)`, 'palletId')
+      .where('ivh.domain_id = :domainId', { domainId: domain.id })
+      .andWhere('ivh.ref_order_id = :refOrderId', { refOrderId: foundGAN.id })
+      .andWhere(`ivh.transaction_type = 'UNLOADING'`)
+      .groupBy('reusable_pallet_id')
+      .addGroupBy('product_id')
+      .addGroupBy('batch_id')
+      .addGroupBy('packing_type')
+      .addGroupBy('uom')
+      .getRawMany()
+
+    // 5. find domain contact point
+    const foundCP: ContactPoint = await getRepository(ContactPoint).findOne({
+      where: { domain, bizplace: domainBizplace }
+    })
+
+    const inboundInventories: any[] = await qbReducedInventory
+
+    const targetProducts: OrderProduct[] = await getRepository(OrderProduct).find({
+      where: { domain, arrivalNotice: foundGAN, actualPalletQty: Not(IsNull()), actualPackQty: Not(IsNull()) },
+      relations: ['product', 'arrivalNotice', 'arrivalNotice.purchaseOrder']
+    })
+
+    const data = {
+      grnNo: foundGRN.name,
+      ganNo: foundGAN.name,
+      refGANNo: foundGAN.refNo || '',
+      refGANNo2: foundGAN.refNo2 || '',
+      refGANNo3: foundGAN.refNo3 || '',
+      companyDomain: domainBizplace.company.name,
+      supplier: foundCP.name || '',
+      date: foundGAN.acceptedAt ? DateTimeConverter.datetime(foundGAN.acceptedAt, timezoneOffSet) : '',
+      productLists: targetProducts.map((item, idx) => {
+        let unloadInvHistory = inboundInventories.find(
+          ih =>
+            ih.productId == item.product.id &&
+            ih.batchId == item.batchId &&
+            ih.packingType == item.packingType &&
+            ih.uom == item.uom
+        )
+
+        return {
+          list_no: idx + 1,
+          po: item?.arrivalNotice?.purchaseOrder?.name ? item?.arrivalNotice?.purchaseOrder.name : '',
+          batchNo: item.batchId || '',
+          productSKU: `${item.product.sku}`,
+          productName: `${item.product.name}(${item.product.description})`,
+          productType: item.packingType,
+          productBatch: item.batchId,
+          expectedQty: item.packQty,
+          actualQty: unloadInvHistory.qty || item.actualPackQty,
+          actualUomValue: item.uomValue * item.actualPackQty,
+          productUom: `${unloadInvHistory.uom || item.uom}`,
+          expiryDate: unloadInvHistory.expiryDate || '',
+          unitPrice: item.unitPrice.toFixed(2) || 0.0,
+          manufactureDate: item.manufactureDate || '',
+          remark: (item.remark ? item.remark : '') + (item.issue ? ' [Issue]: ' + item.issue : '')
+        }
+      })
+    }
+
+    return data
   }
 
   @FieldResolver(type => Domain)

package/server/service/goods-receival-note/goods-receival-note-types.ts

@@ -11,6 +11,54 @@ export class GoodsReceivalNoteList {
   total: number
 }
 
+// Need to review with better class name
+@ObjectType()
+export class ProductListsType {
+
+  @Field({ nullable: true })
+  po: string
+
+  @Field({ nullable: true })
+  batchNo: string
+
+  @Field({ nullable: true })
+  productSKU: string
+
+  @Field({ nullable: true })
+  productName: string
+
+  @Field({ nullable: true })
+  productType: string
+
+  @Field({ nullable: true })
+  productBatch: string
+
+  @Field({nullable:true})
+  @Field({ nullable: true })
+  expectedQty: number
+
+  @Field({ nullable: true })
+  actualQty: number
+
+  @Field({ nullable: true })
+  actualUomValue: number
+
+  @Field({ nullable: true })
+  productUom: string
+
+  @Field({ nullable: true })
+  expiryDate: string
+
+  @Field({ nullable: true })
+  unitPrice: number
+
+  @Field({ nullable: true })
+  manufactureDate: string
+
+  @Field({ nullable: true })
+  remark: string
+}
+
 @InputType()
 export class NewGoodsReceivalNote {
   @Field({ nullable: true })

package/server/service/goods-receival-note/goods-receival-note.ts

@@ -16,6 +16,7 @@ import {
   UpdateDateColumn
 } from 'typeorm'
 import { ArrivalNotice } from '../'
+import { ProductListsType } from './goods-receival-note-types'
 
 @Entity()
 @Index(
@@ -92,4 +93,35 @@ export class GoodsReceivalNote {
 
   @Field(type => [Attachment], { nullable: true })
   attachments: Attachment[]
+
+  @Field({nullable:true})
+  grnNo: string
+
+  @Field({nullable:true})
+  ganNo: string
+
+  @Field({nullable:true})
+  refGANNo: string
+
+  @Field({nullable:true})
+  refGANNo2: string
+
+  @Field({nullable:true})
+  refGANNo3: string
+
+  @Field({nullable:true})
+  timezoneOffSet: string
+
+  @Field(type=>[ProductListsType],{nullable:true})
+  productLists: ProductListsType[]
+
+  @Field({nullable:true})
+  companyDomain: string
+
+  @Field({nullable:true})
+  supplier: string
+
+  @Field({nullable:true})
+  date: string
+  
 }

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

@@ -1,4 +1,4 @@
-import { Arg, Args, Ctx, FieldResolver, Query, Resolver, Root } from 'type-graphql'
+import { Arg, Args, Ctx, FieldResolver, Query, Resolver, Root, Directive } from 'type-graphql'
 import { Brackets, EntityManager, getRepository, Like, SelectQueryBuilder } from 'typeorm'
 
 import { User } from '@things-factory/auth-base'
@@ -438,194 +438,137 @@ export class OrderInventoryQuery {
     }
   }
 
+  @Directive('@transaction')
   @Query(returns => OrderInventoryList)
   async orderInventoriesOfMultipleReleaseOrders(
     @Ctx() context: any,
     @Arg('partnerId') partnerId: string,
+    @Arg('priority', { nullable: true }) priority: string,
+    @Arg('binNumber', { nullable: true }) binNumber: string,
     @Arg('filters', type => [Filter], { nullable: true }) filters?: Filter[],
     @Arg('sortings', type => [Sorting], { nullable: true }) sortings?: Sorting[]
   ): Promise<OrderInventoryList> {
     try {
-      const { domain }: { domain: Domain } = context.state
-      const binNumberParam: any = filters.find((param: any) => param.name === 'binNumber')
-      let arrFilters = []
-
-      if (binNumberParam) {
-        let binLocation: Location = await getRepository(Location).findOne({
-          where: { domain, name: binNumberParam.value }
-        })
-
-        filters.splice(
-          filters.findIndex(item => item.name == 'binNumber'),
-          1
-        )
-        arrFilters.push({ ...binNumberParam, name: 'binLocationId', value: binLocation.id })
-      }
-
-      const releaseGoodsList: ReleaseGood[] = await getRepository(ReleaseGood).query(
-        `select id from release_goods where domain_id = '${domain.id}' and bizplace_id = '${partnerId}' and route_id is not null and status = 'PICKING'`
-      )
-
-      if (releaseGoodsList && releaseGoodsList.length) {
-        arrFilters.push({
-          name: 'releaseGoodId',
-          operator: 'in',
-          value: releaseGoodsList.map((foundRG: ReleaseGood) => foundRG.id),
-          relation: false
-        })
+      const { domain, tx }: { domain: Domain; tx: EntityManager } = context.state
+      const withSkuParam: any = filters.find((param: any) => param.name === 'withSku')
+      const withToteParam: any = filters.find((param: any) => param.name === 'withTote')
+      const mergedPageParam: any = filters.find((param: any) => param.name === 'merged')
+
+      let sort = ''
+      let prioritySort = ''
+      let releaseOrderIdQuery = ''
+      
+      // Require further evaluation. Potential performance issue.
+      if (mergedPageParam) {
+        releaseOrderIdQuery = `
+        select rg.id from release_goods rg
+        inner join order_inventories oi on oi.release_good_id = rg.id
+        inner join worksheet_details wd on wd.target_inventory_id = oi.id
+        inner join worksheets w on w.id = wd.worksheet_id
+        where rg.route_id is not null and rg.type = 'b2b'
+        and rg.domain_id = $1 and rg.bizplace_id = $2
+        and w.type in ('BATCH_PICKING', 'SORTING', 'LOADING') and w.status = 'EXECUTING'
+        and rg.id not in (select rg2.id from release_goods rg2 
+          inner join worksheets w2 on w2.release_good_id = rg2.id 
+          where rg2.domain_id = $1 and rg2.bizplace_id = $2
+          and rg2.route_id is not null and rg2.type = 'b2b' 
+          and w2.type in ('PICKING'))
+        group by rg.id
+        `
       } else {
-        arrFilters.push({
-          name: 'releaseGoodId',
-          operator: 'is_null',
-          relation: false
-        })
+        releaseOrderIdQuery = `
+        select rg.id from release_goods rg 
+        inner join worksheets w on w.release_good_id = rg.id 
+        where rg.domain_id = $1 and rg.bizplace_id = $2
+        and rg.route_id is not null and rg.type = 'b2b' 
+        and w.type in ('PICKING', 'LOADING') and w.status = 'EXECUTING'
+        and rg.id not in (select rg2.id from release_goods rg2 
+          inner join order_inventories oi2 on oi2.release_good_id = rg2.id
+          inner join worksheet_details wd2 on wd2.target_inventory_id = oi2.id
+          inner join worksheets w2 on w2.id = wd2.worksheet_id
+          where rg2.route_id is not null and rg2.type = 'b2b'
+          and rg2.domain_id = $1 and rg2.bizplace_id = $2
+          and w2.type in ('BATCH_PICKING'))
+        group by rg.id
+        `
       }
 
-      const params = { filters: arrFilters }
-      const qb: SelectQueryBuilder<OrderInventory> = getRepository(OrderInventory).createQueryBuilder('oi')
-      buildQuery(qb, params, context)
-
-      qb.select('oi')
-      qb.innerJoinAndSelect('oi.releaseGood', 'rg')
-      qb.innerJoinAndSelect('oi.product', 'Product')
-      qb.leftJoinAndSelect('oi.binLocation', 'bin_loc')
-      qb.leftJoinAndSelect('oi.domain', 'domain')
-      qb.leftJoinAndSelect('oi.creator', 'creator')
-      qb.leftJoinAndSelect('oi.updater', 'updater')
-
-      if (sortings?.length !== 0) {
-        const sorter = (sortings || []).reduce((acc, sort) => {
-          const order: string = sort.desc ? 'DESC' : 'ASC'
-
-          switch (sort.name) {
-            case 'roName':
-              acc = { ...acc, ['rg.name']: order }
-              break
-
-            case 'productSku':
-              acc = { ...acc, ['Product.sku']: order }
-              break
-
-            case 'binNumber':
-              acc = { ...acc, ['bin_loc.name']: order }
-              break
-          }
+      await tx.query(
+        `
+          create temp table temp_route_label ON COMMIT drop as (
+            select distinct(ot.name) as "toteNumber", oi.id, rg3.name as "releaseGoodName", (case when ot.name is null then oi.release_qty else null end) as "releaseQty", 
+            (case when ot.name is null then p.sku else null end) as "productSKU", (case when ot.name is null then p.name else null end) as "productName", (case when ot.name is null then l.name else null end) as "binNumber",
+            rg3.route_id as "routeId", rg3.store_id as "storeId", rg3.store_name as "storeName", rg3.stop_id as "stopId", 
+            rg3.created_at as "createdAt" from order_inventories oi 
+            inner join release_goods rg3 on rg3.id = oi.release_good_id
+            inner join products p on p.id = oi.product_id
+            left join locations l on l.id = oi.bin_location_id
+            left join order_tote_items oti on oti.order_inventory_id = oi.id
+            left join order_totes ot on ot.id = oti.order_tote_id
+            where oi.release_good_id in 
+              (${releaseOrderIdQuery})
+          )
+        `,
+        [domain.id, partnerId]
+      )
 
-          return acc
-        }, {})
-        qb.orderBy(sorter)
+      let withSkuQuery = withSkuParam?.value == true ? `AND tmp."binNumber" is null AND tmp."toteNumber" is null` : ''
+      let withBinQuery = ''
+      let withToteQuery =
+        withToteParam?.value == true
+          ? (withSkuParam?.value == true || binNumber ? `OR ` : 'AND ') + `tmp."toteNumber" is not null`
+          : ''
+
+      if (binNumber) {
+        if (binNumber !== 'all' && binNumber !== '') {
+          withBinQuery =
+            (withSkuParam?.value == true || withToteParam?.value == false ? `OR ` : `AND `) +
+            `tmp."binNumber" = '` +
+            binNumber +
+            `'`
+        } else if (binNumber == 'all') {
+          withBinQuery =
+            (withSkuParam?.value == true || withToteParam?.value == false ? `OR ` : `AND `) +
+            `tmp."binNumber" is not null`
+        }
       }
 
-      const [items, total] = await qb.getManyAndCount()
-
-      return { items, total }
-    } catch (e) {
-      throw e
-    }
-  }
+      if (priority) {
+        prioritySort = ' order by '
 
-  @Query(returns => OrderInventoryList)
-  async orderInventoriesOfMergedReleaseOrders(
-    @Ctx() context: any,
-    @Arg('partnerId') partnerId: string,
-    @Arg('filters', type => [Filter], { nullable: true }) filters?: Filter[],
-    @Arg('sortings', type => [Sorting], { nullable: true }) sortings?: Sorting[]
-  ): Promise<OrderInventoryList> {
-    try {
-      const { domain }: { domain: Domain } = context.state
-      const binNumberParam: any = filters.find((param: any) => param.name === 'binNumber')
-      const priorityParam: any = filters.find((param: any) => param.name === 'priority')
-      let arrFilters = []
-
-      if (priorityParam) {
-        filters.splice(
-          filters.findIndex(item => item.name == 'priority'),
-          1
-        )
-
-        switch (priorityParam.value) {
+        switch (priority) {
           case 'roSku':
-            sortings.push({ name: 'releaseGood', desc: true })
-            sortings.push({ name: 'productSku', desc: false })
+            prioritySort = prioritySort + '"createdAt" desc, "productSKU" asc'
             break
 
           case 'roBin':
-            sortings.push({ name: 'releaseGood', desc: true })
-            sortings.push({ name: 'binNumber', desc: false })
+            prioritySort = prioritySort + '"createdAt" desc, "binNumber" asc'
+            break
+
+          case 'roTote':
+            prioritySort = prioritySort + '"createdAt" desc, "toteNumber" asc'
             break
 
           case 'skuRo':
-            sortings.push({ name: 'productSku', desc: false })
-            sortings.push({ name: 'releaseGood', desc: true })
+            prioritySort = prioritySort + '"productSKU" asc, "createdAt" desc'
             break
 
           case 'skuBin':
-            sortings.push({ name: 'productSku', desc: false })
-            sortings.push({ name: 'binNumber', desc: false })
+            prioritySort = prioritySort + '"productSKU"  asc, "binNumber" asc'
             break
 
           case 'binSku':
-            sortings.push({ name: 'binNumber', desc: false })
-            sortings.push({ name: 'productSku', desc: false })
+            prioritySort = prioritySort + '"binNumber" asc, "productSKU" asc'
             break
 
           case 'binRo':
-            sortings.push({ name: 'binNumber', desc: false })
-            sortings.push({ name: 'releaseGood', desc: true })
+            prioritySort = prioritySort + '"binNumber" asc, "createdAt" desc'
             break
-        }
-      }
-
-      const releaseGoodsList: ReleaseGood[] = await getRepository(ReleaseGood).query(
-        `select oi.release_good_id as id from worksheets w
-        inner join worksheet_details wd on wd.worksheet_id =w.id 
-        inner join order_inventories oi on oi.id =wd.target_inventory_id
-        inner join release_goods rg on rg.id = oi.release_good_id
-        and oi.status in ('PICKING', 'PICKED', 'SORTING', 'SORTED')
-        and w.type = 'BATCH_PICKING' and w.status != 'DEACTIVATED'
-        and rg.domain_id = '${domain.id}' and rg.bizplace_id = '${partnerId}'
-        and rg.route_id is not null
-        group by oi.release_good_id`
-      )
-
-      if (releaseGoodsList && releaseGoodsList.length) {
-        arrFilters.push({
-          name: 'releaseGoodId',
-          operator: 'in',
-          value: releaseGoodsList.map((foundRG: ReleaseGood) => foundRG.id),
-          relation: false
-        })
-      } else {
-        arrFilters.push({
-          name: 'releaseGoodId',
-          operator: 'is_null',
-          relation: false
-        })
-      }
 
-      const params = { filters: arrFilters }
-      const qb: SelectQueryBuilder<OrderInventory> = getRepository(OrderInventory).createQueryBuilder('oi')
-      buildQuery(qb, params, context)
-
-      qb.select('oi')
-      qb.innerJoinAndSelect('oi.releaseGood', 'rg')
-      qb.innerJoinAndSelect('oi.product', 'Product')
-      qb.leftJoinAndSelect('oi.binLocation', 'bin_loc')
-      qb.leftJoinAndSelect('oi.domain', 'domain')
-      qb.leftJoinAndSelect('oi.creator', 'creator')
-      qb.leftJoinAndSelect('oi.updater', 'updater')
-
-      if (binNumberParam) {
-        let binLocation: Location = await getRepository(Location).findOne({
-          where: { domain, name: binNumberParam.value }
-        })
-
-        filters.splice(
-          filters.findIndex(item => item.name == 'binNumber'),
-          1
-        )
-
-        qb.andWhere('bin_loc.id = :id', { id: binLocation.id })
+          case 'toteRo':
+            prioritySort = prioritySort + '"toteNumber" asc, "createdAt" desc'
+            break
+        }
       }
 
       if (sortings?.length !== 0) {
@@ -634,28 +577,40 @@ export class OrderInventoryQuery {
 
           switch (sort.name) {
             case 'roName':
-              acc = { ...acc, ['rg.name']: order }
-              break
-
-            case 'releaseGood':
-              acc = { ...acc, ['rg.created_at']: order }
+              acc = [...acc, '"releaseGoodName" ' + order]
               break
 
             case 'productSku':
-              acc = { ...acc, ['Product.sku']: order }
+              acc = [...acc, '"productSKU" ' + order]
               break
 
             case 'binNumber':
-              acc = { ...acc, ['bin_loc.name']: order }
+              acc = [...acc, '"binNumber" ' + order]
+              break
+
+            case 'toteNumber':
+              acc = [...acc, '"toteNumber" ' + order]
               break
           }
 
           return acc
-        }, {})
-        qb.orderBy(sorter)
+        }, [])
+
+        sort = (priority ? ', ' : ' order by ') + sorter.toString()
       }
 
-      const [items, total] = await qb.getManyAndCount()
+      let items = await tx.query(
+        `
+          select * from temp_route_label tmp where 1 = 1
+          ${withSkuQuery}
+          ${withBinQuery}
+          ${withToteQuery}
+          ${prioritySort}
+          ${sort}
+          `
+      )
+
+      let total = items.length
 
       return { items, total }
     } catch (e) {

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

@@ -401,4 +401,22 @@ export class OrderInventory {
 
   @Field({ nullable: true })
   extraJsonData: string
+
+  @Field({ nullable: true })
+  binNumber: string
+
+  @Field({ nullable: true })
+  toteNumber: string
+
+  @Field({ nullable: true })
+  routeId: string
+
+  @Field({ nullable: true })
+  storeId: string
+
+  @Field({ nullable: true })
+  storeName: string
+
+  @Field({ nullable: true })
+  stopId: string
 }

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

@@ -6,7 +6,7 @@ import { Attachment, createAttachments, deleteAttachmentsByRef } from '@things-f
 import { User } from '@things-factory/auth-base'
 import { Bizplace, ContactPoint, getPermittedBizplaces } from '@things-factory/biz-base'
 import { generateId } from '@things-factory/id-rule-base'
-import { Product } from '@things-factory/product-base'
+import { Product, ProductDetail } from '@things-factory/product-base'
 import { Setting } from '@things-factory/setting-base'
 import { Domain } from '@things-factory/shell'
 import { Location } from '@things-factory/warehouse-base'
@@ -433,12 +433,16 @@ export async function upsertPurchaseOrderProducts(
     orderProducts = await Promise.all(
       orderProducts.map(async (op: OrderProduct) => {
         if (!op?.id) delete op.id
+        let foundProductDetail: ProductDetail = await tx
+          .getRepository(ProductDetail)
+          .findOne({ where: { product: op.product.id, packingType: op.packingType } })
         return {
           ...op,
           domain,
           bizplace: bizplace,
           name: op?.id ? op.name : OrderNoGenerator.orderProduct(),
           product: await productRepo.findOne(op.product.id),
+          packingSize: foundProductDetail?.packingSize || 1,
           purchaseOrder: purchaseOrder,
           status: purchaseOrder.status,
           creator: op?.id ? op.creator : user,