@things-factory/sales-base 4.0.0-alpha.9 → 4.0.0-beta.0

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

@@ -0,0 +1,253 @@
+import { Arg, Args, Ctx, FieldResolver, Query, Resolver, Root } from 'type-graphql'
+import { getRepository, Like, SelectQueryBuilder } from 'typeorm'
+
+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 { ArrivalNotice, OrderInventoryList, ReleaseGood } from '../'
+import { OrderInventory } from './order-inventory'
+
+interface filterInterface {
+  name: string
+  operator: string
+  value: any
+}
+@Resolver(OrderInventory)
+export class OrderInventoryQuery {
+  @Query(returns => OrderInventoryList)
+  async orderInventories(@Ctx() context: any, @Args() params: ListParam): Promise<OrderInventoryList> {
+    const { domain }: { domain: Domain } = context.state
+    let filters = params.filters
+
+    // in case client side passes arrival notice or release good number as filter (single value only)
+    const anParam = filters.find(
+      (filter: filterInterface) => filter.name === 'arrivalNoticeNo' && filter.operator === 'eq'
+    )
+    const rgParam = filters.find(
+      (filter: filterInterface) => filter.name === 'releaseGoodNo' && filter.operator === 'eq'
+    )
+
+    if (anParam && !filters.some((filter: filterInterface) => filter.name === 'arrivalNotice')) {
+      const foundArrivalNotice: ArrivalNotice = await getRepository(ArrivalNotice).findOne({
+        where: {
+          name: anParam.value,
+          domain
+        }
+      })
+
+      if (foundArrivalNotice) {
+        filters = params.filters.filter((filter: filterInterface) => filter.name !== 'arrivalNoticeNo')
+        params.filters = [...filters, { name: 'arrivalNotice', operator: 'eq', value: foundArrivalNotice.id }]
+      } else throw new Error(`Cannot find result for order "${anParam.value}"`)
+    }
+
+    if (rgParam && !filters.some(filter => filter.name === 'releaseGood')) {
+      const foundReleaseGood: ReleaseGood = await getRepository(ReleaseGood).findOne({
+        where: {
+          name: rgParam.value,
+          domain
+        }
+      })
+
+      if (foundReleaseGood) {
+        filters = params.filters.filter(filter => filter.name !== 'releaseGoodNo')
+        params.filters = [...filters, { name: 'releaseGood', operator: 'eq', value: foundReleaseGood.id }]
+      } else throw new Error(`Cannot find result for order "${rgParam.value}"`)
+    }
+
+    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 }
+  }
+
+  @Query(returns => OrderInventoryList)
+  async mergedProductOrderInventories(
+    @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<OrderInventoryList> {
+    const convertedParams = convertListParams({ filters, pagination, sortings })
+    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 }
+  }
+
+  @Query(returns => OrderInventory)
+  async orderInventory(@Arg('name') name: string, @Ctx() context: any): Promise<OrderInventory> {
+    const { domain }: { domain: Domain } = context.state
+
+    return await getRepository(OrderInventory).findOne({
+      where: { domain, name },
+      relations: ['domain', 'releaseGood', 'vasOrder', 'shippingOrder', 'inventory', 'creator', 'updater']
+    })
+  }
+
+  @Query(returns => OrderInventoryList)
+  async inventoriesByOrder(
+    @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<OrderInventoryList> {
+    const { domain, user }: { domain: Domain; user: User } = context.state
+
+    let permittedBizplaceIds: string[] = await getPermittedBizplaceIds(domain, user)
+
+    if (!filters.find((filter: any) => filter.name === 'bizplaceId')) {
+      filters.push({
+        name: 'bizplaceId',
+        operator: 'in',
+        value: permittedBizplaceIds,
+        relation: true
+      })
+    } else {
+      permittedBizplaceIds = filters.find(filter => filter.name === 'bizplaceId').value
+      filters.find(filter => filter.name === 'bizplaceId').relation = true
+    }
+
+    if (filters.find((filter: any) => filter.name === 'releaseGoodName')?.value) {
+      let releaseGood: ReleaseGood = await getRepository(ReleaseGood).findOne({
+        where: {
+          name: Like(filters.find(filter => filter.name === 'releaseGoodName').value)
+        }
+      })
+
+      if (releaseGood) {
+        filters = filters.filter(filter => filter.name != 'releaseGoodName')
+
+        filters.push({
+          name: 'releaseGoodId',
+          operator: 'eq',
+          value: releaseGood.id,
+          relation: true
+        })
+      }
+    }
+    const qb: SelectQueryBuilder<OrderInventory> = getRepository(OrderInventory).createQueryBuilder('oi')
+    buildQuery(qb, { filters, pagination, sortings }, 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 }
+  }
+
+  @FieldResolver(type => Domain)
+  async domain(@Root() orderInventory: OrderInventory): Promise<Domain> {
+    return await getRepository(Domain).findOne(orderInventory.domainId)
+  }
+
+  @FieldResolver(type => User)
+  async creator(@Root() orderInventory: OrderInventory): Promise<User> {
+    return await getRepository(User).findOne(orderInventory.creatorId)
+  }
+
+  @FieldResolver(type => User)
+  async updater(@Root() orderInventory: OrderInventory): Promise<User> {
+    return await getRepository(User).findOne(orderInventory.updaterId)
+  }
+}

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

