@things-factory/sales-base 4.0.0-y.0 → 4.0.4

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

@@ -0,0 +1,579 @@
+import orderBy from 'lodash/orderBy'
+import { Arg, Args, Ctx, Directive, FieldResolver, Query, Resolver, Root } from 'type-graphql'
+import { EntityManager, getRepository, In, Repository, SelectQueryBuilder } from 'typeorm'
+
+import { Attachment } from '@things-factory/attachment-base'
+import { User } from '@things-factory/auth-base'
+import { Bizplace, getMyBizplace, getPermittedBizplaceIds } from '@things-factory/biz-base'
+import { Product } from '@things-factory/product-base'
+import { buildQuery, Domain, Filter, ListParam, Pagination, Sorting } from '@things-factory/shell'
+import { Inventory } from '@things-factory/warehouse-base'
+
+import { InventoryInfos, OrderInventory, ReleasableInventoryList, ReleaseGoodList, ShippingOrder } from '../'
+import { ATTACHMENT_TYPE, ORDER_INVENTORY_STATUS, ORDER_STATUS } from '../../constants'
+import { ReleaseGood } from './release-good'
+
+@Resolver(ReleaseGood)
+export class ReleaseGoodQuery {
+  @Directive('@privilege(category: "order_customer", privilege: "query")')
+  @Query(returns => ReleaseGoodList)
+  async releaseGoods(@Ctx() context: any, @Args() params: ListParam): Promise<ReleaseGoodList> {
+    try {
+      const { domain, user }: { domain: Domain; user: User } = context.state
+
+      if (!params.filters.find((filter: any) => filter.name === 'bizplace')) {
+        params.filters.push({
+          name: 'bizplaceId',
+          operator: 'in',
+          value: await getPermittedBizplaceIds(domain, user),
+          relation: false
+        })
+      }
+
+      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
+        })
+      }
+
+      const qb: SelectQueryBuilder<ReleaseGood> = getRepository(ReleaseGood).createQueryBuilder('rg')
+      buildQuery(qb, params, context)
+      qb.addSelect('COALESCE("cc".rank, 99999)', 'rank')
+      qb.leftJoinAndSelect('rg.domain', 'domain')
+      qb.leftJoinAndSelect('rg.bizplace', 'bizplace')
+      qb.leftJoinAndSelect('rg.orderInventories', 'oi')
+      qb.leftJoinAndSelect('rg.orderProducts', 'op')
+      qb.leftJoinAndSelect('oi.inventory', 'inv')
+      qb.leftJoinAndSelect('oi.product', 'prod')
+      qb.leftJoinAndSelect('rg.arrivalNotice', 'an')
+      qb.leftJoinAndSelect('rg.creator', 'creator')
+      qb.leftJoinAndSelect('rg.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 = 'RO_LIST_STATUS'`)
+        },
+        'cc',
+        'cc.status = rg.status'
+      )
+
+      const arrChildSortData = ['bizplace']
+      const sort = (params.sortings || []).reduce(
+        (acc, sort) => ({
+          ...acc,
+          [arrChildSortData.indexOf(sort.name) >= 0 ? sort.name + '.name' : 'rg.' + sort.name]: sort.desc
+            ? 'DESC'
+            : 'ASC'
+        }),
+        !params.sortings.some(e => e.name === 'status') ? { rank: 'ASC' } : {}
+      )
+
+      qb.orderBy(sort)
+
+      const [items, total] = await qb.getManyAndCount()
+
+      return { items, total }
+    } catch (error) {
+      throw error
+    }
+  }
+
+  @Directive('@privilege(category: "order", privilege: "query")')
+  @Query(returns => ReleaseGood)
+  async releaseGood(@Ctx() context: any, @Arg('name') name: string): Promise<ReleaseGood> {
+    const { domain, user }: { domain: Domain; user: User } = context.state
+
+    return await getRepository(ReleaseGood).findOne({
+      where: {
+        domain,
+        name,
+        bizplace: In(await getPermittedBizplaceIds(domain, user))
+      },
+      relations: [
+        'domain',
+        'bizplace',
+        'shippingOrder',
+        'arrivalNotice',
+        'orderInventories',
+        'orderInventories.product',
+        'orderInventories.inventory',
+        'orderInventories.inventory.product',
+        'orderVass',
+        'orderVass.vas',
+        'creator',
+        'updater'
+      ]
+    })
+  }
+
+  @Directive('@privilege(category: "order", privilege: "query")')
+  @Directive('@transaction')
+  @Query(returns => ReleaseGood)
+  async releaseGoodDetail(
+    @Ctx() context: any,
+    @Arg('refNo', { nullable: true }) refNo?: string,
+    @Arg('name', { nullable: true }) name?: string
+  ): Promise<ReleaseGood> {
+    const { domain, tx }: { domain: Domain; tx: EntityManager } = context.state
+    let param: any
+
+    if (name) param = { domain, name }
+    else param = { domain, refNo }
+
+    const releaseGood: ReleaseGood = await tx.getRepository(ReleaseGood).findOne({
+      where: { ...param },
+      relations: [
+        'domain',
+        'bizplace',
+        'shippingOrder',
+        'arrivalNotice',
+        'orderInventories',
+        'orderInventories.inventory',
+        'orderInventories.product',
+        'orderInventories.inventory.product',
+        'orderInventories.inventory.location',
+        'orderVass',
+        'orderVass.vas',
+        'orderVass.targetProduct',
+        'orderVass.inventory',
+        'creator',
+        'updater',
+        'deliverTo'
+      ]
+    })
+
+    if (releaseGood) {
+      const roBizId: string = releaseGood.bizplace.id
+      const shippingOrder: ShippingOrder = releaseGood.shippingOrder
+      const foundAttachments: Attachment[] = await tx.getRepository(Attachment).find({
+        where: {
+          domain,
+          refBy: releaseGood.id,
+          category: ATTACHMENT_TYPE.DELIVERY_ORDER
+        }
+      })
+
+      await prepOITempTable(domain, tx)
+
+      let invInfos = await Promise.all(
+        releaseGood.orderInventories
+          .filter(
+            itm =>
+              itm.status !== ORDER_INVENTORY_STATUS.COMPLETE_SPLIT && itm.status !== ORDER_INVENTORY_STATUS.REPLACED
+          )
+          .map(async (orderInv: OrderInventory) => {
+            if (orderInv?.inventory?.id) {
+              const inventory: Inventory = orderInv.inventory
+              return {
+                id: inventory.id,
+                name: inventory.name,
+                batchId: inventory.batchId,
+                batchIdRef: inventory.batchIdRef,
+                palletId: inventory.palletId,
+                product: inventory.product,
+                productIdRef: inventory.product.id,
+                productName: `${inventory.product.name} (${inventory.product.description})`,
+                packingType: inventory.packingType,
+                packingSize: inventory.packingSize,
+                location: inventory.location,
+                qty: inventory.qty,
+                uom: inventory.uom,
+                uomValue: inventory.uomValue,
+                releaseQty: orderInv.releaseQty,
+                releaseUomValue: orderInv.releaseUomValue,
+                status: orderInv.status
+              }
+            } else {
+              const { batchId, batchIdRef, product, packingType, packingSize, releaseQty, releaseUomValue } = orderInv
+              const { id: productIdRef, name: productName }: Product = product
+              const { qty, uomValue, uom } = await getAvailableAmount(roBizId, productIdRef, batchId, packingType, tx)
+
+              return {
+                batchId,
+                batchIdRef,
+                productIdRef,
+                product,
+                productName,
+                packingType,
+                packingSize,
+                qty,
+                uom,
+                uomValue,
+                releaseQty,
+                releaseUomValue
+              }
+            }
+          })
+      )
+
+      const result = {
+        ...releaseGood,
+        attachment: foundAttachments,
+        shippingOrderInfo: {
+          containerNo: shippingOrder?.containerNo || '',
+          containerLeavingDate: shippingOrder?.containerLeavingDate || '',
+          containerArrivalDate: shippingOrder?.containerArrivalDate || '',
+          shipName: shippingOrder?.shipName || ''
+        },
+        inventoryInfos: orderBy<InventoryInfos>(invInfos, ['product.sku'], ['asc'])
+      }
+
+      dropOITempTable(domain, tx)
+
+      return result
+    }
+  }
+
+  @Directive('@privilege(category: "order_warehouse", privilege: "query")')
+  @Query(returns => ReleaseGoodList)
+  async releaseGoodRequests(@Ctx() context: any, @Args() params: ListParam): Promise<ReleaseGoodList> {
+    try {
+      const { domain, user }: { domain: Domain; user: User } = context.state
+
+      const statusFilter = params.filters.some(e => e.name === 'status')
+      const bizplaceFilter = params.filters.find(param => param.name === 'bizplaceId')
+
+      if (!statusFilter) {
+        params.filters.push({
+          name: 'status',
+          operator: 'notin',
+          value: [ORDER_STATUS.PENDING, ORDER_STATUS.EDITING],
+          relation: false
+        })
+      }
+
+      if (!bizplaceFilter) {
+        params.filters.push({
+          name: 'bizplaceId',
+          operator: 'in',
+          value: await getPermittedBizplaceIds(domain, user),
+          relation: false
+        })
+      }
+
+      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
+        })
+      }
+
+      const qb: SelectQueryBuilder<ReleaseGood> = getRepository(ReleaseGood).createQueryBuilder('rg')
+      buildQuery(qb, params, context)
+      qb.addSelect('COALESCE("cc".rank, 99999)', 'rank')
+      qb.leftJoinAndSelect('rg.domain', 'domain')
+      qb.leftJoinAndSelect('rg.bizplace', 'bizplace')
+      qb.leftJoinAndSelect('rg.arrivalNotice', 'an')
+      qb.leftJoinAndSelect('rg.creator', 'creator')
+      qb.leftJoinAndSelect('rg.updater', 'updater')
+      qb.leftJoinAndSelect('rg.acceptedBy', 'acceptedBy')
+      qb.leftJoinAndSelect('rg.deliverTo', 'deliverTo')
+      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 = 'RO_REQUESTS_STATUS'`)
+        },
+        'cc',
+        'cc.status = rg.status'
+      )
+
+      const arrChildSortData = ['bizplace']
+      const sort = (params.sortings || []).reduce(
+        (acc, sort) => ({
+          ...acc,
+          [arrChildSortData.indexOf(sort.name) >= 0 ? sort.name + '.name' : 'rg.' + sort.name]: sort.desc
+            ? 'DESC'
+            : 'ASC'
+        }),
+        !params.sortings.some(e => e.name === 'status') ? { rank: 'ASC' } : {}
+      )
+
+      qb.orderBy(sort)
+
+      const [items, total] = await qb.getManyAndCount()
+
+      return { items, total }
+    } catch (error) {
+      throw error
+    }
+  }
+
+  @Directive('@privilege(category: "order", privilege: "query")')
+  @Query(returns => ReleasableInventoryList)
+  async releasableInventories(
+    @Ctx() context: any,
+    @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<ReleasableInventoryList> {
+    const myBizplace: Bizplace = await getMyBizplace(context.state.domain, context.state.user)
+    const INV_ALIAS = 'INV'
+    const PROD_ALIAS = 'PROD'
+    const GAN_ALIAS = 'GAN'
+    const conditions = filters
+    let { batchId = null, containerNo = null, product = [], packingType = null, inventory = [] } = getConditionValues(
+      conditions
+    )
+
+    const SELECT: string = `
+      SELECT
+        ${INV_ALIAS}.batch_id,
+        ${INV_ALIAS}.packing_type,
+        (SUM(COALESCE(${INV_ALIAS}.qty, 0)) - SUM(COALESCE(${INV_ALIAS}.locked_qty, 0))) as remain_qty,
+        (SUM(COALESCE(${INV_ALIAS}.uomValue, 0)) - SUM(COALESCE(${INV_ALIAS}.locked_uom_value, 0))) as remain_uom_value,
+        ${PROD_ALIAS}.id as product_id,
+        ${PROD_ALIAS}.name as product_name,
+        ${GAN_ALIAS}.container_no
+    `
+    const FROM: string = `
+      FROM
+        inventories ${INV_ALIAS}
+      LEFT JOIN
+        products ${PROD_ALIAS}
+      ON
+        ${PROD_ALIAS}.id = ${INV_ALIAS}.product_id
+      LEFT JOIN
+        arrival_notices ${GAN_ALIAS}
+      ON
+        ${GAN_ALIAS}.id = CAST(${INV_ALIAS}.ref_order_id as uuid)
+    `
+
+    const WHERE: string = `
+      WHERE
+        ${INV_ALIAS}.status = 'STORED'
+        AND ${INV_ALIAS}.qty > 0
+        AND ${INV_ALIAS}.bizplace_id = '${myBizplace.id}'
+        ${batchId ? `AND LOWER(${INV_ALIAS}.batch_id) LIKE '%${batchId.toLowerCase()}%'` : ''}
+        ${packingType ? `AND LOWER(${INV_ALIAS}.packing_type) LIKE '%${packingType.toLowerCase()}%'` : ''}
+        ${containerNo ? `AND LOWER(${GAN_ALIAS}.container_no) LIKE '%${containerNo.toLowerCase()}%'` : ''}
+        ${
+          product?.length > 0 && product[0]
+            ? `AND ${PROD_ALIAS}.id IN (${product.map((id: string) => `'${id}'`).join(', ')})`
+            : product[0] === null
+            ? `AND ${PROD_ALIAS}.id isnull`
+            : ''
+        }
+        ${
+          inventory?.length > 0
+            ? `
+              AND (${INV_ALIAS}.batch_id, ${PROD_ALIAS}.id) ${
+                filters.find((filter: { name: string; operator: string; value: any }) => filter.name === 'inventory')
+                  .operator
+              } (
+                ${inventory
+                  .map((inv: { batchId: string; productId: string }) => `('${inv.batchId}', '${inv.productId}')`)
+                  .join(', ')}
+              )
+            `
+            : ''
+        }
+    `
+
+    // ${product?.length > 0 ? `AND ${PROD_ALIAS}.id IN (${product.map((id: string) => id ? `'${id}'` : null).join(', ')})` : ''}
+    const GROUP_BY: string = `
+      GROUP BY
+      ${INV_ALIAS}.batch_id,
+      ${INV_ALIAS}.packing_type,
+      ${GAN_ALIAS}.container_no,
+      ${PROD_ALIAS}.id
+    `
+
+    const OFFSET_LIMIT: string = `
+        OFFSET ${pagination.limit * (pagination.page - 1)}
+        LIMIT ${pagination.limit}
+    `
+
+    const invRepo: Repository<Inventory> = getRepository(Inventory)
+    let items: Inventory[] = await invRepo.query(`
+      ${SELECT} ${FROM} ${WHERE} ${GROUP_BY} ${OFFSET_LIMIT}
+    `)
+    items = items.map((item: Inventory) => {
+      return {
+        batchId: item.batch_id,
+        packingType: item.packing_type,
+        remainQty: item.remain_qty,
+        remainUomValue: item.remain_uom_value,
+        productName: item.product_name,
+        product: {
+          id: item.product_id,
+          name: item.product_name
+        },
+        containerNo: item.container_no
+      }
+    })
+
+    const results: [{ total: number }] = await invRepo.query(`
+      SELECT max(cnt.cnt) as total FROM (
+        SELECT (ROW_NUMBER() OVER()) as cnt ${FROM} ${WHERE} ${GROUP_BY}
+      ) as cnt
+    `)
+
+    return {
+      items,
+      total: Number(results[0].total)
+    }
+  }
+
+  @FieldResolver(type => Domain)
+  async domain(@Root() releaseGood: ReleaseGood): Promise<Domain> {
+    return await getRepository(Domain).findOne(releaseGood.domainId)
+  }
+
+  @FieldResolver(type => User)
+  async creator(@Root() releaseGood: ReleaseGood): Promise<User> {
+    return await getRepository(User).findOne(releaseGood.creatorId)
+  }
+
+  @FieldResolver(type => User)
+  async updater(@Root() releaseGood: ReleaseGood): Promise<User> {
+    return await getRepository(User).findOne(releaseGood.updaterId)
+  }
+}
+
+async function prepOITempTable(domain: Domain, tx: EntityManager) {
+  await tx.query(
+    `
+    CREATE TEMP TABLE oi AS (
+      SELECT
+        SUM(oi.release_qty) as release_qty,
+        SUM(oi.release_uom_value) as release_uom_value,
+        oi.batch_id,
+        p.id as product_id,
+        oi.packing_type
+      FROM
+        order_inventories oi
+      LEFT JOIN
+        products p
+      ON
+        oi.product_id = p.id
+      WHERE
+        oi.status IN ('PENDING', 'PENDING_RECEIVE', 'PENDING_WORKSHEET', 'PENDING_SPLIT') 
+        AND oi.batch_id NOTNULL
+        AND oi.product_id NOTNULL
+        AND oi.packing_type NOTNULL
+        AND oi.inventory_id IS NULL
+        AND oi.domain_id = $1
+      GROUP BY
+        oi.product_id,
+        oi.batch_id,
+        oi.packing_type,
+        p.id
+    )`,
+    [domain.id]
+  )
+}
+
+async function getAvailableAmount(
+  roBizId: string,
+  productIdRef: string,
+  batchId: string,
+  packingType: string,
+  tx: EntityManager
+): Promise<{ qty: number; uomValue: number; uom: string }> {
+  const result: any[] = await tx.getRepository(Inventory).query(`
+    SELECT
+      SUM(COALESCE(i.qty, 0)) - SUM(COALESCE(i.locked_qty, 0)) - MAX(COALESCE(oi.release_qty, 0)) as "qty",
+      SUM(COALESCE(i.uom_value, 0)) - SUM(COALESCE(i.locked_uom_value, 0)) - MAX(COALESCE(oi.release_uom_value, 0)) as "uom_value",
+      uom
+    FROM
+      inventories i
+      LEFT JOIN products p on i.product_id = p.id
+      LEFT JOIN oi on i.batch_id = oi.batch_id
+      AND p.id = oi.product_id
+      AND i.packing_type = oi.packing_type
+    WHERE
+      i.bizplace_id = '${roBizId}'
+      AND i.status = 'STORED'
+      AND i.batch_id = '${batchId}'
+      AND p.id = '${productIdRef}'
+      AND i.packing_type = '${packingType}'
+    GROUP BY
+      i.batch_id,
+      p.id,
+      i.packing_type,
+      i.uom
+  `)
+
+  let qty: number = 0
+  let uomValue: number = 0
+  let uom: string = ''
+  if (result?.length) {
+    qty = result[0].qty
+    uomValue = result[0].uom_value
+    uom = result[0].uom
+  }
+
+  return { qty, uomValue, uom }
+}
+
+async function dropOITempTable(domain: Domain, tx: EntityManager) {
+  await tx.query(`DROP TABLE oi`)
+}
+
+function getConditionValues(
+  conditions: Filter[]
+): {
+  batchId?: string
+  containerNo?: string
+  product?: string[]
+  packingType?: string
+  inventory?: { batchId: string; productId: string }[]
+} {
+  return conditions.reduce((condition, cond: Filter): {} => {
+    condition = {
+      ...condition,
+      [cond.name]: cond.value
+    }
+
+    return condition
+  }, {})
+}