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

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

@@ -0,0 +1,354 @@
+import { Arg, Args, Ctx, Directive, Query, Resolver } from 'type-graphql'
+import { EntityManager, In, OrderByCondition, SelectQueryBuilder } from 'typeorm'
+
+import { Attachment } from '@things-factory/attachment-base'
+import { User } from '@things-factory/auth-base'
+import { Bizplace, getPermittedBizplaceIds, getPermittedBizplaces } from '@things-factory/biz-base'
+import { buildQuery, Domain, getRepository, ListParam } from '@things-factory/shell'
+
+import { ATTACHMENT_TYPE, DRAFT_RELEASE_ORDER_STATUS } from '../../constants'
+import { InventoryUtil } from '../../utils'
+import { DraftReleaseGood } from './draft-release-good'
+import { DraftReleaseGoodList } from './draft-release-good-type'
+
+@Resolver(DraftReleaseGood)
+export class DraftReleaseGoodQuery {
+  @Query(returns => DraftReleaseGood, { description: 'To fetch a DraftReleaseGood' })
+  async draftReleaseGood(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<DraftReleaseGood> {
+    const { domain } = context.state
+
+    return await getRepository(DraftReleaseGood).findOne({
+      where: { domain: { id: domain.id }, id }
+    })
+  }
+
+  @Directive('@transaction')
+  @Query(returns => DraftReleaseGood, { description: 'To fetch a DraftReleaseGood' })
+  async draftReleaseGoodByName(@Arg('name') name: string, @Ctx() context: ResolverContext): Promise<DraftReleaseGood> {
+    const { domain, tx } = context.state
+
+    return getDraftReleaseGoodFunction(null, name, context, tx)
+  }
+
+  @Directive('@transaction')
+  @Query(returns => DraftReleaseGoodList, { description: 'To fetch multiple DraftReleaseGoods' })
+  async draftReleaseGoods(
+    @Args(type => ListParam) params: ListParam,
+    @Ctx() context: ResolverContext
+  ): Promise<DraftReleaseGoodList> {
+    try {
+      const { domain, user, tx } = context.state
+
+      const statusFilter = params.filters.find(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')
+      const orderRemarkFilter = params.filters.find(param => param.name === 'orderRemark')
+
+      if (!bizplaceFilter) {
+        params.filters.push({
+          name: 'bizplaceId',
+          operator: 'in',
+          value: await getPermittedBizplaceIds(domain, user),
+          relation: false
+        })
+      }
+
+      params.filters = params.filters.filter(
+        itm => itm.name !== 'noOfItems' && itm.name !== 'sku' && itm.name !== 'status'
+      )
+
+      if (orderRemarkFilter) {
+        const orderRemarkIdx = params.filters.findIndex(param => param.name === 'orderRemark')
+        if (orderRemarkFilter.value == true) {
+          params.filters.splice(orderRemarkIdx, 1)
+          params.filters.push({
+            name: 'remark',
+            operator: 'is_not_null',
+            value: null,
+            relation: false
+          })
+        } else {
+          params.filters.splice(orderRemarkIdx, 1)
+          params.filters.push({
+            name: 'remark',
+            operator: 'is_null',
+            value: null,
+            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
+        })
+      }
+
+      tx.query(
+        `
+        create temp table temp_op_calculation on commit drop as (
+          SELECT drg1.id from draft_release_goods drg1
+          left join order_products op on drg1.id = op.draft_release_good_id
+          where drg1.status ='DRAFT' AND drg1.domain_id = $1
+          AND NOT EXISTS (
+            SELECT * FROM warehouse_bizplace_onhand_inventories wboi 
+            where (wboi."productId" = op.product_id or wboi."productBundleId" = op.product_id) 
+            and wboi."domainId" = op.domain_id
+            and wboi."bizplaceId" = op.bizplace_id
+            AND wboi."remainQty" >= op.release_qty
+          ) GROUP BY drg1.id
+        )
+      `,
+        [domain.id]
+      )
+
+      const qb: SelectQueryBuilder<DraftReleaseGood> = tx.getRepository(DraftReleaseGood).createQueryBuilder('drg')
+      buildQuery(qb, params, context)
+      qb.addSelect('COALESCE("cc".rank, 99999)', 'rank')
+      qb.addSelect(
+        `CASE WHEN "drg".status = 'DRAFT' and tmp_calc.id IS NOT null then 'INSUFFICIENT' else "drg".status END`,
+        'computed_status'
+      )
+      qb.leftJoin(`temp_op_calculation`, 'tmp_calc', 'tmp_calc.id = drg.id')
+      qb.leftJoinAndSelect('drg.domain', 'domain')
+      qb.leftJoinAndSelect('drg.bizplace', 'bizplace')
+      qb.leftJoinAndSelect('drg.creator', 'creator')
+      qb.leftJoinAndSelect('drg.updater', 'updater')
+      qb.leftJoinAndSelect('drg.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 = 'ODO_REQUESTS_STATUS'`)
+        },
+        'cc',
+        'cc.status = drg.status'
+      )
+
+      if (skuFilter) {
+        qb.andWhere(
+          `
+            exists (
+              select * from  order_products op  
+              inner join products p on op.product_id = p.id
+              where op.draft_release_good_id = drg.id
+              and lower(p.sku) ilike :sku
+            )
+        `,
+          { sku: skuFilter.value.toLowerCase() }
+        )
+      }
+
+      if (noOfItemsFilter) {
+        qb.andWhere(
+          `
+              exists (
+                select numberFilterOp.product_id from order_products numberFilterOp  
+                where numberFilterOp.draft_release_good_id = drg.id
+                group by numberFilterOp.product_id having count(*) ${noOfItemsFilter.value == 1 ? ' = 1' : '> 1'}
+              )
+          `
+        )
+      }
+
+      if (statusFilter) {
+        if (statusFilter.value == DRAFT_RELEASE_ORDER_STATUS.DRAFT) {
+          qb.andWhere(
+            `
+              drg.status = 'DRAFT' and tmp_calc.id IS null
+            `
+          )
+        } else if (statusFilter.value == DRAFT_RELEASE_ORDER_STATUS.INSUFFICIENT) {
+          qb.andWhere(
+            `
+              drg.status = 'DRAFT' and tmp_calc.id IS NOT null
+            `
+          )
+        } else {
+          qb.andWhere(
+            `
+              drg.status = '${statusFilter.value}'
+            `
+          )
+        }
+      }
+
+      const arrChildSortData = ['bizplace', 'creator']
+      const sort: OrderByCondition = (params.sortings || []).reduce(
+        (acc, sort) => ({
+          ...acc,
+          [arrChildSortData.indexOf(sort.name) >= 0 ? sort.name + '.name' : 'drg.' + sort.name]: sort.desc
+            ? 'DESC'
+            : 'ASC'
+        }),
+        params.sortings.length < 1 ? { rank: 'ASC', 'drg.createdAt': 'DESC' } : {}
+      )
+
+      qb.orderBy(sort)
+      qb.offset((params.pagination.page - 1) * params.pagination.limit)
+      qb.limit(params.pagination.limit)
+
+      let [items, total] = await Promise.all([qb.getRawMany(), qb.getCount()])
+
+      items = items.map(itm => {
+        return {
+          id: itm.drg_id,
+          name: itm.drg_name,
+          description: itm.drg_description,
+          type: itm.drg_type,
+          releaseDate: itm.drg_release_date,
+          exportOption: itm.drg_export_option,
+          ownTransport: itm.drg_own_transport,
+          bizplace: { id: itm.bizplace_id, name: itm.bizplace_name, description: itm.bizplace_description },
+          refNo: itm.drg_ref_no,
+          refNo2: itm.drg_ref_no_2,
+          refNo3: itm.drg_ref_no_3,
+          status: itm.computed_status,
+          createdAt: itm.drg_created_at,
+          creator: { id: itm.creator_id, name: itm.creator_name, description: itm.creator_description },
+          updatedAt: itm.drg_updated_at,
+          updater: { id: itm.updater_id, name: itm.updater_name, description: itm.updater_description }
+        }
+      })
+
+      return { items, total }
+    } catch (error) {
+      throw error
+    }
+  }
+}
+
+export async function getDraftReleaseGoodFunction(_: any, name: any, context: any, tx?: EntityManager) {
+  try {
+    const { domain, user, bizplace }: { domain: Domain; user: User; bizplace: Bizplace } = context.state
+
+    let permittedBizplaces = await getPermittedBizplaces(domain, user)
+    let result: any = await tx.getRepository(DraftReleaseGood).findOne({
+      where: { domain: { id: domain.id }, name, bizplace: { id: In(permittedBizplaces.map(biz => biz.id)) } },
+      relations: [
+        'releaseGood',
+        'orderProducts',
+        'orderProducts.product',
+        'orderProducts.productBundle',
+        'shippingOrder',
+        'bizplace',
+        'domain',
+        'creator',
+        'updater'
+      ]
+    })
+
+    if (!result?.id) throw new Error(`Failed to find draft release good ${name}`)
+
+    let foundPermittedBizplace: Bizplace
+    let companyBizplace: Bizplace
+
+    if (result.bizplace.id) {
+      foundPermittedBizplace = permittedBizplaces.find(biz => biz.id == result.bizplace.id)
+
+      if (foundPermittedBizplace) {
+        if (!foundPermittedBizplace.company?.id) {
+          foundPermittedBizplace = await tx.getRepository(Bizplace).findOne({
+            where: { id: foundPermittedBizplace.id },
+            relations: ['company', 'company.domain']
+          })
+        }
+        const companyDomain: Domain = foundPermittedBizplace.company.domain
+        companyBizplace = await tx.getRepository(Bizplace).findOne({ where: { domain: { id: companyDomain.id } } })
+      }
+    }
+
+    const bizplaces: Bizplace[] = [foundPermittedBizplace, companyBizplace]
+
+    let productInventory
+    if (result.orderProducts.length > 0)
+      productInventory = await InventoryUtil.bizplaceProductInventory(
+        bizplaces,
+        {
+          filters: [
+            { name: 'bizplaceId', operator: 'eq', value: result.bizplace.id },
+            {
+              name: 'productId',
+              operator: 'in',
+              value: [
+                ...result.orderProducts
+                  .filter(itm => itm?.product)
+                  .map(itm => {
+                    return itm.product.id
+                  }),
+                ...result.orderProducts
+                  .filter(itm => itm?.productBundle)
+                  .map(itm => {
+                    return itm.productBundle.id
+                  })
+              ]
+            }
+          ]
+        },
+        context,
+        tx
+      )
+
+    result.orderProducts = result.orderProducts.map(itm => {
+      let foundProductInv = productInventory?.items.find(
+        i =>
+          (i.productId == itm?.product?.id || i.productId == itm?.productBundle?.id) &&
+          i.packingType == itm.packingType &&
+          i.packingSize == itm.packingSize &&
+          i.uom == itm.uom
+      )
+      return {
+        ...itm,
+        product: itm.product || {
+          id: foundProductInv.productId,
+          name: foundProductInv.productName,
+          brand: foundProductInv.productBrand,
+          sku: foundProductInv.productSKU
+        },
+        groupType: foundProductInv ? foundProductInv.groupType : 'SINGLE',
+        remainQty: foundProductInv ? foundProductInv.remainQty : 0,
+        remainUomValue: foundProductInv ? foundProductInv.remainUomValue : 0,
+        remainUomValueWithUom: foundProductInv ? foundProductInv.remainUomValueWithUom : 0
+      }
+    })
+    const foundAttachments: Attachment[] = await tx.getRepository(Attachment).find({
+      where: {
+        domain: { id: domain.id },
+        refBy: result.id,
+        category: ATTACHMENT_TYPE.DGRN
+      }
+    })
+
+    return {
+      ...result,
+      attachment: foundAttachments
+    }
+  } catch (error) {
+    console.error(error)
+  }
+}

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

@@ -0,0 +1,261 @@
+import { Field, InputType, Int, ObjectType } from 'type-graphql'
+
+import { ObjectRef } from '@things-factory/shell'
+
+import { OrderProductPatch } from '../order-product/order-product-types'
+import { DraftReleaseGood } from './draft-release-good'
+
+@InputType()
+export class NewDraftReleaseGood {
+  @Field({ nullable: true })
+  name: string
+
+  @Field({ nullable: true })
+  releaseDate: string
+
+  @Field({ nullable: true })
+  type: string
+
+  @Field({ nullable: true })
+  collectionOrderNo: string
+
+  @Field({ nullable: true })
+  ownTransport: Boolean
+
+  @Field({ nullable: true })
+  courierOption: Boolean
+
+  @Field({ nullable: true })
+  packingOption: Boolean
+
+  @Field({ nullable: true })
+  packageId: string
+
+  @Field({ nullable: true })
+  truckNo: string
+
+  @Field({ nullable: true })
+  refNo: string
+
+  @Field({ nullable: true })
+  refNo2: string
+
+  @Field({ nullable: true })
+  refNo3: string
+
+  @Field({ nullable: true })
+  pickupAddress: string
+
+  @Field({ nullable: true })
+  pickupTime: string
+
+  @Field({ nullable: true })
+  handoverType: string
+
+  @Field({ nullable: true })
+  dropoffAddress: string
+
+  @Field({ nullable: true })
+  marketplaceOrderStatus: string
+
+  @Field({ nullable: true })
+  billingAddress: string
+
+  @Field({ nullable: true })
+  deliveryAddress1: string
+
+  @Field({ nullable: true })
+  deliveryAddress2: string
+
+  @Field({ nullable: true })
+  deliveryAddress3: string
+
+  @Field({ nullable: true })
+  deliveryAddress4: string
+
+  @Field({ nullable: true })
+  deliveryAddress5: string
+
+  @Field({ nullable: true })
+  attentionTo: string
+
+  @Field({ nullable: true })
+  attentionCompany: string
+
+  @Field({ nullable: true })
+  city: string
+
+  @Field({ nullable: true })
+  state: string
+
+  @Field({ nullable: true })
+  postalCode: string
+
+  @Field({ nullable: true })
+  country: string
+
+  @Field({ nullable: true })
+  phone1: string
+
+  @Field({ nullable: true })
+  phone2: string
+
+  @Field({ nullable: true })
+  email: string
+
+  @Field()
+  exportOption: Boolean
+
+  @Field({ nullable: true })
+  status: string
+
+  @Field({ nullable: true })
+  description: string
+
+  @Field({ nullable: true })
+  deliverTo: string
+
+  @Field(type => ObjectRef, { nullable: true })
+  bizplace: ObjectRef
+
+  @Field({ nullable: true })
+  remark: string
+
+  @Field(type => [ObjectRef], { nullable: true })
+  orderProducts: ObjectRef[]
+}
+
+@InputType()
+export class DraftReleaseGoodPatch {
+  @Field({ nullable: true })
+  id: string
+
+  @Field({ nullable: true })
+  name: string
+
+  @Field(type => ObjectRef, { nullable: true })
+  bizplace: ObjectRef
+
+  @Field({ nullable: true })
+  releaseDate: string
+
+  @Field({ nullable: true })
+  collectionOrderNo: string
+
+  @Field({ nullable: true })
+  ownTransport: Boolean
+
+  @Field({ nullable: true })
+  type: string
+
+  @Field({ nullable: true })
+  truckNo: string
+
+  @Field({ nullable: true })
+  packageId: string
+
+  @Field({ nullable: true })
+  refNo: string
+
+  @Field({ nullable: true })
+  refNo2: string
+
+  @Field({ nullable: true })
+  refNo3: string
+
+  @Field({ nullable: true })
+  exportOption: Boolean
+
+  @Field({ nullable: true })
+  packingOption: Boolean
+
+  @Field(type => ObjectRef, { nullable: true })
+  shippingOrder: ObjectRef
+
+  @Field({ nullable: true })
+  status: string
+
+  @Field({ nullable: true })
+  remark: string
+
+  @Field({ nullable: true })
+  billingAddress: string
+
+  @Field({ nullable: true })
+  deliveryAddress1: string
+
+  @Field({ nullable: true })
+  deliveryAddress2: string
+
+  @Field({ nullable: true })
+  deliveryAddress3: string
+
+  @Field({ nullable: true })
+  deliveryAddress4: string
+
+  @Field({ nullable: true })
+  deliveryAddress5: string
+
+  @Field({ nullable: true })
+  attentionTo: string
+
+  @Field({ nullable: true })
+  attentionCompany: string
+
+  @Field({ nullable: true })
+  city: string
+
+  @Field({ nullable: true })
+  state: string
+
+  @Field({ nullable: true })
+  postalCode: string
+
+  @Field({ nullable: true })
+  country: string
+
+  @Field({ nullable: true })
+  phone1: string
+
+  @Field({ nullable: true })
+  phone2: string
+
+  @Field({ nullable: true })
+  email: string
+
+  @Field({ nullable: true })
+  description: string
+
+  @Field({ nullable: true })
+  courierOption: Boolean
+
+  @Field({ nullable: true })
+  pickupAddress: string
+
+  @Field({ nullable: true })
+  pickupTime: string
+
+  @Field({ nullable: true })
+  handoverType: string
+
+  @Field({ nullable: true })
+  dropoffAddress: string
+
+  @Field({ nullable: true })
+  marketplaceOrderStatus: string
+
+  @Field({ nullable: true })
+  deliverTo: string
+
+  @Field(type => [OrderProductPatch], { nullable: true })
+  orderProducts: OrderProductPatch[]
+}
+
+@ObjectType()
+export class DraftReleaseGoodList {
+  @Field(type => [DraftReleaseGood])
+  items: DraftReleaseGood[]
+
+  @Field(type => Int)
+  total: number
+}