@@ -0,0 +1,212 @@
+import { NewProduct } from '@things-factory/product-base'
+import { ObjectRef } from '@things-factory/shell'
+import { InventoryPatch } from '@things-factory/warehouse-base'
+import { Field, Float, InputType, Int, ObjectType } from 'type-graphql'
+import { OrderInventory } from './order-inventory'
+
+@ObjectType()
+export class OrderInventoryList {
+  @Field(type => [OrderInventory], { nullable: true })
+  items: OrderInventory[]
+
+  @Field(type => Int, { nullable: true })
+  total: number
+}
+
+@InputType()
+export class NewOrderInventory {
+  @Field({ nullable: true })
+  name: string
+
+  @Field({ nullable: true })
+  description: string
+
+  @Field({ nullable: true })
+  type: string
+
+  @Field(type => ObjectRef, { nullable: true })
+  arrivalNotice: ObjectRef
+
+  @Field(type => ObjectRef, { nullable: true })
+  deliveryOrder: ObjectRef
+
+  @Field(type => ObjectRef, { nullable: true })
+  transferOrder: ObjectRef
+
+  @Field(type => InventoryPatch, { nullable: true })
+  inventory: InventoryPatch
+
+  @Field(type => NewProduct, { nullable: true })
+  product: NewProduct
+
+  @Field({ nullable: true })
+  productSKU: string
+
+  @Field({ nullable: true })
+  batchId: string
+
+  @Field({ nullable: true })
+  batchIdRef: string
+
+  @Field({ nullable: true })
+  productName: string
+
+  @Field({ nullable: true })
+  batchExp: string
+
+  @Field({ nullable: true })
+  packingType: string
+
+  @Field(type => Float, { nullable: true })
+  packingSize: number
+
+  @Field(type => Float, { nullable: true })
+  releaseQty: number
+
+  @Field(type => Float, { nullable: true })
+  pickedQty: number
+
+  @Field(type => Float, { nullable: true })
+  sortedQty: number
+
+  @Field(type => Float, { nullable: true })
+  packedQty: number
+
+  @Field(type => Float, { nullable: true })
+  releaseUomValue: number
+
+  @Field({ nullable: true })
+  uom: string
+
+  @Field(type => Int, { nullable: true })
+  palletQty: number
+
+  @Field({ nullable: true })
+  remark: string
+
+  @Field({ nullable: true })
+  issue: string
+
+  @Field({ nullable: true })
+  crossDocking: boolean
+
+  @Field({ nullable: true })
+  status: string
+
+  @Field({ nullable: true })
+  existingRow: boolean
+
+  @Field(type => Float, { nullable: true })
+  returnQty: number
+
+  @Field(type => Float, { nullable: true })
+  returnUomValue: number
+}
+
+@InputType()
+export class OrderInventoryPatch {
+  @Field({ nullable: true })
+  id: string
+
+  @Field({ nullable: true })
+  name: string
+
+  @Field({ nullable: true })
+  description: string
+
+  @Field({ nullable: true })
+  type: string
+
+  @Field(type => ObjectRef, { nullable: true })
+  arrivalNotice: ObjectRef
+
+  @Field(type => ObjectRef, { nullable: true })
+  deliveryOrder: ObjectRef
+
+  @Field(type => ObjectRef, { nullable: true })
+  transferOrder: ObjectRef
+
+  @Field(type => ObjectRef, { nullable: true })
+  returnOrder: ObjectRef
+
+  @Field(type => ObjectRef, { nullable: true })
+  inventory: ObjectRef
+
+  @Field(type => Int, { nullable: true })
+  inspectedQty: number
+
+  @Field(type => Float, { nullable: true })
+  inspectedUomValue: number
+
+  @Field(type => ObjectRef, { nullable: true })
+  inspectedLocation: ObjectRef
+
+  @Field(type => ObjectRef, { nullable: true })
+  binLocation: ObjectRef
+
+  @Field({ nullable: true })
+  inspectedBatchNo: string
+
+  @Field(type => ObjectRef, { nullable: true })
+  product: ObjectRef
+
+  @Field({ nullable: true })
+  batchId: string
+
+  @Field({ nullable: true })
+  batchIdRef: string
+
+  @Field({ nullable: true })
+  packingType: string
+
+  @Field(type => Float, { nullable: true })
+  packingSize: number
+
+  @Field(type => Float, { nullable: true })
+  releaseQty: number
+
+  @Field(type => Float, { nullable: true })
+  sortedQty: number
+
+  @Field(type => Float, { nullable: true })
+  pickedQty: number
+
+  @Field(type => Float, { nullable: true })
+  packedQty: number
+
+  @Field({ nullable: true })
+  productId: string
+
+  @Field({ nullable: true })
+  productName: string
+
+  @Field(type => Float, { nullable: true })
+  releaseUomValue: number
+
+  @Field(type => Float, { nullable: true })
+  returnUomValue: number
+
+  @Field(type => Float, { nullable: true })
+  actualPackQty: number
+
+  @Field(type => Float, { nullable: true })
+  actualPalletQty: number
+
+  @Field({ nullable: true })
+  remark: string
+
+  @Field({ nullable: true })
+  issue: string
+
+  @Field({ nullable: true })
+  crossDocking: Boolean
+
+  @Field({ nullable: true })
+  status: string
+
+  @Field({ nullable: true })
+  pallet: string
+
+  @Field({ nullable: true })
+  extraJsonData: string
+}