@things-factory/sales-base 4.0.0-y.0 → 4.0.4

package/server/graphql/resolvers/job-sheet/index.ts

@@ -1,15 +0,0 @@
-import { jobSheetResolver } from './job-sheet'
-import { jobSheetsResolver } from './job-sheets'
-
-import { generateJobSheetResolver } from './generate-job-sheet'
-import { updateJobSheet } from './update-job-sheet'
-
-export const Query = {
-  ...jobSheetsResolver,
-  ...jobSheetResolver
-}
-
-export const Mutation = {
-  ...generateJobSheetResolver,
-  ...updateJobSheet
-}

package/server/graphql/resolvers/job-sheet/job-sheet.ts

@@ -1,27 +0,0 @@
-import { Domain } from '@things-factory/shell'
-import { EntityManager } from 'typeorm'
-import { ArrivalNotice, JobSheet } from '../../../entities'
-
-export const jobSheetResolver = {
-  async jobSheet(_: any, { arrivalNoticeRefNo }, context: any) {
-    const { domain, tx }: { domain: Domain; tx: EntityManager } = context.state
-
-    const jobSheet: JobSheet = await tx.getRepository(JobSheet).findOne({
-      where: { domain, arrivalNoticeRefNo },
-      relations: ['domain', 'bizplace', 'creator', 'updater']
-    })
-
-    if (!jobSheet) throw new Error('No job sheet is found')
-
-    const arrivalNotice: ArrivalNotice = await tx.getRepository(ArrivalNotice).findOne({
-      where: { name: jobSheet.arrivalNoticeRefNo, bizplace: jobSheet.bizplace }
-    })
-
-    return {
-      ...jobSheet,
-      looseItem: arrivalNotice?.looseItem,
-      etaDate: arrivalNotice?.etaDate,
-      ata: arrivalNotice?.ata
-    }
-  }
-}

package/server/graphql/resolvers/job-sheet/job-sheets.ts

@@ -1,58 +0,0 @@
-import { User } from '@things-factory/auth-base'
-import { getPermittedBizplaceIds } from '@things-factory/biz-base'
-import { buildQuery, Domain, ListParam } from '@things-factory/shell'
-import { EntityManager, SelectQueryBuilder } from 'typeorm'
-import { JobSheet } from '../../../entities'
-
-export const jobSheetsResolver = {
-  async jobSheets(_: any, params: ListParam, context: any) {
-    const { domain, user, tx }: { domain: Domain; user: User; tx: EntityManager } = context.state
-
-    const bizplaceFilter = params.filters.find(param => param.name === 'bizplaceId')
-    const containerNoFilter = params.filters.find(param => param.name === 'containerNo')
-    const jobSheetNoFilter = params.filters.find(param => param.name === 'name')
-    const fromDateFilter = params.filters.find(param => param.name === 'fromDate')
-    const toDateFilter = params.filters.find(param => param.name === 'toDate')
-
-    if (!bizplaceFilter) {
-      params.filters.push({
-        name: 'bizplaceId',
-        operator: 'in',
-        value: await getPermittedBizplaceIds(domain, user),
-        relation: false
-      })
-    }
-
-    let fromDateValue: Date = new Date(fromDateFilter.value)
-    let toDateValue: Date = new Date(toDateFilter.value)
-    toDateValue.setDate(toDateValue.getDate() + 1)
-
-    const qb: SelectQueryBuilder<JobSheet> = tx.getRepository(JobSheet).createQueryBuilder('js')
-    buildQuery(qb, params, context)
-    qb.innerJoinAndSelect('js.domain', 'domain')
-    qb.innerJoinAndSelect('js.bizplace', 'bizplace')
-    qb.innerJoinAndSelect('js.creator', 'creator')
-    qb.innerJoinAndSelect('js.updater', 'updater')
-    qb.where('js.domain_id = :domainId', { domainId: domain.id })
-
-    if (fromDateFilter && toDateFilter) {
-      qb.andWhere('js.updatedAt >= :fromDate', { fromDate: fromDateValue.toISOString() })
-      qb.andWhere('js.updatedAt <= :toDate', { toDate: toDateValue.toISOString() })
-    }
-
-    if (containerNoFilter) {
-      qb.andWhere('js.container_no ILIKE :containerNo', { containerNo: containerNoFilter.value })
-    }
-
-    if (jobSheetNoFilter) {
-      qb.andWhere('js.name ILIKE :name', { name: jobSheetNoFilter.value })
-    }
-
-    if (bizplaceFilter) {
-      qb.andWhere('js.bizplace_id = :bizplaceId', { bizplaceId: bizplaceFilter.value })
-    }
-
-    const [items, total] = await qb.getManyAndCount()
-    return { items, total }
-  }
-}

