@things-factory/sales-base 4.3.3 → 4.4.0-alpha.1

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

@@ -1,314 +0,0 @@
-import { Arg, Args, Ctx, FieldResolver, Query, Resolver, Root, Directive } from 'type-graphql'
-import { getRepository, SelectQueryBuilder, EntityManager, In, getManager } from 'typeorm'
-
-import { checkUserBelongsDomain, User } from '@things-factory/auth-base'
-import { Bizplace, getPermittedBizplaces, getPermittedBizplaceIds } from '@things-factory/biz-base'
-import { buildQuery, Domain, ListParam, Filter, Pagination, Sorting } from '@things-factory/shell'
-
-import { DRAFT_RELEASE_ORDER_STATUS, ORDER_STATUS } from '../../constants'
-import { DraftReleaseGood } from './draft-release-good'
-import { DraftReleaseGoodList } from './draft-release-good-type'
-
-import { Attachment } from '@things-factory/attachment-base'
-import { ATTACHMENT_TYPE } from '../../constants'
-
-import { InventoryUtil } from '../../utils'
-import { OrderProduct } from '../order-product/order-product'
-
-@Resolver(DraftReleaseGood)
-export class DraftReleaseGoodQuery {
-  @Query(returns => DraftReleaseGood, { description: 'To fetch a DraftReleaseGood' })
-  async draftReleaseGood(@Arg('id') id: string, @Ctx() context: any): Promise<DraftReleaseGood> {
-    const { domain } = context.state
-
-    return await getRepository(DraftReleaseGood).findOne({
-      where: { domain, id }
-    })
-  }
-
-  @Directive('@transaction')
-  @Query(returns => DraftReleaseGood, { description: 'To fetch a DraftReleaseGood' })
-  async draftReleaseGoodByName(@Arg('name') name: string, @Ctx() context: any): Promise<DraftReleaseGood> {
-    const { domain, tx }: { domain: Domain; tx: EntityManager } = context.state
-
-    return getDraftReleaseGoodFunction(null, name, context, tx)
-  }
-
-  @Directive('@transaction')
-  @Query(returns => DraftReleaseGoodList, { description: 'To fetch multiple DraftReleaseGoods' })
-  async draftReleaseGoods(@Args() params: ListParam, @Ctx() context: any): Promise<DraftReleaseGoodList> {
-    try {
-      const { domain, user, tx }: { domain: Domain; user: User, tx: EntityManager } = 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, sum(case when wboi."remainQty" >= op.release_qty then 0 else 1 end) as insufficient_count, count(*) as total_row 
-          from draft_release_goods drg1
-          left join order_products op on drg1.id = op.draft_release_good_id
-          left join warehouse_bizplace_onhand_inventories wboi 
-            on (wboi."productId" = op.product_id or wboi."productBundleId" = op.product_id) 
-            and wboi."packingType" = op.packing_type 
-            and wboi."packingSize" = op.packing_size 
-            and wboi.uom = op.uom
-            and wboi."domainId" = op.domain_id
-            and wboi."bizplaceId" = op.bizplace_id
-          where op.domain_id = $1 and drg1.status ='DRAFT'
-          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.insufficient_count > 0 or tmp_calc.total_row = 0) 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.insufficient_count = 0 AND tmp_calc.total_row > 0
-            `
-          )
-        } else if (statusFilter.value == DRAFT_RELEASE_ORDER_STATUS.INSUFFICIENT) {
-          qb.andWhere(
-            `
-              drg.status = 'DRAFT' AND (tmp_calc.insufficient_count > 0 OR tmp_calc.total_row = 0)
-            `
-          )
-        } else {
-          qb.andWhere(
-            `
-              drg.status = '${statusFilter.value}'
-            `
-          )
-        }
-      }
-
-      const arrChildSortData = ['bizplace', 'creator']
-      const sort = (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)
-
-      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 = await tx.getRepository(DraftReleaseGood).findOne({
-      where: { domain, name, bizplace: 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(foundPermittedBizplace.id, {
-            relations: ['company', 'company.domain']
-          })
-        }
-        const companyDomain: Domain = foundPermittedBizplace.company.domain
-        companyBizplace = await tx.getRepository(Bizplace).findOne({ where: { domain: companyDomain } })
-      }
-    }
-
-    const bizplaces: Bizplace[] = [foundPermittedBizplace, companyBizplace]
-
-    let productInventory
-    if (result.orderProducts.length > 0)
-      productInventory = await InventoryUtil.bizplaceProductInventory(bizplaces, { filters: [{ 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,
-        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
-}