@things-factory/sales-base 5.0.0-alpha.24 → 5.0.0-alpha.27

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

@@ -1,5 +1,5 @@
 import { Arg, Args, Ctx, FieldResolver, Query, Resolver, Root } from 'type-graphql'
-import { Brackets, getRepository, Like, SelectQueryBuilder } from 'typeorm'
+import { Brackets, getRepository, Like, SelectQueryBuilder, In, Not, IsNull } from 'typeorm'
 
 import { User } from '@things-factory/auth-base'
 import { getPermittedBizplaceIds } from '@things-factory/biz-base'
@@ -11,6 +11,7 @@ import { ArrivalNotice } from '../arrival-notice/arrival-notice'
 import { OrderInventoryList } from '../order-inventory/order-inventory-types'
 import { ReleaseGood } from '../release-good/release-good'
 import { OrderInventory } from './order-inventory'
+import { Location } from '@things-factory/warehouse-base'
 
 interface filterInterface {
   name: string
@@ -245,18 +246,18 @@ export class OrderInventoryQuery {
     @Arg('pagination', type => Pagination, { nullable: true }) pagination?: Pagination,
     @Arg('sortings', type => [Sorting], { nullable: true }) sortings?: Sorting[]
   ): Promise<OrderInventoryList> {
-    const { domain, user }: { domain: Domain; user: User } = context.state
     const { page, limit }: { page: number; limit: number } = pagination
 
     try {
       const productFilter = filters.find(x => x.name == 'productInfo')
       const roNoFilter = filters.find(x => x.name == 'roNo')
+      const refNoFilter = filters.find(x => x.name == 'refNo')
       const binLocationFilter = filters.find(x => x.name == 'binLocation')
       const lotIdFilter = filters.find(x => x.name == 'palletId')
       const cartonIdFilter = filters.find(x => x.name == 'cartonId')
 
       filters = filters.filter(
-        filter => ['productInfo', 'roNo', 'binLocation', 'palletId', 'cartonId'].indexOf(filter.name) == -1
+        filter => ['productInfo', 'roNo', 'refNo', 'binLocation', 'palletId', 'cartonId'].indexOf(filter.name) == -1
       )
 
       const params = { filters, pagination }
@@ -305,6 +306,10 @@ export class OrderInventoryQuery {
         qb.andWhere('Lower(rg.name) LIKE :roNo', { roNo: roNoFilter.value.toLowerCase() })
       }
 
+      if (refNoFilter) {
+        qb.andWhere('Lower(rg.ref_no) LIKE :refNo', { refNo: refNoFilter.value.toLowerCase() })
+      }
+
       if (binLocationFilter) {
         qb.andWhere('Lower(bin_loc.name) LIKE :binLocation', { binLocation: binLocationFilter.value.toLowerCase() })
       }
@@ -322,10 +327,6 @@ export class OrderInventoryQuery {
           const order: string = sort.desc ? 'DESC' : 'ASC'
 
           switch (sort.name) {
-            case 'releaseOrderNo':
-              acc = { ...acc, ['rg.name']: order }
-              break
-
             case 'productSku':
               acc = { ...acc, ['Product.sku']: order }
               break
@@ -341,14 +342,6 @@ export class OrderInventoryQuery {
               acc = { ...acc, ['bin_loc.name']: order }
               break
 
-            case 'palletId':
-              acc = { ...acc, ['inv.pallet_id']: order }
-              break
-
-            case 'cartonId':
-              acc = { ...acc, ['inv.carton_id']: order }
-              break
-
             default:
               acc = { ...acc, [`oi.${sort.name}`]: order }
               break
@@ -386,6 +379,7 @@ export class OrderInventoryQuery {
               releaseGood: {
                 id: item.rg_id,
                 name: item.rg_name,
+                refNo: item.rg_ref_no,
                 description: item.rg_description
               },
               inventory: {
@@ -406,6 +400,231 @@ export class OrderInventoryQuery {
     }
   }
 
+  @Query(returns => OrderInventoryList)
+  async orderInventoriesOfMultipleReleaseOrders(
+    @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')
+      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
+        })
+      } 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 (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
+          }
+
+          return acc
+        }, {})
+        qb.orderBy(sorter)
+      }
+
+      const [items, total] = await qb.getManyAndCount()
+
+      return { items, total }
+    } catch (e) {
+      throw e
+    }
+  }
+
+  @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) {
+          case 'roSku':
+            sortings.push({ name: 'releaseGood', desc: true })
+            sortings.push({ name: 'productSku', desc: false })
+            break
+
+          case 'roBin':
+            sortings.push({ name: 'releaseGood', desc: true })
+            sortings.push({ name: 'binNumber', desc: false })
+            break
+
+          case 'skuRo':
+            sortings.push({ name: 'productSku', desc: false })
+            sortings.push({ name: 'releaseGood', desc: true })
+            break
+
+          case 'skuBin':
+            sortings.push({ name: 'productSku', desc: false })
+            sortings.push({ name: 'binNumber', desc: false })
+            break
+
+          case 'binSku':
+            sortings.push({ name: 'binNumber', desc: false })
+            sortings.push({ name: 'productSku', desc: false })
+            break
+
+          case 'binRo':
+            sortings.push({ name: 'binNumber', desc: false })
+            sortings.push({ name: 'releaseGood', desc: true })
+            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 })
+      }
+
+      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 'releaseGood':
+              acc = { ...acc, ['rg.created_at']: order }
+              break
+
+            case 'productSku':
+              acc = { ...acc, ['Product.sku']: order }
+              break
+
+            case 'binNumber':
+              acc = { ...acc, ['bin_loc.name']: order }
+              break
+          }
+
+          return acc
+        }, {})
+        qb.orderBy(sorter)
+      }
+
+      const [items, total] = await qb.getManyAndCount()
+
+      return { items, total }
+    } catch (e) {
+      throw e
+    }
+  }
+
   @FieldResolver(type => Domain)
   async domain(@Root() orderInventory: OrderInventory): Promise<Domain> {
     return await getRepository(Domain).findOne(orderInventory.domainId)

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

@@ -223,4 +223,7 @@ export class OrderInventoryPatch {
 
   @Field({ nullable: true })
   status: string
+
+  @Field({ nullable: true })
+  pickingStrategy: string
 }

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

@@ -565,6 +565,10 @@ export async function generateReleaseGoodFunction(
       orderInventories: releaseGood.orderInventories,
       type: releaseGood?.type ? releaseGood.type : 'b2b',
       status: ORDER_STATUS.PENDING,
+      storeName: releaseGood?.storeName,
+      storeId: releaseGood?.storeId,
+      routeId: releaseGood?.routeId,
+      stopId: releaseGood?.stopId,
       creator: user,
       updater: user
     }
@@ -762,7 +766,7 @@ export async function confirmReleaseGood(name: string, context: any, tx?: Entity
   // 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']
+    relations: ['bizplace', 'product', 'product.productDetails']
   })
 
   let foundBundleInfo: any[] = JSON.parse(foundReleaseGood.bundleInfo)

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

