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

package/server/graphql/resolvers/worksheet/worksheets.ts

@@ -0,0 +1,493 @@
+import { Brackets, OrderByCondition, SelectQueryBuilder } from 'typeorm'
+
+import { User } from '@things-factory/auth-base'
+import { getPermittedBizplaceIds } from '@things-factory/biz-base'
+import { ArrivalNotice, InventoryCheck, ReleaseGood, ReturnOrder } from '@things-factory/sales-base'
+import { buildQuery, convertListParams, getRepository, ListParam } from '@things-factory/shell'
+
+import { WORKSHEET_TYPE } from '../../../constants'
+import { Worksheet } from '../../../entities'
+
+export const worksheetsResolver = {
+  async worksheets(_: any, params: ListParam, context: any) {
+    try {
+      ////For inbound worksheet filter
+      const { domain, user } = context.state
+      const arrivalNoticeParam: any = params.filters.find((param: any) => param.name === 'arrivalNoticeNo')
+      const arrivalNoticeRefNoParam = params.filters.find(param => param.name === 'arrivalNoticeRefNo')
+      const arrivalNoticeCrossDockingParam = params.filters.find(param => param.name === 'crossDocking')
+      const arrivalNoticeEtaDateParam = params.filters.find(param => param.name === 'etaDate')
+      const typeParam = params.filters.find(param => param.name === 'type')
+
+      if (
+        arrivalNoticeParam ||
+        arrivalNoticeRefNoParam ||
+        arrivalNoticeCrossDockingParam ||
+        arrivalNoticeEtaDateParam
+      ) {
+        let arrFilters = []
+        if (arrivalNoticeParam) {
+          params.filters.splice(
+            params.filters.findIndex(item => item.name == 'arrivalNoticeNo'),
+            1
+          )
+          arrFilters.push({ ...arrivalNoticeParam, name: 'name' })
+        }
+        if (arrivalNoticeRefNoParam) {
+          params.filters.splice(
+            params.filters.findIndex(item => item.name == 'arrivalNoticeRefNo'),
+            1
+          )
+          arrFilters.push({ ...arrivalNoticeRefNoParam, name: 'refNo' })
+        }
+        if (arrivalNoticeCrossDockingParam) {
+          params.filters.splice(
+            params.filters.findIndex(item => item.name == 'crossDocking'),
+            1
+          )
+          arrFilters.push({ ...arrivalNoticeCrossDockingParam, name: 'crossDocking' })
+        }
+        if (arrivalNoticeEtaDateParam) {
+          params.filters.splice(params.filters.findIndex(item => item.name == 'etaDate'))
+        }
+        const foundArrivalNotices: ArrivalNotice[] = await getRepository(ArrivalNotice).find({
+          ...convertListParams({ filters: arrFilters })
+        })
+
+        if (foundArrivalNotices && foundArrivalNotices.length) {
+          params.filters.push({
+            name: 'arrivalNoticeId',
+            operator: 'in',
+            value: foundArrivalNotices.map((foundAN: ArrivalNotice) => foundAN.id),
+            relation: false
+          })
+        } else {
+          params.filters.push({
+            name: 'arrivalNoticeId',
+            operator: 'is_null',
+            relation: false
+          })
+        }
+      }
+
+      const tzOffsetIdx = params.filters.findIndex(param => param.name === 'tzoffset')
+      let tzOffset = 0
+      if (tzOffsetIdx >= 0) {
+        tzOffset = params.filters[tzOffsetIdx].value
+        params.filters.splice(tzOffsetIdx, 1)
+      }
+
+      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
+        })
+      }
+
+      ////For outbound worksheet filter
+      let outboundOrderInfoFilter
+      const outboundOrderInfoParamIdx = params.filters.findIndex(param => param.name === 'outboundOrderInfo')
+      if (outboundOrderInfoParamIdx >= 0) {
+        outboundOrderInfoFilter = params.filters[outboundOrderInfoParamIdx].value.toLowerCase().split(',').join('|')
+
+        params.filters.splice(outboundOrderInfoParamIdx, 1)
+      }
+      const releaseGoodParam = params.filters.find(param => param.name === 'releaseGoodNo')
+      const releaseGoodRefNoParam = params.filters.find(param => param.name === 'releaseGoodRefNo')
+      const releaseGoodCrossDockingParam = params.filters.find(param => param.name === 'crossDocking')
+      const releaseGoodCourierOptionParam = params.filters.find(param => param.name === 'courierOption')
+      const releaseGoodPackingOptionParam = params.filters.find(param => param.name === 'packingOption')
+      const orderRemarkParam = params.filters.find(param => param.name === 'orderRemark')
+      const manifestParam = params.filters.find(param => param.name === 'manifest')
+
+      const releaseGoodPickerOptionParam = params.filters.find(param => param.name === 'assignee')
+      if (
+        releaseGoodParam ||
+        releaseGoodRefNoParam ||
+        releaseGoodCrossDockingParam ||
+        releaseGoodCourierOptionParam ||
+        releaseGoodPackingOptionParam
+      ) {
+        let arrFilters = []
+        if (releaseGoodParam) {
+          params.filters.splice(
+            params.filters.findIndex(item => item.name == 'releaseGoodNo'),
+            1
+          )
+          arrFilters.push({ ...releaseGoodParam, name: 'name' })
+        }
+
+        if (releaseGoodRefNoParam) {
+          params.filters.splice(
+            params.filters.findIndex(item => item.name == 'releaseGoodRefNo'),
+            1
+          )
+          arrFilters.push({ ...releaseGoodRefNoParam, name: 'refNo' })
+        }
+
+        if (releaseGoodCrossDockingParam) {
+          params.filters.splice(
+            params.filters.findIndex(item => item.name == 'crossDocking'),
+            1
+          )
+          arrFilters.push({ ...releaseGoodCrossDockingParam, name: 'crossDocking' })
+        }
+
+        if (releaseGoodCourierOptionParam) {
+          params.filters.splice(
+            params.filters.findIndex(item => item.name == 'courierOption'),
+            1
+          )
+          arrFilters.push({ ...releaseGoodCourierOptionParam, name: 'courierOption' })
+        }
+
+        if (releaseGoodPackingOptionParam) {
+          params.filters.splice(
+            params.filters.findIndex(item => item.name == 'packingOption'),
+            1
+          )
+          arrFilters.push({ ...releaseGoodPackingOptionParam, name: 'packingOption' })
+        }
+
+        const foundReleaseGoods: ReleaseGood[] = await getRepository(ReleaseGood).find({
+          ...convertListParams({ filters: arrFilters }, { searchables: ['arrivalNoticeNo', 'releaseGoodNo'] })
+        })
+
+        if (foundReleaseGoods && foundReleaseGoods.length) {
+          params.filters.push({
+            name: 'releaseGoodId',
+            operator: 'in',
+            value: foundReleaseGoods.map((foundRG: ReleaseGood) => foundRG.id),
+            relation: false
+          })
+        } else {
+          params.filters.push({
+            name: 'releaseGoodId',
+            operator: 'is_null',
+            relation: false
+          })
+        }
+      }
+
+      ////For outbound return worksheet filter
+      const returnOrderParam = params.filters.find(param => param.name === 'returnOrderNo')
+      const returnOrderRefNoParam = params.filters.find(param => param.name === 'returnOrderRefNo')
+      if (returnOrderParam || returnOrderRefNoParam) {
+        let arrFilters = []
+        if (returnOrderParam) {
+          params.filters.splice(
+            params.filters.findIndex(item => item.name == 'returnOrderNo'),
+            1
+          )
+          arrFilters.push({ ...returnOrderParam, name: 'name' })
+        }
+        if (returnOrderRefNoParam) {
+          params.filters.splice(
+            params.filters.findIndex(item => item.name == 'returnOrderRefNo'),
+            1
+          )
+          arrFilters.push({ ...returnOrderRefNoParam, name: 'refNo' })
+        }
+        const foundReturnOrders: ReturnOrder[] = await getRepository(ReturnOrder).find({
+          ...convertListParams({ filters: arrFilters })
+        })
+
+        if (foundReturnOrders && foundReturnOrders.length) {
+          params.filters.push({
+            name: 'returnOrderId',
+            operator: 'in',
+            value: foundReturnOrders.map((foundRO: ReturnOrder) => foundRO.id),
+            relation: false
+          })
+        } else {
+          params.filters.push({
+            name: 'returnOrderId',
+            operator: 'is_null',
+            relation: false
+          })
+        }
+      }
+
+      ////For inventory check worksheet filter
+      const inventoryCheckParam = params.filters.find(param => param.name === 'inventoryCheckNo')
+      const inventoryCheckStatusParam = params.filters.find(param => param.name === 'inventoryCheckStatus')
+      const executionDateParam = params.filters.find(param => param.name === 'executionDate')
+      if (inventoryCheckParam || executionDateParam || inventoryCheckStatusParam) {
+        let arrFilters = []
+        if (inventoryCheckParam) {
+          params.filters.splice(
+            params.filters.findIndex(item => item.name == 'inventoryCheckNo'),
+            1
+          )
+          arrFilters.push({ ...inventoryCheckParam, name: 'name' })
+        }
+        if (inventoryCheckStatusParam) {
+          params.filters.splice(
+            params.filters.findIndex(item => item.name == 'inventoryCheckStatus'),
+            1
+          )
+          arrFilters.push({ ...inventoryCheckStatusParam, name: 'status' })
+        }
+        if (executionDateParam) {
+          params.filters.splice(
+            params.filters.findIndex(item => item.name == 'executionDate'),
+            1
+          )
+          arrFilters.push({ ...releaseGoodRefNoParam, name: 'refNo' })
+        }
+        const foundInventoryCheck: InventoryCheck[] = await getRepository(InventoryCheck).find({
+          ...convertListParams({ filters: arrFilters })
+        })
+
+        if (foundInventoryCheck && foundInventoryCheck.length) {
+          params.filters.push({
+            name: 'inventoryCheckId',
+            operator: 'in',
+            value: foundInventoryCheck.map((foundIC: InventoryCheck) => foundIC.id),
+            relation: false
+          })
+        } else {
+          params.filters.push({
+            name: 'inventoryCheckId',
+            operator: 'is_null',
+            relation: false
+          })
+        }
+      }
+
+      //find assignee
+
+      const assigneeParam = params.filters.find(param => param.name === 'assignee')
+      let assigneeFilter = []
+      if (assigneeParam) {
+        params.filters.splice(
+          params.filters.findIndex(item => item.name == 'assignee'),
+          1
+        )
+        assigneeFilter.push({ ...assigneeParam, name: 'name' })
+
+        const foundAssignee: User[] = await getRepository(User).find({
+          ...convertListParams({ filters: assigneeFilter })
+        })
+
+        if (foundAssignee) {
+          params.filters.push({
+            name: 'assigneeId',
+            operator: 'in',
+            value: foundAssignee.map((foundIC: User) => foundIC.id),
+            relation: false
+          })
+        }
+      }
+
+      //check packing worksheet checkbox filter
+      if (manifestParam) {
+        params.filters.splice(
+          params.filters.findIndex(item => item.name == 'manifest'),
+          1
+        )
+      }
+
+      if (orderRemarkParam) {
+        params.filters.splice(
+          params.filters.findIndex(item => item.name == 'orderRemark'),
+          1
+        )
+      }
+      ////Set default bizplace filter
+      const bizplaceFilter = params.filters.find(param => param.name === 'bizplaceId')
+      if (!bizplaceFilter && typeParam?.value[0] !== WORKSHEET_TYPE.BATCH_PICKING) {
+        params.filters.push({
+          name: 'bizplaceId',
+          operator: 'in',
+          value: await getPermittedBizplaceIds(domain, user),
+          relation: false
+        })
+      }
+
+      ////Build and run Query
+      const qb: SelectQueryBuilder<Worksheet> = getRepository(Worksheet).createQueryBuilder('ws')
+
+      ////For vas worksheets filter
+      let orderName: string = ''
+      if (
+        params.filters.find(param => param.name === 'type' && param.value === WORKSHEET_TYPE.VAS) &&
+        params.filters.find(param => param.name === 'name')
+      ) {
+        orderName = params.filters.find(param => param.name === 'name').value?.toLowerCase()
+        params.filters = params.filters.filter(param => param.name !== 'name')
+      }
+
+      buildQuery(qb, params, context, { searchables: ['arrivalNoticeNo'] })
+
+      if (orderName !== '') {
+        qb.andWhere(
+          new Brackets(qb2 => {
+            qb2.orWhere(`arrivalNotice.name ILIKE '${orderName}'`)
+            qb2.orWhere(`releaseGood.name ILIKE '${orderName}'`)
+            qb2.orWhere(`vasOrder.name ILIKE '${orderName}'`)
+          })
+        )
+      }
+
+      if (outboundOrderInfoFilter) {
+        qb.andWhere(
+          '(releaseGood.name ~* :outboundOrderInfoFilter or releaseGood.ref_no ~* :outboundOrderInfoFilter or releaseGood.ref_no_2 ~* :outboundOrderInfoFilter or releaseGood.ref_no_3 ~* :outboundOrderInfoFilter)',
+          { outboundOrderInfoFilter }
+        )
+      }
+
+      if (manifestParam) {
+        params.filters.splice(
+          params.filters.findIndex(item => item.name == 'manifest'),
+          1
+        )
+
+        if (manifestParam?.value == true) {
+          qb.andWhere('releaseGood.manifest_id is not null')
+        } else if (manifestParam?.value == false) {
+          qb.andWhere('releaseGood.manifest_id is null')
+        }
+      }
+
+      if (orderRemarkParam) {
+        params.filters.splice(
+          params.filters.findIndex(item => item.name == 'orderRemark'),
+          1
+        )
+
+        if (orderRemarkParam?.value == true) {
+          qb.andWhere('releaseGood.remark is not null')
+        } else if (orderRemarkParam?.value == false) {
+          qb.andWhere('releaseGood.remark is null')
+        }
+      }
+
+      qb.addSelect('COALESCE("cc".rank, 99999)', 'rank')
+      qb.leftJoinAndSelect('ws.domain', 'domain')
+      qb.leftJoinAndSelect('ws.bizplace', 'bizplace')
+      qb.leftJoinAndSelect('ws.arrivalNotice', 'arrivalNotice')
+      qb.leftJoinAndSelect('arrivalNotice.supplier', 'supplier')
+      qb.leftJoinAndSelect('supplier.bizplace', 'supplierBizplace')
+      qb.leftJoinAndSelect('ws.releaseGood', 'releaseGood')
+      qb.leftJoinAndSelect('releaseGood.deliverTo', 'deliverTo')
+      qb.leftJoinAndSelect('deliverTo.bizplace', 'deliverBizplace')
+      qb.leftJoinAndSelect('ws.returnOrder', 'returnOrder')
+      qb.leftJoinAndSelect('ws.inventoryCheck', 'inventoryCheck')
+      qb.leftJoinAndSelect('ws.vasOrder', 'vasOrder')
+      qb.leftJoinAndSelect('ws.assignee', 'assignee')
+      qb.leftJoinAndSelect('ws.creator', 'creator')
+      qb.leftJoinAndSelect('ws.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 = 'WORKSHEET_STATUS'`)
+        },
+        'cc',
+        'cc.status = ws.status'
+      )
+
+      ////Add sorting conditions
+      const arrChildSortData = ['bizplace', 'arrivalNotice', 'releaseGood', 'returnOrder', 'inventoryCheck']
+      let sort: OrderByCondition = (params.sortings || []).reduce(
+        (acc, sort) => {
+          if (
+            sort.name != 'arrivalRefNo' &&
+            sort.name != 'releaseRefNo' &&
+            sort.name != 'returnOrderNo' &&
+            sort.name != 'inventoryCheckStatus'
+          ) {
+            return {
+              ...acc,
+              [arrChildSortData.indexOf(sort.name) >= 0 ? sort.name + '.name' : 'ws.' + sort.name]: sort.desc
+                ? 'DESC'
+                : 'ASC'
+            }
+          } else {
+            return { ...acc }
+          }
+        },
+        !params.sortings.some(e => e.name === 'status') ? { rank: 'ASC' } : {}
+      )
+
+      if (params.sortings.some(e => e.name === 'arrivalRefNo')) {
+        sort = {
+          ...sort,
+          'arrivalNotice.refNo': params.sortings[params.sortings.findIndex(item => item.name == 'arrivalRefNo')].desc
+            ? 'DESC'
+            : 'ASC'
+        }
+      }
+
+      if (params.sortings.some(e => e.name === 'releaseRefNo')) {
+        sort = {
+          ...sort,
+          'releaseGood.refNo': params.sortings[params.sortings.findIndex(item => item.name == 'releaseRefNo')].desc
+            ? 'DESC'
+            : 'ASC'
+        }
+      }
+
+      if (params.sortings.some(e => e.name === 'returnOrderRefNo')) {
+        sort = {
+          ...sort,
+          'returnOrder.refNo': params.sortings[params.sortings.findIndex(item => item.name == 'returnOrderRefNo')].desc
+            ? 'DESC'
+            : 'ASC'
+        }
+      }
+
+      if (params.sortings.some(e => e.name === 'inventoryCheckStatus')) {
+        // overwrite the worksheet status sorting since inventory check status is needed
+        sort = {
+          'inventoryCheck.status': params.sortings[
+            params.sortings.findIndex(item => item.name == 'inventoryCheckStatus')
+          ].desc
+            ? 'DESC'
+            : 'ASC',
+          'ws.endedAt': params.sortings[params.sortings.findIndex(item => item.name == 'inventoryCheckStatus')].desc
+            ? 'DESC'
+            : 'ASC'
+        }
+      }
+
+      qb.orderBy(sort)
+
+      let [items, total] = await qb.getManyAndCount()
+
+      items = items.map(item => {
+        return {
+          ...item,
+          orderRemark: item?.releaseGood?.remark ? true : false
+        }
+      })
+
+      return { items, total }
+    } catch (error) {
+      throw error
+    }
+  }
+}