package/server/graphql/resolvers/job-sheet/update-job-sheet.ts

@@ -1,39 +0,0 @@
-import { User } from '@things-factory/auth-base'
-import { Domain } from '@things-factory/shell'
-import { EntityManager } from 'typeorm'
-import { ArrivalNotice, JobSheet } from '../../../entities'
-
-export const updateJobSheet = {
-  async updateJobSheet(_, { name, patch }, context: any) {
-    const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
-
-    const jobSheet = await tx.getRepository(JobSheet).findOne({
-      where: {
-        domain,
-        name
-      }
-    })
-
-    if (!jobSheet) throw new Error('No job sheet is found')
-
-    const foundGAN: ArrivalNotice = await tx.getRepository(ArrivalNotice).findOne({
-      where: {
-        domain,
-        name: jobSheet.arrivalNoticeRefNo
-      }
-    })
-
-    await tx.getRepository(ArrivalNotice).save({
-      ...foundGAN,
-      ata: patch.ata,
-      updater: user
-    })
-
-    return await tx.getRepository(JobSheet).save({
-      ...jobSheet,
-      containerMtDate: patch?.containerMtDate ? patch.containerMtDate : null,
-      adviseMtDate: patch?.adviseMtDate ? patch.adviseMtDate : null,
-      sumPalletQty: patch?.sumPalletQty ? patch.sumPalletQty : null
-    })
-  }
-}

package/server/graphql/resolvers/order-inventory/delete-order-inventories.ts

@@ -1,15 +0,0 @@
-import { EntityManager, In } from 'typeorm'
-import { Domain } from '@things-factory/shell'
-import { OrderInventory } from '../../../entities'
-
-export const deleteOrderInventories = {
-  async deleteOrderInventories(_: any, { names }, context: any) {
-    const { tx, domain }: { tx: EntityManager; domain: Domain } = context.state
-
-    await tx.getRepository(OrderInventory).delete({
-      domain,
-      name: In(names)
-    })
-    return true
-  }
-}

package/server/graphql/resolvers/order-inventory/delete-order-inventory.ts

@@ -1,12 +0,0 @@
-import { Domain } from '@things-factory/shell'
-import { EntityManager } from 'typeorm'
-import { OrderInventory } from '../../../entities'
-
-export const deleteOrderInventory = {
-  async deleteOrderInventory(_: any, { name }, context: any) {
-    const { tx, domain }: { tx: EntityManager; domain: Domain } = context.state
-
-    await tx.getRepository(OrderInventory).delete({ domain, name })
-    return true
-  }
-}

package/server/graphql/resolvers/order-inventory/index.ts

@@ -1,19 +0,0 @@
-import { orderInventoryResolver } from './order-inventory'
-import { orderInventoriesResolver } from './order-inventories'
-import { inventoriesByOrderResolver } from './inventories-by-order'
-import { mergedProductOrderInventoriesResolver } from './merged-product-order-inventories'
-
-import { deleteOrderInventory } from './delete-order-inventory'
-import { deleteOrderInventories } from './delete-order-inventories'
-
-export const Query = {
-  ...orderInventoriesResolver,
-  ...mergedProductOrderInventoriesResolver,
-  ...orderInventoryResolver,
-  ...inventoriesByOrderResolver
-}
-
-export const Mutation = {
-  ...deleteOrderInventory,
-  ...deleteOrderInventories
-}