@@ -263,6 +263,7 @@ export class ReleaseGoodQuery {
       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')
+      const routeId = params.filters.find(param => param.name === 'routeId')
 
       if (await checkUserBelongsDomain(domain, user)) {
         if (!statusFilter && !params.filters.some(e => e.name === 'name')) {
@@ -288,6 +289,15 @@ export class ReleaseGoodQuery {
         params.filters = params.filters.filter(param => param.name !== 'sku')
       }
 
+      if (routeId) {
+        if (routeId.value == true) {
+          params.filters.find(param => param.name === 'routeId').value = 'null'
+        } else {
+          params.filters.find(param => param.name === 'routeId').operator = 'is_null'
+          params.filters.find(param => param.name === 'routeId').value = null
+        }
+      }
+
       const fromDateParamIdx = params.filters.findIndex(param => param.name === 'fromDate')
       if (fromDateParamIdx >= 0) {
         let fromDateVal = new Date(params.filters[fromDateParamIdx].value)
@@ -389,9 +399,13 @@ export class ReleaseGoodQuery {
     const PROD_ALIAS = 'PROD'
     const GAN_ALIAS = 'GAN'
     const conditions = filters
-    let { batchId = null, containerNo = null, product = [], packingType = null, inventory = [] } = getConditionValues(
-      conditions
-    )
+    let {
+      batchId = null,
+      containerNo = null,
+      product = [],
+      packingType = null,
+      inventory = []
+    } = getConditionValues(conditions)
 
     const SELECT: string = `
       SELECT
@@ -812,9 +826,7 @@ function _extractData(rawData, validatedData) {
   })
 }
 
-function getConditionValues(
-  conditions: Filter[]
-): {
+function getConditionValues(conditions: Filter[]): {
   batchId?: string
   containerNo?: string
   product?: string[]

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

@@ -347,6 +347,18 @@ export class NewReleaseGood {
 
   @Field({ nullable: true })
   errorMsg: string
+
+  @Field({ nullable: true })
+  storeName: string
+
+  @Field({ nullable: true })
+  storeId: string
+
+  @Field({ nullable: true })
+  routeId: string
+
+  @Field({ nullable: true })
+  stopId: string
 }
 
 @InputType()
@@ -503,4 +515,16 @@ export class ReleaseGoodPatch {
 
   @Field({ nullable: true })
   description: string
+
+  @Field({ nullable: true })
+  storeName: string
+
+  @Field({ nullable: true })
+  storeId: string
+
+  @Field({ nullable: true })
+  routeId: string
+
+  @Field({ nullable: true })
+  stopId: string
 }

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

@@ -389,4 +389,20 @@ export class ReleaseGood {
 
   @Field({ nullable: true })
   errorMsg: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  storeId: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  storeName: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  routeId: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  stopId: string
 }