@things-factory/sales-base 8.0.0-beta.9 → 8.0.0

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

@@ -0,0 +1,631 @@
+import { Arg, Args, Ctx, FieldResolver, Query, Resolver, Root } from 'type-graphql'
+import { EntityManager, In, Not, OrderByCondition, Repository } from 'typeorm'
+
+import { Attachment } from '@things-factory/attachment-base'
+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,
+  getRepository,
+  ListParam,
+  Pagination,
+  Sorting
+} from '@things-factory/shell'
+import { Inventory } from '@things-factory/warehouse-base'
+
+import { ORDER_STATUS } from '../../constants'
+import { OrderInventory } from '../order-inventory/order-inventory'
+import { OrderInventoryList } from '../order-inventory/order-inventory-types'
+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 DeliveryOrderQuery {
+  @Query(returns => DeliveryOrderList)
+  async deliveryOrders(
+    @Ctx() context: ResolverContext,
+    @Args(type => ListParam) params: ListParam
+  ): Promise<DeliveryOrderList> {
+    try {
+      const { domain, user, tx } = 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 },
+            {
+              searchables: ['name', 'releaseGoodNo', 'truckNo']
+            }
+          )
+        })
+
+        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')
+      let orderProductsApiFilter = params.filters.find(x => x.name == 'orderProductsApi')
+
+      params.filters = params.filters.filter(
+        x => x.name != 'refNo' && x.name != 'refNo2' && x.name != 'refNo3' && x.name != 'orderProductsApi'
+      )
+
+      const qb: any = getRepository(DeliveryOrder).createQueryBuilder('do')
+      buildQuery(qb, params, context)
+      qb.addSelect('COALESCE("cc".rank, 99999)', 'rank')
+      qb.leftJoinAndSelect('do.bizplace', 'bizplace')
+      qb.leftJoinAndSelect('do.releaseGood', 'releaseGood')
+      qb.leftJoinAndSelect('do.transportDriver', 'td')
+      qb.leftJoinAndSelect('do.transportVehicle', 'th')
+      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'
+      )
+
+      // was add specifically for API usage, do we really need
+      // orderProducts over orderInventories? else we should remove this
+      if (orderProductsApiFilter?.value) {
+        qb.innerJoinAndSelect('releaseGood.orderProducts', 'orderProducts')
+      }
+
+      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: OrderByCondition = (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)
+
+      let [items, total] = await qb.getManyAndCount()
+      if (orderProductsApiFilter?.value) {
+        items = await Promise.all(
+          items.map(async itm => {
+            const qb: any = getRepository(OrderInventory).createQueryBuilder('OrderInventory')
+
+            let orderInventories: any[] = await qb
+              .leftJoinAndSelect('OrderInventory.product', 'Product')
+              .leftJoinAndSelect('OrderInventory.orderToteItems', 'OrderToteItems')
+              .leftJoinAndSelect('OrderToteItems.orderTote', 'OrderTote')
+              .leftJoinAndSelect('OrderTote.orderToteSeals', 'OrderToteSeals')
+              .where('OrderInventory.delivery_order_id = :deliveryOrderId', { deliveryOrderId: itm.id })
+              .andWhere('OrderInventory.domain_id = :domainId', { domainId: domain.id })
+              .getMany()
+
+            return {
+              ...itm,
+              orderInventories
+            }
+          })
+        )
+      }
+
+      return { items, total }
+    } catch (error) {
+      debug('deliveryOrders', error.toString())
+      throw error
+    }
+  }
+
+  @Query(returns => DeliveryOrder)
+  async deliveryOrder(@Arg('name') name: string, @Ctx() context: ResolverContext): Promise<DeliveryOrder> {
+    const { domain } = context.state
+
+    const foundDO = await getRepository(DeliveryOrder).findOne({
+      where: {
+        domain: { id: domain.id },
+        name
+      },
+      relations: ['domain', 'bizplace', 'transportDriver', 'transportVehicle', 'releaseGood', 'creator', 'updater']
+    })
+
+    let foundAttachments = []
+    if (foundDO) {
+      foundAttachments = await getRepository(Attachment).find({
+        where: {
+          domain: { id: domain.id },
+          refBy: foundDO.id
+        }
+      })
+    }
+
+    return { ...foundDO, attachments: foundAttachments }
+  }
+
+  @Query(returns => DeliveryOrderList)
+  async deliveryOrderRequests(
+    @Ctx() context: ResolverContext,
+    @Arg('filters', type => [Filter], { nullable: true }) filters?: Filter[],
+    @Arg('pagination', type => Pagination, { nullable: true }) pagination?: Pagination,
+    @Arg('sortings', type => [Sorting], { nullable: true }) sortings?: Sorting[]
+  ): Promise<DeliveryOrderList> {
+    const { domain, user } = context.state
+
+    const convertedParams = convertListParams({ filters, pagination, sortings })
+
+    if (!convertedParams.where || !convertedParams.where.status) {
+      convertedParams.where.status = Not(In([ORDER_STATUS.PENDING, ORDER_STATUS.EDITING]))
+    }
+
+    ;(convertedParams as any).bizplace = In(await getPermittedBizplaceIds(domain, user))
+
+    const [items, total] = await getRepository(DeliveryOrder).findAndCount({
+      ...convertedParams,
+      relations: ['domain', 'bizplace', 'releaseGood', 'transportDriver', 'transportVehicle', 'creator', 'updater']
+    })
+
+    return { items, total }
+  }
+
+  @Query(returns => DeliveryOrderList)
+  async deliveryOrderByReleaseGood(
+    @Arg('releaseGoodNo') releaseGoodNo: string,
+    @Ctx() context: ResolverContext
+  ): Promise<DeliveryOrderList> {
+    const releaseGood: ReleaseGood = await getRepository(ReleaseGood).findOne({
+      where: { name: releaseGoodNo }
+    })
+
+    return await deliveryOrderByReleaseGood(releaseGood)
+  }
+
+  @Query(returns => OrderInventoryList)
+  async deliveryOrderItems(@Arg('name') name: string, @Ctx() context: ResolverContext): Promise<OrderInventoryList> {
+    const { domain } = context.state
+    const deliveryOrder: DeliveryOrder = await getRepository(DeliveryOrder).findOne({
+      where: { domain: { id: domain.id }, name }
+    })
+
+    let [items, total] = await getRepository(OrderInventory).findAndCount({
+      where: { domain: { id: domain.id }, deliveryOrder: { id: deliveryOrder.id } },
+      relations: ['inventory', 'inventory.product', 'inventory.reusablePallet']
+    })
+
+    items = items
+      .map((oi: OrderInventory) => {
+        const inventory: Inventory = oi.inventory
+        const product: Product = inventory.product
+        return {
+          inventory: inventory,
+          productName: `${product.name} (${product.description})`,
+          packingType: inventory.packingType,
+          batchId: inventory.batchId,
+          releaseQty: oi.releaseQty,
+          releaseUomValue: oi.releaseUomValue,
+          remark: oi.remark,
+          crossDocking: oi.crossDocking,
+          pallet: inventory?.reusablePallet && inventory?.reusablePallet?.name ? inventory.reusablePallet.name : ''
+        }
+      })
+      .reduce((newItem, item) => {
+        var foundItem = newItem.find(
+          newItem =>
+            newItem.productName === item.productName &&
+            newItem.batchId === item.batchId &&
+            newItem.crossDocking === item.crossDocking &&
+            newItem.pallet === item.pallet
+        )
+        if (!foundItem) {
+          foundItem = {
+            inventory: item.inventory,
+            productName: item.productName,
+            packingType: item.packingType,
+            batchId: item.batchId,
+            releaseQty: item.releaseQty,
+            releaseUomValue: item.releaseUomValue,
+            palletQty: 1,
+            remark: item.remark,
+            crossDocking: item.crossDocking,
+            pallet: item.pallet
+          }
+
+          newItem.push(foundItem)
+          return newItem
+        } else {
+          return newItem.map(ni => {
+            if (
+              ni.productName === item.productName &&
+              ni.batchId === item.batchId &&
+              ni.crossDocking === item.crossDocking &&
+              ni.pallet === item.pallet
+            ) {
+              return {
+                ...ni,
+                palletQty: ni.palletQty + 1,
+                releaseQty: ni.releaseQty + item.releaseQty,
+                releaseUomValue: ni.releaseUomValue + item.releaseUomValue
+              }
+            } else {
+              return ni
+            }
+          })
+        }
+      }, [])
+
+    items = items.map((prod: any) => {
+      return {
+        ...prod,
+        systemRemark: prod?.remark
+          ? prod.remark
+          : prod.crossDocking
+            ? prod.pallet === ''
+              ? `${prod.palletQty} PALLET(S) [C/D]`
+              : `${prod.palletQty} PALLET(S) (${prod.pallet}) [C/D]`
+            : prod.pallet === ''
+              ? `${prod.palletQty} PALLET(S)`
+              : `${prod.palletQty} PALLET(S) (${prod.pallet})`
+      }
+    })
+
+    return { items, total }
+  }
+
+  @Query(returns => OrderInventoryList)
+  async manualDeliveryOrderItems(
+    @Arg('name') name: string,
+    @Ctx() context: ResolverContext
+  ): Promise<OrderInventoryList> {
+    const { domain } = context.state
+    const deliveryOrder: DeliveryOrder = await getRepository(DeliveryOrder).findOne({
+      where: { domain: { id: domain.id }, name }
+    })
+
+    let [items, total] = await getRepository(OrderInventory).findAndCount({
+      where: { domain: { id: domain.id }, deliveryOrder: { id: deliveryOrder.id } },
+      relations: ['product']
+    })
+
+    items = items
+      .map((oi: OrderInventory) => {
+        const product: Product = oi.product
+        return {
+          inventory: oi.inventory,
+          productId: product.id,
+          productName: `${product.name} (${product.description})`,
+          packingType: oi.packingType,
+          batchId: oi.batchId,
+          releaseQty: oi.releaseQty,
+          releaseUomValue: oi.releaseUomValue,
+          remark: oi.remark,
+          crossDocking: oi.crossDocking,
+          pallet: ''
+        }
+      })
+      .reduce((newItem, item) => {
+        var foundItem = newItem.find(
+          newItem =>
+            newItem.productName === item.productName &&
+            newItem.batchId === item.batchId &&
+            newItem.crossDocking === item.crossDocking &&
+            newItem.pallet === item.pallet
+        )
+        if (!foundItem) {
+          foundItem = {
+            inventory: item.inventory,
+            productId: item.productId,
+            productName: item.productName,
+            packingType: item.packingType,
+            batchId: item.batchId,
+            releaseQty: item.releaseQty,
+            releaseUomValue: item.releaseUomValue,
+            palletQty: 1,
+            remark: item.remark,
+            crossDocking: item.crossDocking,
+            pallet: item.pallet
+          }
+
+          newItem.push(foundItem)
+          return newItem
+        } else {
+          return newItem.map(ni => {
+            if (
+              ni.productName === item.productName &&
+              ni.batchId === item.batchId &&
+              ni.crossDocking === item.crossDocking &&
+              ni.pallet === item.pallet
+            ) {
+              return {
+                ...ni,
+                palletQty: ni.palletQty + 1,
+                releaseQty: ni.releaseQty + item.releaseQty,
+                releaseUomValue: ni.releaseUomValue + item.releaseUomValue
+              }
+            } else {
+              return ni
+            }
+          })
+        }
+      }, [])
+
+    items = items.map((prod: any) => {
+      return {
+        ...prod,
+        systemRemark: prod?.remark
+          ? prod.remark
+          : prod.crossDocking
+            ? prod.pallet === ''
+              ? `${prod.palletQty} PALLET(S) [C/D]`
+              : `${prod.palletQty} PALLET(S) (${prod.pallet}) [C/D]`
+            : prod.pallet === ''
+              ? `${prod.palletQty} PALLET(S)`
+              : `${prod.palletQty} PALLET(S) (${prod.pallet})`
+      }
+    })
+
+    return { items, total }
+  }
+
+  @Query(returns => DeliveryOrderList)
+  async deliveryOrderReport(
+    @Ctx() context: ResolverContext,
+    @Args(type => ListParam) params: ListParam
+  ): Promise<DeliveryOrderList> {
+    try {
+      const { domain, 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: OrderByCondition = (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).findOneBy({ id: deliveryOrder.domainId })
+  }
+
+  @FieldResolver(type => User)
+  async creator(@Root() deliveryOrder: DeliveryOrder): Promise<User> {
+    return await getRepository(User).findOneBy({ id: deliveryOrder.creatorId })
+  }
+
+  @FieldResolver(type => User)
+  async updater(@Root() deliveryOrder: DeliveryOrder): Promise<User> {
+    return await getRepository(User).findOneBy({ id: deliveryOrder.updaterId })
+  }
+}
+
+export async function deliveryOrderByReleaseGood(releaseGood: ReleaseGood, trxMgr?: EntityManager): Promise<any> {
+  const doRepo: Repository<DeliveryOrder> = trxMgr?.getRepository(DeliveryOrder) || getRepository(DeliveryOrder)
+  const oiRepo: Repository<OrderInventory> = trxMgr?.getRepository(OrderInventory) || getRepository(OrderInventory)
+
+  let [items, total] = await doRepo.findAndCount({
+    where: { releaseGood: { id: releaseGood.id } },
+    relations: ['domain', 'bizplace', 'releaseGood', 'transportDriver', 'transportVehicle', 'creator', 'updater']
+  })
+
+  items = await Promise.all(
+    items.map(async (deliveryOrder: DeliveryOrder) => {
+      return {
+        ...deliveryOrder,
+        truck: deliveryOrder?.truckNo || deliveryOrder.transportVehicle?.name || null,
+        targetInventories: await oiRepo.find({
+          where: { deliveryOrder: { id: deliveryOrder.id } },
+          relations: ['domain', 'bizplace', 'releaseGood', 'inventory']
+        })
+      }
+    })
+  )
+
+  return {
+    items,
+    total
+  }
+}