package/server/graphql/resolvers/order-inventory/inventories-by-order.ts

@@ -1,72 +0,0 @@
-import { User } from '@things-factory/auth-base'
-import { getPermittedBizplaceIds } from '@things-factory/biz-base'
-import { buildQuery, Domain, ListParam } from '@things-factory/shell'
-import { getRepository, Like, SelectQueryBuilder } from 'typeorm'
-import { OrderInventory, ReleaseGood } from '../../../entities'
-
-export const inventoriesByOrderResolver = {
-  async inventoriesByOrder(_: any, params: ListParam, context: any) {
-    const { domain, user }: { domain: Domain; user: User } = context.state
-
-    let permittedBizplaceIds: string[] = await getPermittedBizplaceIds(domain, user)
-
-    if (!params.filters.find((filter: any) => filter.name === 'bizplaceId')) {
-      params.filters.push({
-        name: 'bizplaceId',
-        operator: 'in',
-        value: permittedBizplaceIds,
-        relation: true
-      })
-    } else {
-      permittedBizplaceIds = params.filters.find(filter => filter.name === 'bizplaceId').value
-      params.filters.find(filter => filter.name === 'bizplaceId').relation = true
-    }
-
-    if (params.filters.find((filter: any) => filter.name === 'releaseGoodName')?.value) {
-      let releaseGood: ReleaseGood = await getRepository(ReleaseGood).findOne({
-        where: {
-          name: Like(params.filters.find(filter => filter.name === 'releaseGoodName').value)
-        }
-      })
-
-      if (releaseGood) {
-        params.filters = params.filters.filter(filter => filter.name != 'releaseGoodName')
-
-        params.filters.push({
-          name: 'releaseGoodId',
-          operator: 'eq',
-          value: releaseGood.id,
-          relation: true
-        })
-      }
-    }
-    const qb: SelectQueryBuilder<OrderInventory> = getRepository(OrderInventory).createQueryBuilder('oi')
-    buildQuery(qb, params, context)
-
-    qb.innerJoinAndSelect('oi.releaseGood', 'releaseGood')
-      .leftJoinAndSelect('oi.domain', 'domain')
-      .leftJoinAndSelect('oi.bizplace', 'bizplace')
-      .leftJoinAndSelect('oi.inventory', 'inventory')
-      .leftJoinAndSelect('inventory.product', 'product')
-      .leftJoinAndSelect('oi.creator', 'creator')
-      .leftJoinAndSelect('oi.updater', 'updater')
-
-    qb.andWhere('releaseGood.status = :status', { status: 'DONE' })
-    let [items, total] = await qb.getManyAndCount()
-
-    items = items.map((item: OrderInventory) => {
-      return {
-        ...item,
-        id: item.inventory.id,
-        releaseGoodName: item.releaseGood.name,
-        palletId: item.inventory.palletId,
-        productId: item.inventory.product.id,
-        productName: item.inventory.product.name,
-        productSKU: item.inventory.product.sku,
-        packingSize: item.inventory.packingSize
-      }
-    })
-
-    return { items, total }
-  }
-}

package/server/graphql/resolvers/order-inventory/merged-product-order-inventories.ts

