@things-factory/sales-base 4.0.44 → 4.1.2

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

@@ -397,6 +397,143 @@ export class DeliveryOrderQuery {
     return { items, total }
   }
 
+  @Query(returns => DeliveryOrderList)
+  async deliveryOrderReport(@Ctx() context: any, @Args() params: ListParam): Promise<DeliveryOrderList> {
+    try {
+      const { domain, user }: { domain: Domain; user: User } = context.state
+
+      const bizplaceFilter = params.filters.find(param => param.name === 'bizplaceId')
+      if (!bizplaceFilter) {
+        params.filters.push({
+          name: 'bizplaceId',
+          operator: 'in',
+          value: await getPermittedBizplaceIds(domain, user),
+          relation: false
+        })
+      }
+
+      const releaseGoodParam = params.filters.find(param => param.name === 'releaseGoodNo')
+      if (releaseGoodParam) {
+        let arrFilters = []
+        params.filters.splice(
+          params.filters.findIndex(item => item.name == 'releaseGoodNo'),
+          1
+        )
+        arrFilters.push({ ...releaseGoodParam, name: 'name' })
+
+        const foundReleaseGoods: ReleaseGood[] = await getRepository(ReleaseGood).find({
+          ...convertListParams({ filters: arrFilters })
+        })
+
+        if (foundReleaseGoods && foundReleaseGoods.length) {
+          params.filters.push({
+            name: 'releaseGoodId',
+            operator: 'in',
+            value: foundReleaseGoods.map((releaseGood: ReleaseGood) => releaseGood.id),
+            relation: false
+          })
+        }
+      }
+
+      const tzOffsetIdx = params.filters.findIndex(param => param.name === 'tzoffset')
+      let tzOffset = 0
+      if (tzOffsetIdx >= 0) {
+        tzOffset = params.filters[tzOffsetIdx].value
+        params.filters.splice(tzOffsetIdx, 1)
+      }
+
+      const fromDateParamIdx = params.filters.findIndex(param => param.name === 'fromDate')
+      if (fromDateParamIdx >= 0) {
+        let fromDateVal = new Date(params.filters[fromDateParamIdx].value)
+        params.filters.splice(fromDateParamIdx, 1)
+
+        params.filters.push({
+          name: 'createdAt',
+          operator: 'gte',
+          value: fromDateVal.toISOString(),
+          relation: false
+        })
+      }
+      const toDateParamIdx = params.filters.findIndex(param => param.name === 'toDate')
+      if (toDateParamIdx >= 0) {
+        let toDateVal = new Date(params.filters[toDateParamIdx].value)
+        params.filters.splice(toDateParamIdx, 1)
+
+        params.filters.push({
+          name: 'createdAt',
+          operator: 'lt',
+          value: new Date(toDateVal.setDate(toDateVal.getDate() + 1)).toISOString(),
+          relation: false
+        })
+      }
+
+      let refNoFilter = params.filters.find(x => x.name == 'refNo')
+      let refNo2Filter = params.filters.find(x => x.name == 'refNo2')
+      let refNo3Filter = params.filters.find(x => x.name == 'refNo3')
+
+      params.filters = params.filters.filter(x => x.name != 'refNo' && x.name != 'refNo2' && x.name != 'refNo3')
+
+      const qb: any = getRepository(DeliveryOrder).createQueryBuilder('do')
+      buildQuery(qb, params, context)
+      qb.addSelect('COALESCE("cc".rank, 99999)', 'rank')
+      qb.leftJoinAndSelect('do.domain', 'domain')
+      qb.leftJoinAndSelect('do.bizplace', 'bizplace')
+      qb.leftJoinAndSelect('do.releaseGood', 'releaseGood')
+      qb.leftJoinAndSelect('do.transportDriver', 'td')
+      qb.leftJoinAndSelect('do.transportVehicle', 'th')
+      qb.leftJoinAndSelect('do.orderInventories', 'oi')
+      qb.leftJoinAndSelect('oi.inventory', 'inv')
+      qb.leftJoinAndSelect('inv.product', 'prd')
+      qb.leftJoinAndSelect('do.creator', 'creator')
+      qb.leftJoinAndSelect('do.updater', 'updater')
+      qb.leftJoin(
+        subQuery => {
+          return subQuery
+            .select(`ccd.rank`, 'rank')
+            .addSelect(`ccd.name`, 'status')
+            .from(`common_code_details`, 'ccd')
+            .innerJoin(`ccd.commonCode`, 'cc')
+            .where(`ccd.domain_id = :domainId`, { domainId: domain.id })
+            .andWhere(`cc.name = 'DELIVERY_STATUS'`)
+        },
+        'cc',
+        'cc.status = do.status'
+      )
+
+      if (refNoFilter?.value) {
+        qb.andWhere('releaseGood.ref_no ilike :refNo', { refNo: refNoFilter.value })
+      }
+      if (refNo2Filter?.value) {
+        qb.andWhere('releaseGood.ref_no_2 ilike :refNo2', { refNo2: refNo2Filter.value })
+      }
+      if (refNo3Filter?.value) {
+        qb.andWhere('releaseGood.ref_no_3 ilike :refNo3', { refNo3: refNo3Filter.value })
+      }
+
+      const arrChildSortData = ['refNo', 'refNo2', 'refNo3']
+      const arrNameSortData = ['bizplace', 'releaseGood', 'updater']
+      const sort = (params.sortings || []).reduce(
+        (acc, sort) => ({
+          ...acc,
+          [arrChildSortData.indexOf(sort.name) >= 0
+            ? 'releaseGood.' + sort.name
+            : arrNameSortData.indexOf(sort.name) >= 0
+            ? sort.name + '.name'
+            : 'do.' + sort.name]: sort.desc ? 'DESC' : 'ASC'
+        }),
+        params.sortings.length < 1 ? { rank: 'ASC', 'do.createdAt': 'DESC' } : {}
+      )
+
+      qb.orderBy(sort)
+
+      const [items, total] = await qb.getManyAndCount()
+      return { items, total }
+    } catch (error) {
+      debug('deliveryOrders', error.toString())
+      throw error
+    }
+  }
+
   @FieldResolver(type => Domain)
   async domain(@Root() deliveryOrder: DeliveryOrder): Promise<Domain> {
     return await getRepository(Domain).findOne(deliveryOrder.domainId)

package/server/service/delivery-order/index.ts

@@ -1,11 +1,9 @@
 import { DeliveryOrder } from './delivery-order'
 import { DeliveryOrderMutation } from './delivery-order-mutation'
 import { DeliveryOrderQuery } from './delivery-order-query'
-import { DeliveryOrderSummaryReport } from './delivery-order-summary-report'
 
 export const entities = [DeliveryOrder]
-export const resolvers = [DeliveryOrderQuery, DeliveryOrderMutation, DeliveryOrderSummaryReport]
+export const resolvers = [DeliveryOrderQuery, DeliveryOrderMutation]
 
 export * from './delivery-order-mutation'
 export * from './delivery-order-query'
-export * from './delivery-order-summary-report'

package/server/service/index.ts

@@ -125,7 +125,6 @@ export * from './claim-order/claim-order-query'
 export * from './claim/claim-query'
 export * from './collection-order/collection-order-query'
 export * from './delivery-order/delivery-order-query'
-export * from './delivery-order/delivery-order-summary-report'
 export * from './goods-receival-note/goods-receival-note-query'
 export * from './inventory-check/inventory-check-query'
 export * from './invoice/invoice-query'

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

@@ -133,7 +133,7 @@ export class ReleaseGoodMutation {
           context,
           tx
         )
-      } catch (error) {}
+      } catch (error) { }
 
     if (errorsCaught.length)
       throw new ValidationError({
@@ -196,12 +196,12 @@ export class ReleaseGoodMutation {
   ): Promise<ReleaseGood> {
     const { tx, domain, user } = context.state
     let foundReleaseGood = await tx.getRepository(ReleaseGood).findOne({
-      where: { name: releaseGood.name, domain },
+      where: { id: releaseGood.id, domain },
       relations: ['shippingOrder']
     })
 
     if (!foundReleaseGood) {
-      throw new Error(`Release order ${releaseGood.name} is not found.`)
+      throw new Error(`Release order ${releaseGood.id} is not found.`)
     }
 
     // case to update existing shippingOrder
@@ -362,16 +362,11 @@ export async function deleteReleaseGood(tx: EntityManager, name: string, user: U
     await tx.getRepository(OrderVas).delete({ id: In(vasIds) })
   }
 
-  // 4. if there is SO, delete SO
-  if (foundSO) {
-    await tx.getRepository(ShippingOrder).delete({ domain, id: foundSO.id })
-  }
-
   if (foundAttachment) {
     await tx.getRepository(Attachment).delete({ domain, id: foundAttachment.id })
   }
 
-  // 5. Remove relation with GAN if it's cross docking
+  // 4. Remove relation with GAN if it's cross docking
   if (foundReleaseOrder.crossDocking && foundReleaseOrder.arrivalNotice?.id) {
     let arrivalNotice: ArrivalNotice = foundReleaseOrder.arrivalNotice
     arrivalNotice.releaseGood = null
@@ -382,6 +377,11 @@ export async function deleteReleaseGood(tx: EntityManager, name: string, user: U
   } else {
     await tx.getRepository(ReleaseGood).delete({ domain, name })
   }
+
+  // 5. if there is SO, delete SO
+  if (foundSO) {
+    await tx.getRepository(ShippingOrder).delete({ domain, id: foundSO.id })
+  }
   return true
 }
 
@@ -741,26 +741,25 @@ export async function confirmReleaseGood(name: string, context: any, tx?: Entity
 
   let foundReleaseGood: ReleaseGood = await tx.getRepository(ReleaseGood).findOne({
     where: { name, status: ORDER_STATUS.PENDING },
-    relations: [
-      'domain',
-      'bizplace',
-      'bizplace.domain',
-      'bizplace.company',
-      'bizplace.company.domain',
-      'orderProducts',
-      'orderProducts.product',
-      'orderProducts.product.productDetails',
-      'orderInventories',
-      'orderInventories.product',
-      'orderVass'
-    ]
+    relations: ['domain', 'bizplace', 'bizplace.domain', 'bizplace.company', 'bizplace.company.domain', 'orderVass']
   })
 
   if (!foundReleaseGood) throw new Error(`Release good order doesn't exists.`)
-  let foundOIs: OrderInventory[] = foundReleaseGood.orderInventories
+
+  // query orderInventories separately from releaseGood to reduce resource usage
+  let foundOIs: OrderInventory[] = await tx.getRepository(OrderInventory).find({
+    where: { domain, releaseGood: foundReleaseGood },
+    relations: ['product']
+  })
+
+  // query orderProducts separately from releaseGood to reduce resource usage
+  let foundOPs: OrderProduct[] = await tx.getRepository(OrderProduct).find({
+    where: { domain, releaseGood: foundReleaseGood },
+    relations: ['product', 'product.productDetails']
+  })
+
   let foundBundleInfo: any[] = JSON.parse(foundReleaseGood.bundleInfo)
   let foundOVs: OrderVas[] = foundReleaseGood.orderVass
-  let foundOPs: OrderProduct[] = foundReleaseGood.orderProducts
   let customerBizplace: Bizplace = foundReleaseGood.bizplace
   const companyDomain: Domain = customerBizplace?.company.domain
   const sellercraft: Sellercraft = await tx
@@ -770,7 +769,7 @@ export async function confirmReleaseGood(name: string, context: any, tx?: Entity
   if (foundReleaseGood.type == 'b2c') {
     if (sellercraft) {
       const sellercraftCtrl: SellercraftController = new SellercraftController(tx, domain, user)
-      foundReleaseGood = await sellercraftCtrl.packOrder(sellercraft, foundReleaseGood)
+      foundReleaseGood = await sellercraftCtrl.packOrder(sellercraft, { ...foundReleaseGood, orderProducts: foundOPs })
     } else {
       // find for any existing marketplace store connections
       let marketplaceStores: MarketplaceStore[] = await tx.getRepository(MarketplaceStore).find({

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

@@ -261,6 +261,8 @@ export class ReleaseGoodQuery {
 
       const statusFilter = params.filters.some(e => e.name === 'status')
       const bizplaceFilter = params.filters.find(param => param.name === 'bizplaceId')
+      const noOfItemsFilter = params.filters.find(param => param.name === 'noOfItems')
+      const skuFilter = params.filters.find(param => param.name === 'sku')
 
       if (await checkUserBelongsDomain(domain, user)) {
         if (!statusFilter && !params.filters.some(e => e.name === 'name')) {
@@ -282,6 +284,10 @@ export class ReleaseGoodQuery {
         })
       }
 
+      if (skuFilter) {
+        params.filters = params.filters.filter(param => param.name !== 'sku')
+      }
+
       const fromDateParamIdx = params.filters.findIndex(param => param.name === 'fromDate')
       if (fromDateParamIdx >= 0) {
         let fromDateVal = new Date(params.filters[fromDateParamIdx].value)
@@ -308,6 +314,10 @@ export class ReleaseGoodQuery {
         })
       }
 
+      if (noOfItemsFilter && noOfItemsFilter.value == 1) {
+        params.filters.find(param => param.name === 'noOfItems').operator = 'eq'
+      }
+
       const qb: SelectQueryBuilder<ReleaseGood> = getRepository(ReleaseGood).createQueryBuilder('rg')
       buildQuery(qb, params, context)
       qb.addSelect('COALESCE("cc".rank, 99999)', 'rank')
@@ -332,7 +342,20 @@ export class ReleaseGoodQuery {
         'cc.status = rg.status'
       )
 
-      const arrChildSortData = ['bizplace']
+      if (skuFilter) {
+        qb.andWhere(
+          `
+        exists (select * from  order_inventories oi  
+        inner join products p on oi.product_id = p.id
+        inner join inventories i on i.product_id = p.id
+        where oi.release_good_id = rg.id
+        and lower(p.sku) like :sku)
+        `,
+          { sku: skuFilter.value.toLowerCase() }
+        )
+      }
+
+      const arrChildSortData = ['bizplace', 'creator']
       const sort = (params.sortings || []).reduce(
         (acc, sort) => ({
           ...acc,
@@ -340,7 +363,7 @@ export class ReleaseGoodQuery {
             ? 'DESC'
             : 'ASC'
         }),
-        !params.sortings.some(e => e.name === 'status') ? { rank: 'ASC' } : {}
+        params.sortings.length < 1 ? { rank: 'ASC', 'rg.createdAt': 'DESC' } : {}
       )
 
       qb.orderBy(sort)

package/server/service/delivery-order/delivery-order-summary-report.ts

@@ -1,152 +0,0 @@
-import { Args, Ctx, Query, Resolver } from 'type-graphql'
-import { getRepository } from 'typeorm'
-
-import { User } from '@things-factory/auth-base'
-import { getPermittedBizplaceIds } from '@things-factory/biz-base'
-import { buildQuery, convertListParams, Domain, ListParam } from '@things-factory/shell'
-
-import { ReleaseGood } from '../release-good/release-good'
-import { DeliveryOrder } from './delivery-order'
-import { DeliveryOrderList } from './delivery-order-types'
-
-const debug = require('debug')('things-factory:sales-base:delivery-orders')
-
-@Resolver(DeliveryOrder)
-export class DeliveryOrderSummaryReport {
-  @Query(returns => DeliveryOrderList)
-  async deliveryOrderSummaryReport(@Ctx() context: any, @Args() params: ListParam): Promise<DeliveryOrderList> {
-    try {
-      const { domain, user }: { domain: Domain; user: User } = context.state
-
-      const bizplaceFilter = params.filters.find(param => param.name === 'bizplaceId')
-      if (!bizplaceFilter) {
-        params.filters.push({
-          name: 'bizplaceId',
-          operator: 'in',
-          value: await getPermittedBizplaceIds(domain, user),
-          relation: false
-        })
-      }
-
-      const releaseGoodParam = params.filters.find(param => param.name === 'releaseGoodNo')
-      if (releaseGoodParam) {
-        let arrFilters = []
-        params.filters.splice(
-          params.filters.findIndex(item => item.name == 'releaseGoodNo'),
-          1
-        )
-        arrFilters.push({ ...releaseGoodParam, name: 'name' })
-
-        const foundReleaseGoods: ReleaseGood[] = await getRepository(ReleaseGood).find({
-          ...convertListParams({ filters: arrFilters })
-        })
-
-        if (foundReleaseGoods && foundReleaseGoods.length) {
-          params.filters.push({
-            name: 'releaseGoodId',
-            operator: 'in',
-            value: foundReleaseGoods.map((releaseGood: ReleaseGood) => releaseGood.id),
-            relation: false
-          })
-        }
-      }
-
-      const tzOffsetIdx = params.filters.findIndex(param => param.name === 'tzoffset')
-      let tzOffset = 0
-      if (tzOffsetIdx >= 0) {
-        tzOffset = params.filters[tzOffsetIdx].value
-        params.filters.splice(tzOffsetIdx, 1)
-      }
-
-      const fromDateParamIdx = params.filters.findIndex(param => param.name === 'fromDate')
-      if (fromDateParamIdx >= 0) {
-        let fromDateVal = new Date(params.filters[fromDateParamIdx].value)
-        params.filters.splice(fromDateParamIdx, 1)
-
-        params.filters.push({
-          name: 'createdAt',
-          operator: 'gte',
-          value: fromDateVal.toISOString(),
-          relation: false
-        })
-      }
-      const toDateParamIdx = params.filters.findIndex(param => param.name === 'toDate')
-      if (toDateParamIdx >= 0) {
-        let toDateVal = new Date(params.filters[toDateParamIdx].value)
-        params.filters.splice(toDateParamIdx, 1)
-
-        params.filters.push({
-          name: 'createdAt',
-          operator: 'lt',
-          value: new Date(toDateVal.setDate(toDateVal.getDate() + 1)).toISOString(),
-          relation: false
-        })
-      }
-
-      let refNoFilter = params.filters.find(x => x.name == 'refNo')
-      let refNo2Filter = params.filters.find(x => x.name == 'refNo2')
-      let refNo3Filter = params.filters.find(x => x.name == 'refNo3')
-
-      params.filters = params.filters.filter(x => x.name != 'refNo' && x.name != 'refNo2' && x.name != 'refNo3')
-
-      const qb: any = getRepository(DeliveryOrder).createQueryBuilder('do')
-      buildQuery(qb, params, context)
-      qb.addSelect('COALESCE("cc".rank, 99999)', 'rank')
-      qb.leftJoinAndSelect('do.domain', 'domain')
-      qb.leftJoinAndSelect('do.bizplace', 'bizplace')
-      qb.leftJoinAndSelect('do.releaseGood', 'releaseGood')
-      qb.leftJoinAndSelect('do.transportDriver', 'td')
-      qb.leftJoinAndSelect('do.transportVehicle', 'th')
-      qb.leftJoinAndSelect('do.orderInventories', 'oi')
-      qb.leftJoinAndSelect('oi.inventory', 'inv')
-      qb.leftJoinAndSelect('inv.product', 'prd')
-      qb.leftJoinAndSelect('do.creator', 'creator')
-      qb.leftJoinAndSelect('do.updater', 'updater')
-      qb.leftJoin(
-        subQuery => {
-          return subQuery
-            .select(`ccd.rank`, 'rank')
-            .addSelect(`ccd.name`, 'status')
-            .from(`common_code_details`, 'ccd')
-            .innerJoin(`ccd.commonCode`, 'cc')
-            .where(`ccd.domain_id = :domainId`, { domainId: domain.id })
-            .andWhere(`cc.name = 'DELIVERY_STATUS'`)
-        },
-        'cc',
-        'cc.status = do.status'
-      )
-
-      if (refNoFilter?.value) {
-        qb.andWhere('releaseGood.ref_no ilike :refNo', { refNo: refNoFilter.value })
-      }
-      if (refNo2Filter?.value) {
-        qb.andWhere('releaseGood.ref_no_2 ilike :refNo2', { refNo2: refNo2Filter.value })
-      }
-      if (refNo3Filter?.value) {
-        qb.andWhere('releaseGood.ref_no_3 ilike :refNo3', { refNo3: refNo3Filter.value })
-      }
-
-      const arrChildSortData = ['refNo', 'refNo2', 'refNo3']
-      const arrNameSortData = ['bizplace', 'releaseGood', 'updater']
-      const sort = (params.sortings || []).reduce(
-        (acc, sort) => ({
-          ...acc,
-          [arrChildSortData.indexOf(sort.name) >= 0
-            ? 'releaseGood.' + sort.name
-            : arrNameSortData.indexOf(sort.name) >= 0
-            ? sort.name + '.name'
-            : 'do.' + sort.name]: sort.desc ? 'DESC' : 'ASC'
-        }),
-        params.sortings.length < 1 ? { rank: 'ASC', 'do.createdAt': 'DESC' } : {}
-      )
-
-      qb.orderBy(sort)
-
-      const [items, total] = await qb.getManyAndCount()
-      return { items, total }
-    } catch (error) {
-      debug('deliveryOrders', error.toString())
-      throw error
-    }
-  }
-}