@things-factory/sales-base 3.7.2 → 3.7.7

package/server/graphql/resolvers/release-good/release-good-requests.ts

@@ -83,7 +83,7 @@ export const releaseGoodRequestsResolver = {
         'cc.status = rg.status'
       )
 
-      const arrChildSortData = ['bizplace']
+      const arrChildSortData = ['bizplace', 'creator']
       const sort = (params.sortings || []).reduce(
         (acc, sort) => ({
           ...acc,
@@ -91,7 +91,7 @@ export const releaseGoodRequestsResolver = {
             ? 'DESC'
             : 'ASC'
         }),
-        !params.sortings.some(e => e.name === 'status') ? { rank: 'ASC' } : {}
+        params.sortings.length < 1 ? { rank: 'ASC', 'rg.createdAt': 'DESC' } : {}
       )
 
       qb.orderBy(sort)

package/server/graphql/resolvers/release-good/release-good.ts

@@ -1,14 +1,17 @@
+import { getRepository, In } from 'typeorm'
+
 import { User } from '@things-factory/auth-base'
 import { getPermittedBizplaceIds } from '@things-factory/biz-base'
+import { ProductDetail } from '@things-factory/product-base'
 import { Domain } from '@things-factory/shell'
-import { getRepository, In } from 'typeorm'
-import { ReleaseGood } from '../../../entities'
+
+import { OrderInventory, ReleaseGood } from '../../../entities'
 
 export const releaseGoodResolver = {
   async releaseGood(_: any, { name }, context: any) {
     const { domain, user }: { domain: Domain; user: User } = context.state
 
-    return await getRepository(ReleaseGood).findOne({
+    let releaseGood: ReleaseGood = await getRepository(ReleaseGood).findOne({
       where: {
         domain,
         name,
@@ -23,11 +26,32 @@ export const releaseGoodResolver = {
         'orderInventories.product',
         'orderInventories.inventory',
         'orderInventories.inventory.product',
+        'orderInventories.inventory.location',
         'orderVass',
         'orderVass.vas',
         'creator',
         'updater'
       ]
     })
+
+    releaseGood.orderInventories = await Promise.all(
+      releaseGood.orderInventories.map(async (orderInventory: OrderInventory) => {
+        const productDetails: ProductDetail[] = await getRepository(ProductDetail).find({
+          where: {
+            product: orderInventory.product.id,
+            packingType: orderInventory.packingType,
+            packingSize: orderInventory.packingSize
+          }
+        })
+
+        orderInventory.product['productDetails'] = productDetails
+
+        if (orderInventory.inventory) orderInventory.inventory.product['productDetails'] = productDetails
+
+        return orderInventory
+      })
+    )
+
+    return releaseGood
   }
 }

package/server/graphql/resolvers/release-good/update-release-good-details.ts

@@ -0,0 +1,61 @@
+import { EntityManager } from 'typeorm'
+
+import { User } from '@things-factory/auth-base'
+import { getMyBizplace } from '@things-factory/biz-base'
+import { Domain } from '@things-factory/shell'
+
+import { ORDER_STATUS } from '../../../constants'
+import { ReleaseGood, ShippingOrder } from '../../../entities'
+import { OrderNoGenerator } from '../../../utils/order-no-generator'
+
+export const updateReleaseGoodDetailsResolver = {
+  async updateReleaseGoodDetails(_: any, { releaseGood, shippingOrder }, context: any) {
+    const { tx }: { tx: EntityManager } = context.state
+
+    try {
+      return updateReleaseGoodFunction(releaseGood, shippingOrder, context, tx)
+    } catch (error) {
+      throw error
+    }
+  }
+}
+
+export async function updateReleaseGoodFunction(
+  releaseGood: ReleaseGood,
+  shippingOrder: ShippingOrder,
+  context: any,
+  tx?: EntityManager
+) {
+  const { domain, user }: { domain: Domain; user: User } = context.state
+  let foundReleaseGood = await tx.getRepository(ReleaseGood).findOne({
+    where: { id: releaseGood.id, name: releaseGood.name, domain },
+    relations: ['shippingOrder']
+  })
+
+  if (!foundReleaseGood) {
+    throw new Error(`Release Order ${releaseGood.name} is not found.`)
+  }
+
+  // case to update existing shippingOrder
+  if (foundReleaseGood.shippingOrder && shippingOrder) {
+    await tx.getRepository(ShippingOrder).update(foundReleaseGood.shippingOrder.id, shippingOrder)
+  }
+  // case for new shippingOrder
+  else if (!foundReleaseGood.shippingOrder && shippingOrder) {
+    let newShippingOrder: ShippingOrder = await tx.getRepository(ShippingOrder).save({
+      ...shippingOrder,
+      name: OrderNoGenerator.shippingOrder(),
+      domain,
+      bizplace: await getMyBizplace(domain, user),
+      status: ORDER_STATUS.PENDING,
+      creator: user,
+      updater: user
+    })
+
+    releaseGood.shippingOrder = newShippingOrder
+  }
+
+  await tx.getRepository(ReleaseGood).update(foundReleaseGood.id, releaseGood)
+  // return updated Release Good
+  return await tx.getRepository(ReleaseGood).findOne(foundReleaseGood.id)
+}

package/server/graphql/resolvers/reverse-kitting-order/cancel-reverse-kitting-order.ts

@@ -2,6 +2,7 @@ import { EntityManager } from 'typeorm'
 
 import { User } from '@things-factory/auth-base'
 import { Domain } from '@things-factory/shell'
+import { Inventory } from '@things-factory/warehouse-base'
 
 import { ORDER_STATUS, ORDER_VAS_STATUS } from '../../../constants'
 import { OrderReverseKitting, ReverseKittingOrder } from '../../../entities'
@@ -24,7 +25,7 @@ export async function cancelReverseKittingOrderFunction(
 
   const foundReverseKittingOrder: ReverseKittingOrder = await tx.getRepository(ReverseKittingOrder).findOne({
     where: { domain, name, status: ORDER_STATUS.READY_TO_EXECUTE },
-    relations: ['bizplace', 'orderReverseKittings', 'creator', 'updater']
+    relations: ['bizplace', 'orderReverseKittings', 'orderReverseKittings.inventory', 'creator', 'updater']
   })
 
   let foundORKs: OrderReverseKitting[] = foundReverseKittingOrder.orderReverseKittings
@@ -38,9 +39,22 @@ export async function cancelReverseKittingOrderFunction(
     updater: user
   })
 
-  foundORKs = foundORKs.map((ork: OrderReverseKitting) => {
-    return { ...ork, status: ORDER_VAS_STATUS.CANCELLED }
-  })
+  foundORKs = await Promise.all(
+    foundORKs.map(async (ork: OrderReverseKitting) => {
+      if (ork?.inventory?.id) {
+        ork.inventory = await tx.getRepository(Inventory).findOne(ork.inventory.id)
+
+        await tx.getRepository(Inventory).save({
+          ...ork.inventory,
+          lockedQty: ork.inventory.lockedQty - ork.qty,
+          lockedUomValue: ork.inventory.lockedUomValue - ork.uomValue,
+          updater: user
+        })
+      }
+
+      return { ...ork, status: ORDER_VAS_STATUS.CANCELLED }
+    })
+  )
   await tx.getRepository(OrderReverseKitting).save(foundORKs)
 
   return reverseKitting

package/server/graphql/resolvers/reverse-kitting-order/complete-reverse-kitting-order.ts

@@ -25,7 +25,9 @@ export const completeReverseKittingOrderResolver = {
       orderReverseKittings.map(async orderReverseKitting => {
         let inventory: Inventory = orderReverseKitting.inventory
         inventory.qty = inventory.qty - orderReverseKitting.qty
+        inventory.lockedQty = inventory.lockedQty - orderReverseKitting.qty
         inventory.uomValue = inventory.uomValue - orderReverseKitting.uomValue
+        inventory.lockedUomValue = inventory.lockedUomValue - orderReverseKitting.uomValue
 
         await InventoryUtil.transactionInventory(
           inventory,

package/server/graphql/resolvers/reverse-kitting-order/delete-reverse-kitting-order.ts

@@ -2,6 +2,7 @@ import { EntityManager, In } from 'typeorm'
 
 import { User } from '@things-factory/auth-base'
 import { Domain } from '@things-factory/shell'
+import { Inventory } from '@things-factory/warehouse-base'
 
 import { OrderReverseKitting, ReverseKittingOrder } from '../../../entities'
 
@@ -21,13 +22,30 @@ export async function deleteReverseKittingOrder(
 ): Promise<boolean> {
   let foundReverseKittingOrder: ReverseKittingOrder = await tx.getRepository(ReverseKittingOrder).findOne({
     where: { domain, name },
-    relations: ['bizplace', 'orderReverseKittings', 'creator', 'updater']
+    relations: ['bizplace', 'orderReverseKittings', 'orderReverseKittings.inventory', 'creator', 'updater']
   })
 
   if (!foundReverseKittingOrder) throw new Error(`Reverse kitting order doesn't exists.`)
 
   const foundORKs: OrderReverseKitting[] = foundReverseKittingOrder.orderReverseKittings
 
+  // Delete order reverse kittings by ids
+  await Promise.all(
+    foundORKs.map(async (ork: OrderReverseKitting) => {
+      if (ork?.inventory?.id) {
+        ork.inventory = await tx.getRepository(Inventory).findOne(ork.inventory.id)
+
+        await tx.getRepository(Inventory).save({
+          ...ork.inventory,
+          lockedQty: ork.inventory.lockedQty - ork.qty,
+          lockedUomValue: ork.inventory.lockedUomValue - ork.uomValue,
+          updater: user
+        })
+      }
+      return ork
+    })
+  )
+
   // 1. delete order reverse kittings
   const productIds = foundORKs.map((ork: OrderReverseKitting) => ork.id)
   if (productIds.length) {

package/server/graphql/resolvers/reverse-kitting-order/execute-reverse-kitting.ts

@@ -50,7 +50,6 @@ export async function executeReverseKittingFunction(
 
   const productDetail: ProductDetail = await tx.getRepository(ProductDetail).findOne({
     where: {
-      domain: customerCompanyBizplace.domain,
       id: inventory.productDetailId
     },
     relations: ['product']
@@ -115,7 +114,7 @@ export async function executeReverseKittingFunction(
   let productCombinationSets: any[] = operationGuide.data.productCombinationSets
   operationGuide.data.productCombinationSets = productCombinationSets.map(item => {
     if (item.productDetailId == inventory.productDetailId) {
-      item.actualQty++
+      item.actualQty += qty
     }
     return item
   })

package/server/graphql/resolvers/reverse-kitting-order/generate-reverse-kitting-order.ts

@@ -38,7 +38,14 @@ export const generateReverseKittingOrder = {
     orderReverseKittings = await Promise.all(
       orderReverseKittings.map(async (ork: OrderReverseKitting) => {
         if (ork?.inventory?.id) {
-          ork.inventory = await tx.getRepository(Inventory).findOne(ork.inventory.id)
+          const foundInv: Inventory = await tx.getRepository(Inventory).findOne(ork.inventory.id)
+          ork.inventory = foundInv
+
+          foundInv.lockedQty = Number(foundInv.lockedQty) + ork.qty
+          foundInv.lockedUomValue = Number(foundInv.lockedUomValue) + ork.uomValue
+          foundInv.updater = user
+
+          await tx.getRepository(Inventory).save(foundInv)
         }
         return {
           ...ork,

package/server/graphql/resolvers/reverse-kitting-order/generate-reverse-kitting-pallet-id.ts

@@ -0,0 +1,71 @@
+import { EntityManager, In } from 'typeorm'
+
+import { generateId } from '@things-factory/id-rule-base'
+import { Domain } from '@things-factory/shell'
+
+import { OrderReverseKitting } from '../../../entities'
+
+export const generateReverseKittingPalletIdResolver = {
+  async generateReverseKittingPalletId(_: any, { targets, type }, context: any) {
+    const { tx, domain }: { tx: EntityManager; domain: Domain } = context.state
+    // 1. get and set the date
+    const today = new Date()
+    const year = today.getFullYear()
+    const month = today.getMonth()
+    const day = today.getDate()
+
+    const yy = String(year).substr(String(year).length - 2)
+    const mm = String(month + 1).padStart(2, '0')
+    const dd = String(day).padStart(2, '0')
+
+    const date = yy + mm + dd
+    let results = []
+
+    // 2. get worksheet detail
+    let ids = targets.map(target => target.id)
+
+    // - getRepository using In(array) to pass the value to defined variable
+    const foundOrderReverseKittings: OrderReverseKitting[] = await tx.getRepository(OrderReverseKitting).find({
+      where: {
+        domain,
+        id: In(ids)
+      },
+      relations: ['domain', 'bizplace']
+    })
+
+    // 3. from worksheet detail get product name, product type, batchid, packing type, bizplace
+
+    if (foundOrderReverseKittings.length <= 0) throw new Error('Unable to find order reverse kittings')
+    else {
+      for (let i = 0; i < foundOrderReverseKittings.length; i++) {
+        let foundORK = foundOrderReverseKittings[i]
+        for (let idx = 0; idx < targets.length; idx++) {
+          if (foundORK.id === targets[idx].id) {
+            // 4. generate pallet id based on print qty > call generateId resolver
+            for (let i = 0; i < targets[idx].printQty; i++) {
+              const generatedPalletId = await generateId({
+                domain,
+                type,
+                seed: {
+                  batchId: foundORK.inventory.batchId,
+                  date: date
+                }
+              })
+
+              // 5. map all data to be returned
+              if (foundORK != null) {
+                results.push({
+                  ...foundORK,
+                  palletId: generatedPalletId,
+                  bizplace: foundORK.bizplace
+                })
+              }
+            }
+          }
+        }
+      }
+    }
+
+    return results
+  }
+}

package/server/graphql/resolvers/reverse-kitting-order/index.ts

@@ -6,9 +6,11 @@ import { deleteReverseKittingOrderResolver } from './delete-reverse-kitting-orde
 import { executeReverseKittingResolver } from './execute-reverse-kitting'
 import { executingReverseKittingOrderResolver } from './executing-reverse-kitting-order'
 import { generateReverseKittingOrder } from './generate-reverse-kitting-order'
+import { generateReverseKittingPalletIdResolver } from './generate-reverse-kitting-pallet-id'
 import { reverseKittingInventoriesResolver } from './reverse-kitting-inventories'
 import { reverseKittingOrderResolver } from './reverse-kitting-order'
 import { reverseKittingOrdersResolver } from './reverse-kitting-orders'
+import { undoReverseKittingInventoryResolver } from './undo-reverse-kitting-inventory'
 
 export const Query = {
   ...reverseKittingOrdersResolver,
@@ -24,5 +26,7 @@ export const Mutation = {
   ...deleteReverseKittingOrderResolver,
   ...cancelReverseKittingOrderResolver,
   ...executeReverseKittingResolver,
-  ...completeReverseKittingOrderResolver
+  ...completeReverseKittingOrderResolver,
+  ...generateReverseKittingPalletIdResolver,
+  ...undoReverseKittingInventoryResolver
 }

package/server/graphql/resolvers/reverse-kitting-order/reverse-kitting-inventories.ts

@@ -1,6 +1,7 @@
 import { getRepository } from 'typeorm'
 
 import { Bizplace } from '@things-factory/biz-base'
+import { Product, ProductDetail } from '@things-factory/product-base'
 import { Domain } from '@things-factory/shell'
 import { Inventory, INVENTORY_STATUS } from '@things-factory/warehouse-base'
 
@@ -8,8 +9,16 @@ import { ORDER_VAS_STATUS } from '../../../constants'
 import { OrderReverseKitting, ReverseKittingOrder } from '../../../entities'
 
 export const reverseKittingInventoriesResolver = {
-  async reverseKittingInventories(_: any, { orderReverseKittingName }, context: any) {
+  async reverseKittingInventories(_: any, { orderReverseKittingName, productDetailId }, context: any) {
     const { domain }: { domain: Domain } = context.state
+
+    const productDetail: ProductDetail = await getRepository(ProductDetail).findOne({
+      where: { id: productDetailId },
+      relations: ['product']
+    })
+
+    const product: Product = productDetail.product
+
     const foundOrderReverseKitting: OrderReverseKitting = await getRepository(OrderReverseKitting).findOne({
       where: {
         domain,
@@ -29,9 +38,10 @@ export const reverseKittingInventoriesResolver = {
         bizplace: customerBizplace,
         refOrderId: reverseKittingOrder.id,
         orderVasId: foundOrderReverseKitting.id,
+        product: product,
         status: INVENTORY_STATUS.STORED
       },
-      relations: ['product', 'bizplace']
+      relations: ['product', 'bizplace', 'location']
     })
   }
 }

package/server/graphql/resolvers/reverse-kitting-order/undo-reverse-kitting-inventory.ts

@@ -0,0 +1,70 @@
+import { EntityManager } from 'typeorm'
+
+import { User } from '@things-factory/auth-base'
+import { Bizplace } from '@things-factory/biz-base'
+import { Domain } from '@things-factory/shell'
+import {
+  Inventory,
+  INVENTORY_STATUS,
+  INVENTORY_TRANSACTION_TYPE,
+  InventoryHistory
+} from '@things-factory/warehouse-base'
+
+import { OrderReverseKitting, ReverseKittingOrder } from '../../../entities'
+import { InventoryUtil } from '../../../utils'
+
+export const undoReverseKittingInventoryResolver = {
+  async undoReverseKittingInventory(_: any, { orderReverseKittingName, palletId }, context: any) {
+    const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
+
+    //@sumjoekin please add stricter validation. It is dangerous without strict validation. Unexpected behaviour will cause accidental deletion of inventory.
+
+    const orderReverseKitting: OrderReverseKitting = await tx.getRepository(OrderReverseKitting).findOne({
+      where: { domain, name: orderReverseKittingName },
+      relations: ['bizplace', 'reverseKittingOrder']
+    })
+
+    const bizplace: Bizplace = orderReverseKitting.bizplace
+    const reverseKittingOrder: ReverseKittingOrder = orderReverseKitting.reverseKittingOrder
+    let foundInventory: Inventory = await tx.getRepository(Inventory).findOne({
+      where: { domain, bizplace, orderVasId: orderReverseKitting.id, palletId },
+      relations: ['bizplace', 'product']
+    })
+    if (!foundInventory) throw new Error(`There's no results matched with condition ${foundInventory.palletId}`)
+
+    let operationGuide: any = JSON.parse(orderReverseKitting.operationGuide)
+    let productCombinationSets: any[] = operationGuide.data.productCombinationSets
+    productCombinationSets = productCombinationSets.map(item => {
+      if (foundInventory.product.id == item.productId) {
+        item.actualQty -= foundInventory.qty
+      }
+      return item
+    })
+    operationGuide.data.productCombinationSets = productCombinationSets
+
+    await tx
+      .getRepository(OrderReverseKitting)
+      .update({ id: orderReverseKitting.id }, { operationGuide: operationGuide })
+
+    foundInventory.lastSeq++
+    foundInventory.status = INVENTORY_STATUS.DELETED
+    foundInventory = await InventoryUtil.transactionInventory(
+      foundInventory,
+      reverseKittingOrder,
+      -foundInventory.qty,
+      -foundInventory.uomValue,
+      INVENTORY_TRANSACTION_TYPE.UNDO_REVERSE_KITTING,
+      user,
+      tx
+    )
+    foundInventory.qty = 0
+    foundInventory.uomValue = 0
+    foundInventory.updater = this.user
+
+    await tx.getRepository(InventoryHistory).update({ inventory: foundInventory }, { inventory: null })
+
+    await tx.getRepository(Inventory).delete({ id: foundInventory.id })
+
+    return true
+  }
+}

package/server/graphql/types/index.ts

@@ -8,6 +8,7 @@ import * as GoodsReceivalNote from './goods-receival-note'
 import * as InventoryCheck from './inventory-check'
 import * as Invoice from './invoice'
 import * as JobSheet from './job-sheet'
+import * as Manifest from './manifest'
 import * as OrderInventory from './order-inventory'
 import * as OrderProduct from './order-product'
 import * as OrderReverseKitting from './order-reverse-kitting'
@@ -49,7 +50,8 @@ export const queries = [
   GoodsReceivalNote.Query,
   Others.Query,
   OrderReverseKitting.Query,
-  ReverseKittingOrder.Query
+  ReverseKittingOrder.Query,
+  Manifest.Query
 ]
 
 export const mutations = [
@@ -76,7 +78,8 @@ export const mutations = [
   VasOrder.Mutation,
   GoodsReceivalNote.Mutation,
   ReverseKittingOrder.Mutation,
-  OrderReverseKitting.Mutation
+  OrderReverseKitting.Mutation,
+  Manifest.Mutation
 ]
 
 export const types = [
@@ -104,5 +107,6 @@ export const types = [
   ...GoodsReceivalNote.Types,
   ...Others.Types,
   ...ReverseKittingOrder.Types,
-  ...OrderReverseKitting.Types
+  ...OrderReverseKitting.Types,
+  ...Manifest.Types
 ]

package/server/graphql/types/manifest/index.ts

@@ -0,0 +1,34 @@
+import { Manifest } from './manifest'
+import { ManifestItem } from './manifest-item'
+import { ManifestList } from './manifest-list'
+import { ManifestPatch } from './manifest-patch'
+import { NewManifest } from './new-manifest'
+import { TrackingNo } from './tracking-no'
+
+export const Mutation = `
+  generateManifest (
+    manifest: NewManifest
+  ): Boolean @transaction
+
+  dispatchManifest (
+    name: String!
+    patch: ManifestPatch!
+  ): Manifest @transaction
+
+  deleteManifest (
+    name: String!
+  ): Manifest @transaction
+`
+
+export const Query = `
+  manifests(
+    filters: [Filter],
+    pagination: Pagination,sortings: [Sorting]
+  ): ManifestList @transaction
+
+  manifest(
+    name: String!
+  ): Manifest @transaction
+`
+
+export const Types = [Manifest, NewManifest, ManifestList, ManifestPatch, ManifestItem, TrackingNo]

package/server/graphql/types/manifest/manifest-item.ts

@@ -0,0 +1,9 @@
+import gql from 'graphql-tag'
+
+export const ManifestItem = gql`
+  input ManifestItem {
+    trackingNo: String
+    refNo: String
+    transporter: String
+  }
+`

package/server/graphql/types/manifest/manifest-list.ts

@@ -0,0 +1,8 @@
+import gql from 'graphql-tag'
+
+export const ManifestList = gql`
+  type ManifestList {
+    items: [Manifest]
+    total: Int
+  }
+`

package/server/graphql/types/manifest/manifest-patch.ts

@@ -0,0 +1,13 @@
+import gql from 'graphql-tag'
+
+export const ManifestPatch = gql`
+  input ManifestPatch {
+    id: String
+    name: String
+    shippingProvider: String
+    dispatcherName: String
+    dispatcherIdentity: String
+    status: String
+    cuFlag: String
+  }
+`

package/server/graphql/types/manifest/manifest.ts

@@ -0,0 +1,19 @@
+import gql from 'graphql-tag'
+
+export const Manifest = gql`
+  type Manifest {
+    id: String
+    name: String
+    domain: Domain
+    shippingProvider: String
+    dispatcherName: String
+    dispatcherIdentity: String
+    dispatchedAt: String
+    trackingNos: [TrackingNo]
+    status: String
+    updater: User
+    creator: User
+    updatedAt: String
+    createdAt: String
+  }
+`

package/server/graphql/types/manifest/new-manifest.ts

@@ -0,0 +1,7 @@
+import gql from 'graphql-tag'
+
+export const NewManifest = gql`
+  input NewManifest {
+    manifestItems: [ManifestItem]
+  }
+`

package/server/graphql/types/manifest/tracking-no.ts

@@ -0,0 +1,14 @@
+import gql from 'graphql-tag'
+
+export const TrackingNo = gql`
+  type TrackingNo {
+    trackingNo: String
+    refNo: String
+    dispatchmentStatus: String
+    deliveryAddress: String
+    attentionTo: String
+    postalCode: String
+    phone: String
+    city: String
+  }
+`

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

@@ -11,12 +11,16 @@ export const Mutation = /* GraphQL */ `
   deleteOrderInventories (
     names: [String]!
   ): Boolean @transaction
+
+  updateOrderInventorySerialNumber(
+    orderInventory: OrderInventoryPatch
+  ): OrderInventory @transaction
 `
 
 export const Query = /* GraphQL */ `
   orderInventories(filters: [Filter], pagination: Pagination, sortings: [Sorting]): OrderInventoryList
   mergedProductOrderInventories(filters: [Filter], pagination: Pagination, sortings: [Sorting]): OrderInventoryList
-  orderInventory(name: String!): OrderInventory
+  orderInventory(id: String!): OrderInventory
   inventoriesByOrder(filters: [Filter], pagination: Pagination, sortings: [Sorting]): OrderInventoryList
 `
 

package/server/graphql/types/order-inventory/new-order-inventory.ts

@@ -27,6 +27,7 @@ export const NewOrderInventory = gql`
     remark: String
     issue: String
     crossDocking: Boolean
+    serialNumber: String
     status: String
     existingRow: Boolean
     returnQty: Float

package/server/graphql/types/order-inventory/order-inventory-patch.ts

@@ -34,6 +34,7 @@ export const OrderInventoryPatch = gql`
     remark: String
     issue: String
     crossDocking: Boolean
+    serialNumber: String
     status: String
     pallet: String
     extraJsonData: String

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

@@ -47,6 +47,7 @@ export const OrderInventory = gql`
     actualPackQty: Float
     actualPalletQty: Float
     crossDocking: Boolean
+    serialNumber: String
     status: String
     updater: User
     creator: User