@@ -1,73 +0,0 @@
-import { Product } from '@things-factory/product-base'
-import { convertListParams, ListParam } from '@things-factory/shell'
-import { getRepository } from 'typeorm'
-import { OrderInventory } from '../../../entities'
-
-export const mergedProductOrderInventoriesResolver = {
-  async mergedProductOrderInventories(_: any, params: ListParam, context: any) {
-    const convertedParams = convertListParams(params)
-    let [items, total] = await getRepository(OrderInventory).findAndCount({
-      ...convertedParams,
-      relations: [
-        'domain',
-        'arrivalNotice',
-        'inventory',
-        'product',
-        'releaseGood',
-        'deliveryOrder',
-        'creator',
-        'updater'
-      ]
-    })
-
-    items = items
-      .map((item: OrderInventory) => {
-        const product: Product = item.product
-        return {
-          productName: `(${product?.sku ? product.sku : '-'}) ${product.name}`,
-          packingType: item.packingType,
-          packingSize: item.packingSize,
-          sku: item.product.sku,
-          batchId: item.batchId,
-          batchIdRef: item.batchIdRef,
-          releaseQty: item.releaseQty,
-          releaseUomValue: item.releaseUomValue
-        }
-      })
-      .reduce((newItem, item) => {
-        let foundItem = newItem.find(
-          newItem =>
-            newItem.sku === item.sku && newItem.packingType === item.packingType && newItem.packingSize === item.packingSize && newItem.batchId === item.batchId
-        )
-        if (!foundItem) {
-          foundItem = {
-            productName: item.productName,
-            packingType: item.packingType,
-            packingSize: item.packingSize,
-            sku: item.sku,
-            batchId: item.batchId,
-            batchIdRef: item.batchIdRef,
-            releaseQty: item.releaseQty,
-            releaseUomValue: item.releaseUomValue
-          }
-
-          newItem.push(foundItem)
-          return newItem
-        } else {
-          return newItem.map(ni => {
-            if (ni.sku === item.sku && ni.packingType === item.packingType && ni.packingSize === item.packingSize && ni.batchId === item.batchId) {
-              return {
-                ...ni,
-                releaseQty: ni.releaseQty + item.releaseQty,
-                releaseUomValue: ni.releaseUomValue + item.releaseUomValue
-              }
-            } else {
-              return ni
-            }
-          })
-        }
-      }, [])
-
-    return { items, total }
-  }
-}

package/server/graphql/resolvers/order-inventory/order-inventories.ts

@@ -1,23 +0,0 @@
-import { convertListParams, ListParam } from '@things-factory/shell'
-import { getRepository } from 'typeorm'
-import { OrderInventory } from '../../../entities'
-
-export const orderInventoriesResolver = {
-  async orderInventories(_: any, params: ListParam, context: any) {
-    const convertedParams = convertListParams(params)
-    const [items, total] = await getRepository(OrderInventory).findAndCount({
-      ...convertedParams,
-      relations: [
-        'domain',
-        'arrivalNotice',
-        'inventory',
-        'inventory.product',
-        'releaseGood',
-        'deliveryOrder',
-        'creator',
-        'updater'
-      ]
-    })
-    return { items, total }
-  }
-}

package/server/graphql/resolvers/order-inventory/order-inventory.ts

@@ -1,17 +0,0 @@
-import { Domain } from '@things-factory/shell'
-import { getRepository } from 'typeorm'
-import { OrderInventory } from '../../../entities'
-
-export const orderInventoryResolver = {
-  async orderInventory(_: any, { name }, context: any) {
-    const { domain }: { domain: Domain } = context.state
-
-    return await getRepository(OrderInventory).findOne({
-      where: {
-        domain,
-        name
-      },
-      relations: ['domain', 'releaseGood', 'vasOrder', 'shippingOrder', 'inventory', 'creator', 'updater']
-    })
-  }
-}

package/server/graphql/resolvers/order-product/delete-order-product.ts

@@ -1,12 +0,0 @@
-import { Domain } from '@things-factory/shell'
-import { EntityManager } from 'typeorm'
-import { OrderProduct } from '../../../entities'
-
-export const deleteOrderProduct = {
-  async deleteOrderProduct(_: any, { name }, context: any) {
-    const { tx, domain }: { tx: EntityManager; domain: Domain } = context.state
-
-    await tx.getRepository(OrderProduct).delete({ domain, name })
-    return true
-  }
-}

