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

package/server/service/delivery-order/delivery-order-query.ts

@@ -0,0 +1,423 @@
+import { Arg, Args, Ctx, FieldResolver, Query, Resolver, Root } from 'type-graphql'
+import { EntityManager, getRepository, In, Not, Repository } from 'typeorm'
+
+import { Attachment } from '@things-factory/attachment-base'
+import { User } from '@things-factory/auth-base'
+import { getPermittedBizplaceIds } from '@things-factory/biz-base'
+import { Product } from '@things-factory/product-base'
+import { buildQuery, convertListParams, Domain, Filter, ListParam, Pagination, Sorting } from '@things-factory/shell'
+import { Inventory } from '@things-factory/warehouse-base'
+
+import { DeliveryOrderList, OrderInventory, OrderInventoryList, ReleaseGood } from '../'
+import { ORDER_STATUS } from '../../constants'
+import { DeliveryOrder } from './delivery-order'
+
+const debug = require('debug')('things-factory:sales-base:delivery-orders')
+
+@Resolver(DeliveryOrder)
+export class DeliveryOrderQuery {
+  @Query(returns => DeliveryOrderList)
+  async deliveryOrders(@Ctx() context: any, @Args() params: ListParam): Promise<DeliveryOrderList> {
+    try {
+      const { domain, user }: { domain: Domain; user: User } = context.state
+
+      const bizplaceFilter = params.filters.find(param => param.name === 'bizplaceId')
+      if (!bizplaceFilter) {
+        params.filters.push({
+          name: 'bizplaceId',
+          operator: 'in',
+          value: await getPermittedBizplaceIds(domain, user),
+          relation: false
+        })
+      }
+
+      const releaseGoodParam = params.filters.find(param => param.name === 'releaseGoodNo')
+      if (releaseGoodParam) {
+        let arrFilters = []
+        params.filters.splice(
+          params.filters.findIndex(item => item.name == 'releaseGoodNo'),
+          1
+        )
+        arrFilters.push({ ...releaseGoodParam, name: 'name' })
+
+        const foundReleaseGoods: ReleaseGood[] = await getRepository(ReleaseGood).find({
+          ...convertListParams({ filters: arrFilters })
+        })
+
+        if (foundReleaseGoods && foundReleaseGoods.length) {
+          params.filters.push({
+            name: 'releaseGoodId',
+            operator: 'in',
+            value: foundReleaseGoods.map((releaseGood: ReleaseGood) => releaseGood.id),
+            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
+        })
+      }
+
+      const qb: any = getRepository(DeliveryOrder).createQueryBuilder('do')
+      buildQuery(qb, params, context)
+      qb.addSelect('COALESCE("cc".rank, 99999)', 'rank')
+      qb.leftJoinAndSelect('do.domain', 'domain')
+      qb.leftJoinAndSelect('do.bizplace', 'bizplace')
+      qb.leftJoinAndSelect('do.releaseGood', 'rg')
+      qb.leftJoinAndSelect('do.transportDriver', 'td')
+      qb.leftJoinAndSelect('do.transportVehicle', 'th')
+      qb.leftJoinAndSelect('do.orderInventories', 'oi')
+      qb.leftJoinAndSelect('oi.inventory', 'inv')
+      qb.leftJoinAndSelect('inv.product', 'prd')
+      qb.leftJoinAndSelect('do.creator', 'creator')
+      qb.leftJoinAndSelect('do.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 = 'DELIVERY_STATUS'`)
+        },
+        'cc',
+        'cc.status = do.status'
+      )
+
+      const arrChildSortData = ['bizplace', 'releaseGood']
+      const sort = (params.sortings || []).reduce(
+        (acc, sort) => ({
+          ...acc,
+          [arrChildSortData.indexOf(sort.name) >= 0 ? sort.name + '.name' : 'do.' + 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) {
+      debug('deliveryOrders', error.toString())
+      throw error
+    }
+  }
+
+  @Query(returns => DeliveryOrder)
+  async deliveryOrder(@Arg('name') name: string, @Ctx() context: any): Promise<DeliveryOrder> {
+    const { domain }: { domain: Domain } = context.state
+
+    const foundDO = await getRepository(DeliveryOrder).findOne({
+      where: {
+        domain,
+        name
+      },
+      relations: ['domain', 'bizplace', 'transportDriver', 'transportVehicle', 'releaseGood', 'creator', 'updater']
+    })
+
+    let foundAttachments = []
+    if (foundDO) {
+      foundAttachments = await getRepository(Attachment).find({
+        where: {
+          domain,
+          refBy: foundDO.id
+        }
+      })
+    }
+
+    return { ...foundDO, attachments: foundAttachments }
+  }
+
+  @Query(returns => DeliveryOrderList)
+  async deliveryOrderRequests(
+    @Ctx() context: any,
+    @Arg('filters', type => [Filter], { nullable: true }) filters?: Filter[],
+    @Arg('pagination', type => Pagination, { nullable: true }) pagination?: Pagination,
+    @Arg('sortings', type => [Sorting], { nullable: true }) sortings?: Sorting[]
+  ): Promise<DeliveryOrderList> {
+    const { domain, user }: { domain: Domain; user: User } = context.state
+
+    const convertedParams = convertListParams({ filters, pagination, sortings })
+
+    if (!convertedParams.where || !convertedParams.where.status) {
+      convertedParams.where.status = Not(In([ORDER_STATUS.PENDING, ORDER_STATUS.EDITING]))
+    }
+    convertedParams.bizplace = In(await getPermittedBizplaceIds(domain, user))
+
+    const [items, total] = await getRepository(DeliveryOrder).findAndCount({
+      ...convertedParams,
+      relations: ['domain', 'bizplace', 'releaseGood', 'transportDriver', 'transportVehicle', 'creator', 'updater']
+    })
+
+    return { items, total }
+  }
+
+  @Query(returns => DeliveryOrderList)
+  async deliveryOrderByReleaseGood(
+    @Arg('releaseGoodNo') releaseGoodNo: string,
+    @Ctx() context: any
+  ): Promise<DeliveryOrderList> {
+    const releaseGood: ReleaseGood = await getRepository(ReleaseGood).findOne({
+      where: { name: releaseGoodNo }
+    })
+
+    return await deliveryOrderByReleaseGood(releaseGood)
+  }
+
+  @Query(returns => OrderInventoryList)
+  async deliveryOrderItems(@Arg('name') name: string, @Ctx() context: any): Promise<OrderInventoryList> {
+    const { domain }: { domain: Domain } = context.state
+    const deliveryOrder: DeliveryOrder = await getRepository(DeliveryOrder).findOne({
+      where: { domain, name }
+    })
+
+    let [items, total] = await getRepository(OrderInventory).findAndCount({
+      where: { domain, deliveryOrder },
+      relations: ['inventory', 'inventory.product', 'inventory.reusablePallet']
+    })
+
+    items = items
+      .map((oi: OrderInventory) => {
+        const inventory: Inventory = oi.inventory
+        const product: Product = inventory.product
+        return {
+          inventory: inventory,
+          productName: `${product.name} (${product.description})`,
+          packingType: inventory.packingType,
+          batchId: inventory.batchId,
+          releaseQty: oi.releaseQty,
+          releaseUomValue: oi.releaseUomValue,
+          remark: oi.remark,
+          crossDocking: oi.crossDocking,
+          pallet: inventory?.reusablePallet && inventory?.reusablePallet?.name ? inventory.reusablePallet.name : ''
+        }
+      })
+      .reduce((newItem, item) => {
+        var foundItem = newItem.find(
+          newItem =>
+            newItem.productName === item.productName &&
+            newItem.batchId === item.batchId &&
+            newItem.crossDocking === item.crossDocking &&
+            newItem.pallet === item.pallet
+        )
+        if (!foundItem) {
+          foundItem = {
+            inventory: item.inventory,
+            productName: item.productName,
+            packingType: item.packingType,
+            batchId: item.batchId,
+            releaseQty: item.releaseQty,
+            releaseUomValue: item.releaseUomValue,
+            palletQty: 1,
+            remark: item.remark,
+            crossDocking: item.crossDocking,
+            pallet: item.pallet
+          }
+
+          newItem.push(foundItem)
+          return newItem
+        } else {
+          return newItem.map(ni => {
+            if (
+              ni.productName === item.productName &&
+              ni.batchId === item.batchId &&
+              ni.crossDocking === item.crossDocking &&
+              ni.pallet === item.pallet
+            ) {
+              return {
+                ...ni,
+                palletQty: ni.palletQty + 1,
+                releaseQty: ni.releaseQty + item.releaseQty,
+                releaseUomValue: ni.releaseUomValue + item.releaseUomValue
+              }
+            } else {
+              return ni
+            }
+          })
+        }
+      }, [])
+
+    items = items.map((prod: any) => {
+      return {
+        ...prod,
+        systemRemark: prod?.remark
+          ? prod.remark
+          : prod.crossDocking
+          ? prod.pallet === ''
+            ? `${prod.palletQty} PALLET(S) [C/D]`
+            : `${prod.palletQty} PALLET(S) (${prod.pallet}) [C/D]`
+          : prod.pallet === ''
+          ? `${prod.palletQty} PALLET(S)`
+          : `${prod.palletQty} PALLET(S) (${prod.pallet})`
+      }
+    })
+
+    return { items, total }
+  }
+
+  @Query(returns => OrderInventoryList)
+  async manualDeliveryOrderItems(@Arg('name') name: string, @Ctx() context: any): Promise<OrderInventoryList> {
+    const { domain }: { domain: Domain } = context.state
+    const deliveryOrder: DeliveryOrder = await getRepository(DeliveryOrder).findOne({
+      where: { domain, name }
+    })
+
+    let [items, total] = await getRepository(OrderInventory).findAndCount({
+      where: { domain, deliveryOrder },
+      relations: ['product']
+    })
+
+    items = items
+      .map((oi: OrderInventory) => {
+        const product: Product = oi.product
+        return {
+          inventory: oi.inventory,
+          productId: product.id,
+          productName: `${product.name} (${product.description})`,
+          packingType: oi.packingType,
+          batchId: oi.batchId,
+          releaseQty: oi.releaseQty,
+          releaseUomValue: oi.releaseUomValue,
+          remark: oi.remark,
+          crossDocking: oi.crossDocking,
+          pallet: ''
+        }
+      })
+      .reduce((newItem, item) => {
+        var foundItem = newItem.find(
+          newItem =>
+            newItem.productName === item.productName &&
+            newItem.batchId === item.batchId &&
+            newItem.crossDocking === item.crossDocking &&
+            newItem.pallet === item.pallet
+        )
+        if (!foundItem) {
+          foundItem = {
+            inventory: item.inventory,
+            productId: item.productId,
+            productName: item.productName,
+            packingType: item.packingType,
+            batchId: item.batchId,
+            releaseQty: item.releaseQty,
+            releaseUomValue: item.releaseUomValue,
+            palletQty: 1,
+            remark: item.remark,
+            crossDocking: item.crossDocking,
+            pallet: item.pallet
+          }
+
+          newItem.push(foundItem)
+          return newItem
+        } else {
+          return newItem.map(ni => {
+            if (
+              ni.productName === item.productName &&
+              ni.batchId === item.batchId &&
+              ni.crossDocking === item.crossDocking &&
+              ni.pallet === item.pallet
+            ) {
+              return {
+                ...ni,
+                palletQty: ni.palletQty + 1,
+                releaseQty: ni.releaseQty + item.releaseQty,
+                releaseUomValue: ni.releaseUomValue + item.releaseUomValue
+              }
+            } else {
+              return ni
+            }
+          })
+        }
+      }, [])
+
+    items = items.map((prod: any) => {
+      return {
+        ...prod,
+        systemRemark: prod?.remark
+          ? prod.remark
+          : prod.crossDocking
+          ? prod.pallet === ''
+            ? `${prod.palletQty} PALLET(S) [C/D]`
+            : `${prod.palletQty} PALLET(S) (${prod.pallet}) [C/D]`
+          : prod.pallet === ''
+          ? `${prod.palletQty} PALLET(S)`
+          : `${prod.palletQty} PALLET(S) (${prod.pallet})`
+      }
+    })
+
+    return { items, total }
+  }
+
+  @FieldResolver(type => Domain)
+  async domain(@Root() deliveryOrder: DeliveryOrder): Promise<Domain> {
+    return await getRepository(Domain).findOne(deliveryOrder.domainId)
+  }
+
+  @FieldResolver(type => User)
+  async creator(@Root() deliveryOrder: DeliveryOrder): Promise<User> {
+    return await getRepository(User).findOne(deliveryOrder.creatorId)
+  }
+
+  @FieldResolver(type => User)
+  async updater(@Root() deliveryOrder: DeliveryOrder): Promise<User> {
+    return await getRepository(User).findOne(deliveryOrder.updaterId)
+  }
+}
+
+export async function deliveryOrderByReleaseGood(releaseGood: ReleaseGood, trxMgr?: EntityManager): Promise<any> {
+  const doRepo: Repository<DeliveryOrder> = trxMgr?.getRepository(DeliveryOrder) || getRepository(DeliveryOrder)
+  const oiRepo: Repository<OrderInventory> = trxMgr?.getRepository(OrderInventory) || getRepository(OrderInventory)
+
+  let [items, total] = await doRepo.findAndCount({
+    where: { releaseGood },
+    relations: ['domain', 'bizplace', 'releaseGood', 'transportDriver', 'transportVehicle', 'creator', 'updater']
+  })
+
+  items = await Promise.all(
+    items.map(async (deliveryOrder: DeliveryOrder) => {
+      return {
+        ...deliveryOrder,
+        truck: deliveryOrder?.truckNo || deliveryOrder.transportVehicle?.name || null,
+        targetInventories: await oiRepo.find({
+          where: { deliveryOrder },
+          relations: ['domain', 'bizplace', 'releaseGood', 'inventory']
+        })
+      }
+    })
+  )
+
+  return {
+    items,
+    total
+  }
+}

package/server/service/delivery-order/delivery-order-types.ts

@@ -0,0 +1,253 @@
+import { ObjectRef } from '@things-factory/shell'
+import { Field, Float, ID, InputType, Int, ObjectType } from 'type-graphql'
+import { DeliveryOrder } from './delivery-order'
+
+@ObjectType()
+export class DeliveryOrderList {
+  @Field(type => [DeliveryOrder], { nullable: true })
+  items: DeliveryOrder[]
+
+  @Field(type => Int, { nullable: true })
+  total: number
+}
+
+@InputType()
+export class NewDeliveryOrder {
+  @Field({ nullable: true })
+  cargoType: string
+
+  @Field({ nullable: true })
+  contactCompany: string
+
+  @Field({ nullable: true })
+  contactEmail: string
+
+  @Field({ nullable: true })
+  contactName: string
+
+  @Field({ nullable: true })
+  contactPhone: string
+
+  @Field({ nullable: true })
+  contactPointRefId: string
+
+  @Field({ nullable: true })
+  contactType: string
+  @Field({ nullable: true })
+  deliveryDate: string
+  @Field({ nullable: true })
+  deliveryDateTime: string
+  @Field({ nullable: true })
+  description: string
+  @Field({ nullable: true })
+  from: string
+
+  @Field(type => Float, { nullable: false })
+  loadWeight: number
+
+  @Field({ nullable: true })
+  looseItem: Boolean
+
+  @Field({ nullable: true })
+  name: string
+
+  @Field({ nullable: true })
+  otherBillingAddress: string
+
+  @Field({ nullable: true })
+  otherDestination: string
+
+  @Field({ nullable: true })
+  otherDriver: string
+
+  @Field({ nullable: true })
+  ownCollection: Boolean
+
+  @Field(type => Int, { nullable: true })
+  palletQty: number
+  @Field({ nullable: true })
+  refNo: string
+
+  @Field({ nullable: true })
+  status: string
+
+  @Field({ nullable: true })
+  telNo: string
+
+  @Field({ nullable: true })
+  to: string
+
+  @Field({ nullable: true })
+  transportDriver: string
+
+  @Field({ nullable: true })
+  transportVehicle: string
+
+  @Field({ nullable: true })
+  truckNo: string
+
+  @Field({ nullable: true })
+  urgency: Boolean
+
+  @Field({ nullable: true })
+  remark: string
+}
+
+@InputType()
+export class GenerateDeliveryOrder {
+  @Field({ nullable: true })
+  name: string
+
+  @Field({ nullable: true })
+  from: string
+
+  @Field({ nullable: true })
+  to: string
+
+  @Field(type => Float, { nullable: false })
+  loadWeight: number
+
+  @Field({ nullable: true })
+  urgency: Boolean
+
+  @Field({ nullable: true })
+  cargoType: string
+
+  @Field({ nullable: true })
+  ownCollection: Boolean
+
+  @Field({ nullable: true })
+  truckNo: string
+
+  @Field({ nullable: true })
+  refNo: string
+
+  @Field({ nullable: true })
+  looseItem: Boolean
+
+  @Field()
+  deliveryDate: string
+
+  @Field({ nullable: true })
+  deliveryDateTime: string
+
+  @Field({ nullable: true })
+  telNo: string
+
+  @Field({ nullable: true })
+  palletQty: string
+
+  @Field({ nullable: true })
+  status: string
+
+  @Field({ nullable: true })
+  description: string
+}
+
+@InputType()
+export class DeliveryOrderPatch {
+  @Field(type => ID, { nullable: true })
+  id: string
+
+  @Field({ nullable: true })
+  name: string
+
+  @Field({ nullable: true })
+  truckNo: string
+
+  @Field({ nullable: true })
+  from: string
+
+  @Field({ nullable: true })
+  to: string
+
+  @Field({ nullable: true })
+  contactPointRefId: string
+
+  @Field({ nullable: true })
+  refNo: string
+
+  @Field(type => Float, { nullable: true })
+  loadWeight: number
+
+  @Field({ nullable: true })
+  contactName: string
+
+  @Field({ nullable: true })
+  contactPhone: string
+
+  @Field({ nullable: true })
+  contactEmail: string
+
+  @Field({ nullable: true })
+  contactCompany: string
+
+  @Field({ nullable: true })
+  contactType: string
+
+  @Field({ nullable: true })
+  urgency: Boolean
+
+  @Field({ nullable: true })
+  ownCollection: Boolean
+
+  @Field({ nullable: true })
+  contactPoint: string
+
+  @Field({ nullable: true })
+  cargoType: string
+
+  @Field({ nullable: true })
+  otherDriver: string
+
+  @Field({ nullable: true })
+  palletQty: string
+
+  @Field({ nullable: true })
+  ownDriver: string
+
+  @Field({ nullable: true })
+  otherTruck: string
+
+  @Field({ nullable: true })
+  ownTruck: string
+
+  @Field({ nullable: true })
+  otherDestination: string
+
+  @Field({ nullable: true })
+  billingAddress: string
+
+  @Field({ nullable: true })
+  deliveryDate: string
+
+  @Field({ nullable: true })
+  deliveryDateTime: string
+
+  @Field({ nullable: true })
+  looseItem: Boolean
+
+  @Field(type => ObjectRef, { nullable: true })
+  transportDriver: ObjectRef
+
+  @Field(type => ObjectRef, { nullable: true })
+  transportVehicle: ObjectRef
+
+  @Field({ nullable: true })
+  driverName: string
+
+  @Field({ nullable: true })
+  remark: string
+
+  @Field({ nullable: true })
+  telNo: string
+
+  @Field({ nullable: true })
+  status: string
+
+  @Field({ nullable: true })
+  reusablePallet: string
+
+  @Field({ nullable: true })
+  description: string
+}