package/server/graphql/resolvers/worksheet-detail/check-progressing-pallet.ts

@@ -0,0 +1,22 @@
+import { SelectQueryBuilder } from 'typeorm'
+
+import { WORKSHEET_STATUS } from '../../../constants'
+import { WorksheetDetail } from '../../../entities'
+
+export const checkProgressingPalletResolver = {
+  async checkProgressingPallet(_: any, { palletId }, context: ResolverContext) {
+    const { tx, domain } = context.state
+    const qb: SelectQueryBuilder<WorksheetDetail> = tx.getRepository(WorksheetDetail).createQueryBuilder('WSD')
+    const cnt: number = await qb
+      .leftJoin('WSD.targetInventory', 'T_INV')
+      .leftJoin('T_INV.inventory', 'INV')
+      .where('"INV"."domain_id" = :domainId', { domainId: domain.id })
+      .andWhere('"INV"."pallet_id" = :palletId', { palletId })
+      .andWhere('"WSD"."status" IN (:...status)', {
+        status: [WORKSHEET_STATUS.EXECUTING, WORKSHEET_STATUS.DEACTIVATED]
+      })
+      .getCount()
+
+    return Boolean(cnt)
+  }
+}

package/server/graphql/resolvers/worksheet-detail/create-worksheet-detail.ts