package/server/graphql/resolvers/order-product/delete-order-products.ts

@@ -1,15 +0,0 @@
-import { EntityManager, In } from 'typeorm'
-import { Domain } from '@things-factory/shell'
-import { OrderProduct } from '../../../entities'
-
-export const deleteOrderProducts = {
-  async deleteOrderProducts(_: any, { names }, context: any) {
-    const { tx, domain }: { tx: EntityManager; domain: Domain } = context.state
-
-    await tx.getRepository(OrderProduct).delete({
-      domain,
-      name: In(names)
-    })
-    return true
-  }
-}

package/server/graphql/resolvers/order-product/index.ts

@@ -1,14 +0,0 @@
-import { deleteOrderProduct } from './delete-order-product'
-import { deleteOrderProducts } from './delete-order-products'
-import { orderProductResolver } from './order-product'
-import { orderProductsResolver } from './order-products'
-
-export const Query = {
-  ...orderProductsResolver,
-  ...orderProductResolver
-}
-
-export const Mutation = {
-  ...deleteOrderProduct,
-  ...deleteOrderProducts
-}

package/server/graphql/resolvers/order-product/order-product.ts

@@ -1,17 +0,0 @@
-import { Domain } from '@things-factory/shell'
-import { getRepository } from 'typeorm'
-import { OrderProduct } from '../../../entities'
-
-export const orderProductResolver = {
-  async orderProduct(_: any, { name }, context: any) {
-    const { domain }: { domain: Domain } = context.state
-
-    return await getRepository(OrderProduct).findOne({
-      where: {
-        domain,
-        name,
-        relations: ['domain', 'arrivalNotice', 'product', 'creator', 'updater']
-      }
-    })
-  }
-}

package/server/graphql/resolvers/order-product/order-products.ts

@@ -1,14 +0,0 @@
-import { convertListParams, ListParam } from '@things-factory/shell'
-import { getRepository } from 'typeorm'
-import { OrderProduct } from '../../../entities'
-
-export const orderProductsResolver = {
-  async orderProducts(_: any, params: ListParam, context: any) {
-    const convertedParams = convertListParams(params)
-    const [items, total] = await getRepository(OrderProduct).findAndCount({
-      ...convertedParams,
-      relations: ['domain', 'bizplace', 'bizplace.company', 'arrivalNotice', 'product', 'creator', 'updater']
-    })
-    return { items, total }
-  }
-}

package/server/graphql/resolvers/order-vas/index.ts

@@ -1,9 +0,0 @@
-import { orderVasResolver } from './order-vas'
-import { orderVassResolver } from './order-vass'
-
-export const Query = {
-  ...orderVasResolver,
-  ...orderVassResolver
-}
-
-export const Mutation = {}

package/server/graphql/resolvers/order-vas/order-vas.ts

@@ -1,27 +0,0 @@
-import { Domain } from '@things-factory/shell'
-import { getRepository } from 'typeorm'
-import { OrderVas } from '../../../entities'
-
-export const orderVasResolver = {
-  async orderVas(_: any, { name }, context: any) {
-    const { domain }: { domain: Domain } = context.state
-
-    return await getRepository(OrderVas).findOne({
-      where: {
-        domain,
-        name
-      },
-      relations: [
-        'domain',
-        'arrivalNotice',
-        'releaseGood',
-        'vasOrder',
-        'shippingOrder',
-        'vas',
-        'inventory',
-        'creator',
-        'updater'
-      ]
-    })
-  }
-}

package/server/graphql/resolvers/order-vas/order-vass.ts

@@ -1,24 +0,0 @@
-import { convertListParams, ListParam } from '@things-factory/shell'
-import { getRepository } from 'typeorm'
-import { OrderVas } from '../../../entities'
-
-export const orderVassResolver = {
-  async orderVass(_: any, params: ListParam, context: any) {
-    const convertedParams = convertListParams(params)
-    const [items, total] = await getRepository(OrderVas).findAndCount({
-      ...convertedParams,
-      relations: [
-        'domain',
-        'arrivalNotice',
-        'releaseGood',
-        'vasOrder',
-        'shippingOrder',
-        'vas',
-        'inventory',
-        'creator',
-        'updater'
-      ]
-    })
-    return { items, total }
-  }
-}

