@things-factory/sales-base 8.0.2 → 8.0.5

package/server/service/arrival-notice/arrival-notice-query.ts

@@ -1,549 +0,0 @@
-import { Arg, Args, Ctx, Directive, FieldResolver, Query, Resolver, Root } from 'type-graphql'
-import { EntityManager, In, OrderByCondition, SelectQueryBuilder } from 'typeorm'
-
-import { Attachment } from '@things-factory/attachment-base'
-import { checkUserBelongsDomain, User } from '@things-factory/auth-base'
-import { Bizplace, getCompanyBizplace, getPermittedBizplaceIds } from '@things-factory/biz-base'
-import { ProductDetail } from '@things-factory/product-base'
-import { buildQuery, Domain, getRepository, ListParam } from '@things-factory/shell'
-
-import { ArrivalNoticeList, NewArrivalNotice, RawArrivalNotice } from '../'
-import { ATTACHMENT_TYPE, ORDER_STATUS } from '../../constants'
-import { OrderInventory, OrderProduct } from '../../service'
-import { ArrivalNotice } from './arrival-notice'
-
-@Resolver(ArrivalNotice)
-export class ArrivalNoticeQuery {
-  @Directive('@privilege(category: "order", privilege: "query", domainOwnerGranted: true)')
-  @Query(returns => ArrivalNotice)
-  async arrivalNotice(
-    @Ctx() context: ResolverContext,
-    @Arg('name', { nullable: true }) name?: string,
-    @Arg('refNo', { nullable: true }) refNo?: string
-  ): Promise<ArrivalNotice> {
-    const { domain, user, bizplace }: { domain: Domain; user: User; bizplace?: Bizplace } = context.state
-
-    let param: any = { domain, bizplace: bizplace ? bizplace : In(await getPermittedBizplaceIds(domain, user)) }
-
-    if (name) param = { ...param, name }
-    else if (refNo) param = { ...param, refNo }
-    else return
-
-    let foundGAN: ArrivalNotice = await getRepository(ArrivalNotice).findOne({
-      where: { ...param },
-      relations: [
-        'domain',
-        'bizplace',
-        'bizplace.domain',
-        'releaseGood',
-        'purchaseOrder',
-        'purchaseOrder.bufferLocation',
-        'orderProducts',
-        'orderProducts.product',
-        'orderInventories',
-        'orderInventories.inventory',
-        'orderInventories.inventory.product',
-        'orderInventories.inventory.location',
-        'orderVass',
-        'orderVass.vas',
-        'orderVass.targetProduct',
-        'supplier',
-        'creator',
-        'updater'
-      ]
-    })
-
-    if (name && !foundGAN) throw new Error(`Failed to find arrival notice with ${name}`)
-
-    if (foundGAN) {
-      const foundAttachments: Attachment[] = await getRepository(Attachment).find({
-        where: {
-          domain: { id: domain.id },
-          refBy: foundGAN?.id,
-          category: ATTACHMENT_TYPE.GAN
-        }
-      })
-
-      const foundPOAttachments: Attachment[] = foundGAN?.purchaseOrder?.id
-        ? await getRepository(Attachment).find({
-            where: {
-              domain: { id: domain.id },
-              refBy: foundGAN.purchaseOrder?.id,
-              category: ATTACHMENT_TYPE.PO
-            }
-          })
-        : []
-
-      // add productDetails data to orderProduct.product
-      foundGAN.orderProducts = await Promise.all(
-        foundGAN.orderProducts.map(async (orderProduct: OrderProduct) => {
-          orderProduct.product['productDetails'] = await getRepository(ProductDetail).find({
-            where: {
-              product: { id: orderProduct.product.id },
-              packingType: orderProduct.packingType,
-              packingSize: orderProduct.packingSize
-            }
-          })
-          return orderProduct
-        })
-      )
-
-      // add productDetails data to orderInventory.inventory.product if orderInventory is exist
-      if (foundGAN.orderInventories && foundGAN.orderInventories.length) {
-        foundGAN.orderInventories = await Promise.all(
-          foundGAN.orderInventories.map(async (orderInventory: OrderInventory) => {
-            orderInventory.inventory.product['productDetails'] = await getRepository(ProductDetail).find({
-              where: {
-                product: { id: orderInventory.inventory.product.id },
-                packingType: orderInventory.inventory.packingType,
-                packingSize: orderInventory.inventory.packingSize
-              }
-            })
-            return orderInventory
-          })
-        )
-      }
-
-      return {
-        ...foundGAN,
-        attachment: [...foundPOAttachments, ...foundAttachments]
-      }
-    } else {
-      return
-    }
-  }
-
-  @Directive('@privilege(category: "order_customer", privilege: "query", domainOwnerGranted: true)')
-  @Query(returns => ArrivalNoticeList)
-  async arrivalNotices(
-    @Ctx() context: ResolverContext,
-    @Args(type => ListParam) params: ListParam
-  ): Promise<ArrivalNoticeList> {
-    const { domain, user } = context.state
-
-    if (await checkUserBelongsDomain(domain, user)) {
-      if (!params.filters.some(e => e.name === 'status') && !params.filters.some(e => e.name === 'name')) {
-        params.filters.push({
-          name: 'status',
-          operator: 'notin',
-          value: [ORDER_STATUS.PENDING, ORDER_STATUS.EDITING],
-          relation: false
-        })
-      }
-    }
-
-    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<ArrivalNotice> = getRepository(ArrivalNotice).createQueryBuilder('an')
-    buildQuery(qb, params, context)
-    qb.addSelect('COALESCE("cc".rank, 9999)', 'rank')
-    qb.leftJoinAndSelect('an.domain', 'domain')
-    qb.leftJoinAndSelect('an.bizplace', 'bizplace')
-    qb.leftJoinAndSelect('an.releaseGood', 'ro')
-    qb.leftJoinAndSelect('an.creator', 'creator')
-    qb.leftJoinAndSelect('an.updater', 'updater')
-    qb.leftJoinAndSelect('an.acceptedBy', 'accepter')
-    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 = 'ORDER_STATUS'`)
-      },
-      'cc',
-      'cc.status = an.status'
-    )
-
-    const arrChildSortData = ['bizplace']
-    const sort: OrderByCondition = (params.sortings || []).reduce(
-      (acc, sort) => ({
-        ...acc,
-        [arrChildSortData.indexOf(sort.name) >= 0 ? sort.name + '.name' : 'an.' + 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 }
-  }
-
-  @Directive('@privilege(category: "order_warehouse", privilege: "query", domainOwnerGranted: true)')
-  @Query(returns => ArrivalNoticeList)
-  async arrivalNoticeRequests(
-    @Args(type => ListParam) params: ListParam,
-    @Ctx() context: ResolverContext
-  ): Promise<ArrivalNoticeList> {
-    try {
-      const { domain, 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<ArrivalNotice> = getRepository(ArrivalNotice).createQueryBuilder('an')
-      buildQuery(qb, params, context)
-      qb.addSelect('COALESCE("cc".rank, 9999)', 'rank')
-      qb.leftJoinAndSelect('an.domain', 'domain')
-      qb.leftJoinAndSelect('an.bizplace', 'bizplace')
-      qb.leftJoinAndSelect('an.releaseGood', 'ro')
-      qb.leftJoinAndSelect('an.creator', 'creator')
-      qb.leftJoinAndSelect('an.updater', 'updater')
-      qb.leftJoinAndSelect('an.acceptedBy', 'accepter')
-      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 = 'ORDER_STATUS'`)
-        },
-        'cc',
-        'cc.status = an.status'
-      )
-
-      const arrChildSortData = ['bizplace']
-      const sort: OrderByCondition = (params.sortings || []).reduce(
-        (acc, sort) => ({
-          ...acc,
-          [arrChildSortData.indexOf(sort.name) >= 0 ? sort.name + '.name' : 'an.' + 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('@transaction')
-  @Query(returns => [RawArrivalNotice])
-  async validateBulkArrivalNotices(
-    @Ctx() context: ResolverContext,
-    @Arg('rawArrivalNotices', type => [NewArrivalNotice], { nullable: true }) rawArrivalNotices: NewArrivalNotice[],
-    @Arg('bizplaceId', type => String) bizplaceId: string
-  ): Promise<RawArrivalNotice[]> {
-    const tx: EntityManager = context.state.tx
-    return await validateBulkArrivalNoticesFunction(rawArrivalNotices, bizplaceId, tx)
-  }
-
-  @FieldResolver(type => Domain)
-  async domain(@Root() arrivalNotice: ArrivalNotice): Promise<Domain> {
-    return await getRepository(Domain).findOneBy({ id: arrivalNotice.domainId })
-  }
-
-  @FieldResolver(type => User)
-  async creator(@Root() arrivalNotice: ArrivalNotice): Promise<User> {
-    return await getRepository(User).findOneBy({ id: arrivalNotice.creatorId })
-  }
-
-  @FieldResolver(type => User)
-  async updater(@Root() arrivalNotice: ArrivalNotice): Promise<User> {
-    return await getRepository(User).findOneBy({ id: arrivalNotice.updaterId })
-  }
-}
-
-export async function validateBulkArrivalNoticesFunction(
-  rawArrivalNotices: NewArrivalNotice[],
-  bizplaceId: string,
-  trxMgr: EntityManager
-): Promise<RawArrivalNotice[]> {
-  const companyBizplace: Bizplace = await getCompanyBizplace(null, null, bizplaceId)
-
-  const json_oi = JSON.stringify(
-    rawArrivalNotices.map(raw => {
-      return {
-        ref_no: raw.refNo || null,
-        ref_no_2: raw.refNo2 || null,
-        ref_no_3: raw.refNo3 || null,
-        eta_date: raw.etaDate || null,
-        truck_no: raw.truckNo || null,
-        own_transport: !!raw.truckNo || false,
-        loose_item: raw.looseItem || false,
-        import_cargo: raw.importCargo || false,
-        container: (!!raw.containerNo && !!raw.containerSize) || false,
-        container_no: raw.containerNo || null,
-        container_size: raw.containerSize || null,
-        sku: raw.sku || null,
-        batch_id: raw.batchId || null,
-        batch_id_ref: raw.batchIdRef || null,
-        packing_type: raw.packingType || null,
-        packing_size: raw.packingSize || null,
-        uom: raw.uom || null,
-        pack_qty: raw.packQty || null,
-        pallet_qty: raw.palletQty || null,
-        unit_price: raw.unitPrice || null,
-        manufacture_date: raw.manufactureDate || null
-      }
-    })
-  )
-
-  await trxMgr.query(
-    `
-      CREATE TEMP TABLE raw_arrival_notices(
-        ref_no VARCHAR(150),
-        ref_no_2 VARCHAR(150),
-        ref_no_3 VARCHAR(150),
-        eta_date VARCHAR(24),
-        truck_no VARCHAR(10),
-        own_transport BOOLEAN,
-        container BOOLEAN,
-        container_no VARCHAR(50),
-        container_size VARCHAR(24),
-        import_cargo BOOLEAN,
-        loose_item BOOLEAN,
-        sku VARCHAR(150),
-        batch_id VARCHAR(100),
-        batch_id_ref VARCHAR(100),
-        packing_type VARCHAR(50),
-        packing_size INT,
-        uom VARCHAR(10),
-        pack_qty INT,
-        pallet_qty INT,
-        unit_price FLOAT8,
-        manufacture_date DATE
-      );
-    `
-  )
-
-  await trxMgr.query(
-    `
-      CREATE TEMP TABLE temp_gan AS (
-        SELECT an.name, an.ref_no, an.ref_no_2, an.ref_no_3, an.eta_date, an.truck_no, an.own_transport, an.container, an.container_no, an.container_size, an.import_cargo, an.loose_item
-        FROM arrival_notices an
-        WHERE EXISTS (
-          SELECT raw.* FROM
-          JSON_POPULATE_RECORDSET(NULL:: arrival_notices, $1) raw
-          WHERE raw.ref_no = an.ref_no 
-          AND raw.ref_no_2 = an.ref_no_2
-          AND raw.ref_no_3 = an.ref_no_3
-          AND raw.eta_date::date = an.eta_date::date
-          AND raw.truck_no = an.truck_no
-          AND raw.own_transport = an.own_transport
-          AND raw.container = an.container
-          AND raw.container_no = an.container_no
-          AND raw.container_size = an.container_size
-          AND raw.loose_item = an.loose_item
-          AND raw.import_cargo = an.import_cargo			
-        )
-      )
-    `,
-    [json_oi]
-  )
-
-  await trxMgr.query(
-    `
-      INSERT INTO raw_arrival_notices 
-      SELECT 
-        js.ref_no, js.ref_no_2, js.ref_no_3, js.eta_date, js.truck_no, js.own_transport, js.container,
-        js.container_no, js.container_size, js.import_cargo, js.loose_item, js.sku, js.batch_id,
-        js.batch_id_ref, js.packing_type, js.packing_size, js.uom, js.pack_qty, js.pallet_qty,
-        js.unit_price, js.manufacture_date
-      FROM 
-        JSON_POPULATE_RECORDSET(NULL:: raw_arrival_notices, $1) js;
-    `,
-    [json_oi]
-  )
-
-  const insertResult: any[] = await trxMgr.query(`
-      SELECT * from raw_arrival_notices
-    `)
-
-  let validatedItems = await trxMgr.query(
-    `
-      WITH foo AS (
-	      SELECT 
-	      	an.name AS gan_name,
-	      	an.ref_no AS gan_ref_no,
-	        raw.ref_no, 
-	        raw.ref_no_2, 
-	        raw.ref_no_3, 
-	        raw.eta_date, 
-	        raw.truck_no, 
-	        raw.own_transport, 
-	        raw.container, 
-	        raw.container_no, 
-	        raw.container_size, 
-	        raw.import_cargo, 
-	        raw.loose_item, 
-	        pr.id AS product_id, 
-	        pd.id AS product_detail_id, 
-	        raw.sku AS sku, 
-	        CASE WHEN pr.description NOT IN (NULL, '', '-') THEN CONCAT(pr.name, '(', pr.description, ')') ELSE pr.name END AS product_info, 
-	        raw.batch_id,
-	        raw.batch_id_ref,
-	        pd.packing_type, 
-	        pd.packing_size, 
-	        sum(raw.pack_qty) AS pack_qty, 
-	        sum(pd.uom_value) AS uom_value,
-	        pd.uom,  
-	        sum(raw.pallet_qty) AS pallet_qty, 
-	        raw.unit_price, 
-	        raw.manufacture_date
-	      FROM 
-	        raw_arrival_notices raw 
-	        LEFT JOIN temp_gan an ON raw.ref_no = an.ref_no 
-	        AND raw.ref_no_2 = an.ref_no_2
-	        AND raw.ref_no_3 = an.ref_no_3
-	        AND raw.eta_date::date = an.eta_date::date
-	        AND raw.truck_no = an.truck_no
-	        AND raw.own_transport = an.own_transport
-	        AND raw.container = an.container
-	        AND raw.container_no = an.container_no
-	        AND raw.container_size = an.container_size
-	        AND raw.loose_item = an.loose_item
-	        AND raw.import_cargo = an.import_cargo 
-	        LEFT JOIN products pr ON LOWER(pr.sku) = LOWER(raw.sku)
-	        LEFT JOIN product_details pd ON pr.id = pd.product_id
-	        AND CASE WHEN raw.packing_type NOTNULL AND raw.packing_size NOTNULL AND raw.uom NOTNULL
-	          THEN pd.packing_type = raw.packing_type AND pd.packing_size = raw.packing_size AND pd.uom = raw.uom 
-	          WHEN raw.packing_type NOTNULL AND raw.packing_size NOTNULL AND raw.uom ISNULL
-	            THEN pd.packing_type = raw.packing_type AND pd.packing_size = raw.packing_size AND pd.is_default IS TRUE
-	            WHEN raw.packing_type ISNULL AND raw.packing_size ISNULL AND raw.uom NOTNULL
-	              THEN pd.uom = raw.uom AND pd.is_default IS TRUE ELSE pd.is_default IS TRUE
-	        END
-        WHERE pr.bizplace_id = $1
-	      GROUP BY raw.ref_no, raw.ref_no_2, raw.ref_no_3, raw.eta_date, raw.truck_no, raw.own_transport, raw.container, raw.container_no, raw.container_size, raw.import_cargo, raw.loose_item,
-	        pr.id, pd.id, raw.sku, pr.name, pr.description, raw.batch_id, raw.batch_id_ref, raw.packing_type, raw.packing_size, raw.uom, raw.unit_price, raw.manufacture_date, an.ref_no, an.name
-      ) SELECT foo.*, 
-	       CONCAT(COALESCE(ROUND(foo.uom_value:: numeric, 2), 0) * COALESCE(foo.pack_qty, 0), ' ', foo.uom) AS total_uom_value,
-         CASE WHEN foo.gan_ref_no NOTNULL THEN concat('order duplicated with ', foo.gan_name)
-         WHEN foo.manufacture_date > current_date THEN 'invalid manufacture date'
-         WHEN foo.product_id ISNULL OR foo.product_detail_id ISNULL OR foo.sku ISNULL THEN 'product not found'
-         WHEN foo.pack_qty ISNULL OR foo.pack_qty <= 0 THEN 'invalid pack qty'
-         WHEN foo.batch_id ISNULL THEN 'batch no. is required'
-         WHEN foo.ref_no ISNULL OR foo.ref_no = '' THEN 'ref no. is required'
-         WHEN foo.eta_date ISNULL THEN 'eta date is required'
-         WHEN foo.container_no NOTNULL AND foo.container_size ISNULL OR foo.container_no ISNULL AND foo.container_size NOTNULL THEN 'incomplete container information'
-         WHEN foo.unit_price < 0 THEN 'invalid unit price'
-         WHEN foo.pallet_qty < 0 THEN 'invalid pallet qty'
-       ELSE '' END AS error_msg
-      FROM foo
-      ORDER BY foo.ref_no, foo.ref_no_2, foo.ref_no_3, foo.sku
-    `,
-    [companyBizplace.id]
-  )
-
-  await trxMgr.query('DROP TABLE raw_arrival_notices, temp_gan')
-
-  return validatedItems.map(item => {
-    return {
-      refNo: item.ref_no,
-      refNo2: item.ref_no_2,
-      refNo3: item.ref_no_3,
-      etaDate: item.eta_date,
-      truckNo: item.truck_no,
-      ownTransport: !!item.own_transport,
-      container: item.container,
-      containerNo: item.container_no,
-      containerSize: item.container_size,
-      importCargo: !!item.import_cargo,
-      looseItem: !!item.loose_item,
-      productId: item.product_id,
-      productDetailId: item.product_detail_id,
-      sku: item.sku,
-      productInfo: item.product_info,
-      batchId: item.batch_id,
-      batchIdRef: item.batch_id_ref,
-      packingType: item.packing_type,
-      packingSize: item.packing_size,
-      uom: item.uom,
-      packQty: item.pack_qty,
-      uomValue: item.uom_value,
-      totalUomValue: item.total_uom_value,
-      palletQty: item.pallet_qty,
-      unitPrice: item.unit_price,
-      manufactureDate: item.manufacture_date,
-      errorMsg: item.error_msg
-    }
-  })
-}