@@ -0,0 +1,38 @@
+import { getPermittedBizplaceIds, Worker } from '@things-factory/biz-base'
+import { OrderProduct, OrderVas } from '@things-factory/sales-base'
+
+import { Worksheet, WorksheetDetail } from '../../../entities'
+
+export const createWorksheetDetail = {
+  async createWorksheetDetail(_: any, { worksheetDetail }, context: ResolverContext) {
+    const { tx, user, domain } = context.state
+    worksheetDetail.worksheet = await tx.getRepository(Worksheet).findOne({
+      where: {
+        domain: { id: domain.id },
+        //@ts-ignore
+        bizplace: { id: (await getPermittedBizplaceIds(domain, user)).id },
+        id: worksheetDetail.worksheet.id
+      }
+    })
+
+    if (worksheetDetail.worker && worksheetDetail.worker.id) {
+      worksheetDetail.worker = await tx.getRepository(Worker).findOne(worksheetDetail.worker.id)
+    }
+
+    if (worksheetDetail.targetProduct && worksheetDetail.targetProduct.id) {
+      worksheetDetail.targetProduct = await tx.getRepository(OrderProduct).findOne(worksheetDetail.targetProduct.id)
+    }
+
+    if (worksheetDetail.targetVas && worksheetDetail.targetVas.id) {
+      worksheetDetail.targetVas = await tx.getRepository(OrderVas).findOne(worksheetDetail.targetVas.id)
+    }
+
+    return await tx.getRepository(WorksheetDetail).save({
+      ...worksheetDetail,
+      domain,
+      bizplace: context.state.bizplace[0],
+      creator: user,
+      updater: user
+    })
+  }
+}

package/server/graphql/resolvers/worksheet-detail/delete-worksheet-detail.ts

@@ -0,0 +1,18 @@
+import { In } from 'typeorm'
+
+import { getPermittedBizplaceIds } from '@things-factory/biz-base'
+
+import { WorksheetDetail } from '../../../entities'
+
+export const deleteWorksheetDetail = {
+  async deleteWorksheetDetail(_: any, { id }, context: ResolverContext) {
+    const { tx, user, domain } = context.state
+    await tx.getRepository(WorksheetDetail).delete({
+      domain: { id: domain.id },
+      bizplace: In(await getPermittedBizplaceIds(domain, user)),
+      id
+    })
+
+    return true
+  }
+}