@things-factory/sales-base 8.0.3 → 8.0.5

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

@@ -1,631 +0,0 @@
-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
-  }
-}