package/server/graphql/resolvers/others/bulk-upload-validate-order-products.ts

@@ -1,108 +0,0 @@
-import { User } from '@things-factory/auth-base'
-import { Bizplace, getPermittedBizplaces } from '@things-factory/biz-base'
-import { Domain } from '@things-factory/shell'
-import { Product, ProductDetail } from '@things-factory/product-base'
-import { EntityManager } from 'typeorm'
-
-export const bulkUploadValidateOrderProductsResolver = {
-  async bulkUploadValidateOrderProducts(_: any, { orderProducts, partnerBizplaceId }, context: any) {
-    const {
-      domain,
-      user,
-      tx,
-      bizplace
-    }: { domain: Domain; user: User; tx: EntityManager; bizplace: Bizplace } = context.state
-
-    const productDetailRepo = tx.getRepository(ProductDetail)
-
-    let permittedBizplaces: Bizplace[] = await getPermittedBizplaces(domain, user)
-    let foundPermittedBizplace: Bizplace
-    let companyBizplace: Bizplace
-
-    if (partnerBizplaceId) {
-      foundPermittedBizplace = permittedBizplaces.find(biz => biz.id == partnerBizplaceId)
-
-      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]
-    if (bizplace) bizplaces.push(bizplace)
-
-    let newOrderProducts: any[] = []
-
-    for (var i = 0; i < orderProducts.length; i++) {
-      const orderProduct = orderProducts[i]
-      const productSKU: string = orderProduct.productSKU
-      const foundProduct: Product = await tx.getRepository(Product).findOne({
-        where: {
-          sku: productSKU,
-          bizplace: companyBizplace
-        }
-      })
-
-      let newOrderProduct: any
-
-      if (foundProduct) {
-        let productDetail: ProductDetail
-
-        if (orderProduct?.packingType) {
-          productDetail = await productDetailRepo.findOne({
-            where: {
-              product: foundProduct,
-              packingType: orderProduct.packingType
-            }
-          })
-        } else {
-          productDetail = await productDetailRepo.findOne({
-            where: {
-              product: foundProduct,
-              isDefault: true
-            }
-          })
-        }
-
-        newOrderProduct = {
-          ...orderProduct,
-          packingType: orderProduct?.packingType ? orderProduct.packingType : productDetail.packingType,
-          uom: productDetail?.uom ? productDetail.uom : null,
-          uomValue: productDetail?.uomValue ? productDetail.uomValue : null,
-          productName: `${foundProduct.name}(${foundProduct.description}(${foundProduct.sku}))`,
-          isError: productDetail ? false : true,
-          product: {
-            id: foundProduct.id,
-            name: foundProduct.name,
-            sku: foundProduct.sku,
-            packingType: orderProduct?.packingType ? orderProduct.packingType : productDetail.packingType,
-            packingSize: productDetail?.packingSize ? productDetail.packingSize : null,
-            primaryUnit: productDetail?.uom ? productDetail.uom : null,
-            primaryValue: productDetail?.uomValue ? productDetail.uomValue : null
-          },
-          totalUomValue:
-            orderProduct.packQty > 0
-              ? productDetail?.uomValue
-                ? `${(orderProduct.packQty * productDetail.uomValue).toFixed(2)} ${productDetail.uom}`
-                : null
-              : null
-        }
-      } else {
-        newOrderProduct = {
-          ...orderProduct,
-          productName: orderProduct.productSKU,
-          isError: true
-        }
-      }
-
-      newOrderProducts.push(newOrderProduct)
-    }
-
-    return newOrderProducts
-  }
-}