@things-factory/sales-base 8.0.2 → 8.0.5

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

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

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