@things-factory/worksheet-base 5.0.12 → 6.0.0-alpha.0

package/server/graphql/resolvers/worksheet/vas-candidates.ts

@@ -1,15 +1,17 @@
+import { EntityManager, FindOperator, In } from 'typeorm'
+
 import { Bizplace } from '@things-factory/biz-base'
 import { Product } from '@things-factory/product-base'
 import {
+  ORDER_INVENTORY_STATUS,
+  ORDER_PRODUCT_STATUS,
   OrderInventory,
   OrderProduct,
-  OrderVas,
-  ORDER_INVENTORY_STATUS,
-  ORDER_PRODUCT_STATUS
+  OrderVas
 } from '@things-factory/sales-base'
 import { Domain } from '@things-factory/shell'
 import { Inventory, INVENTORY_STATUS } from '@things-factory/warehouse-base'
-import { EntityManager, FindOperator, In } from 'typeorm'
+
 import { Worksheet, WorksheetDetail } from '../../../entities'
 
 enum OrderType {
@@ -29,9 +31,10 @@ interface IInventoryCondition {
 }
 
 export const vasCandidatesResolver = {
-  async vasCandidates(_: any, { worksheetDetailId }, context: any) {
-    const { tx, domain }: { tx: EntityManager; domain: Domain } = context.state
-    const worksheetDetail: WorksheetDetail = await tx.getRepository(WorksheetDetail).findOne(worksheetDetailId, {
+  async vasCandidates(_: any, { worksheetDetailId }, context: ResolverContext) {
+    const { tx, domain } = context.state
+    const worksheetDetail: WorksheetDetail = await tx.getRepository(WorksheetDetail).findOne({
+      where: { id: worksheetDetailId },
       relations: [
         'bizplace',
         'worksheet',
@@ -80,10 +83,10 @@ export const vasCandidatesResolver = {
         inventories.map(async (inventory: Inventory) => {
           const orderInv: OrderInventory = await tx.getRepository(OrderInventory).findOne({
             where: {
-              domain,
-              bizplace,
-              inventory,
-              releaseGood: worksheet.releaseGood,
+              domain: { id: domain.id },
+              bizplace: { id: bizplace.id },
+              inventory: { id: inventory.id },
+              releaseGood: { id: worksheet.releaseGood.id },
               status: In([ORDER_INVENTORY_STATUS.PICKED])
             }
           })
@@ -127,9 +130,9 @@ async function buildInventoryCondition(
     case OrderType.ArrivalNotice:
       const orderProducts: OrderProduct[] = await tx.getRepository(OrderProduct).find({
         where: {
-          domain,
-          bizplace,
-          arrivalNotice: worksheet.arrivalNotice,
+          domain: { id: domain.id },
+          bizplace: { id: bizplace.id },
+          arrivalNotice: { id: worksheet.arrivalNotice.id },
           status: In([
             ORDER_PRODUCT_STATUS.READY_TO_UNLOAD,
             ORDER_PRODUCT_STATUS.UNLOADING,
@@ -153,9 +156,9 @@ async function buildInventoryCondition(
     case OrderType.ReleaseGood:
       const orderInventories: OrderInventory[] = await tx.getRepository(OrderInventory).find({
         where: {
-          domain,
-          bizplace,
-          releaseGood: worksheet.releaseGood,
+          domain: { id: domain.id },
+          bizplace: { id: bizplace.id },
+          releaseGood: { id: worksheet.releaseGood.id },
           status: In([ORDER_INVENTORY_STATUS.PICKED])
         },
         relations: ['inventory']

package/server/graphql/resolvers/worksheet/vas-inventories.ts

@@ -1,17 +1,19 @@
+import { Equal, Not } from 'typeorm'
+
 import { ArrivalNotice, Bizplace } from '@things-factory/sales-base'
-import { Domain } from '@things-factory/shell'
+import { getRepository } from '@things-factory/shell'
 import { Inventory, INVENTORY_STATUS } from '@things-factory/warehouse-base'
+
+import { WORKSHEET_STATUS, WORKSHEET_TYPE } from '../../../constants'
 import { WorksheetDetail } from '../../../entities'
-import { WORKSHEET_TYPE, WORKSHEET_STATUS } from '../../../constants'
-import { getRepository, Not, Equal } from 'typeorm'
 
 export const vasInventories = {
-  async vasInventories(_: any, { worksheetDetailName }, context: any) {
-    const { domain }: { domain: Domain } = context.state
+  async vasInventories(_: any, { worksheetDetailName }, context: ResolverContext) {
+    const { domain } = context.state
 
     const foundWorksheetDetail: WorksheetDetail = await getRepository(WorksheetDetail).findOne({
       where: {
-        domain,
+        domain: { id: domain.id },
         name: worksheetDetailName,
         type: WORKSHEET_TYPE.VAS,
         status: WORKSHEET_STATUS.EXECUTING
@@ -25,7 +27,7 @@ export const vasInventories = {
     const customerBizplace: Bizplace = foundWorksheetDetail.bizplace
     return await getRepository(Inventory).find({
       where: {
-        domain,
+        domain: { id: domain.id },
         bizplace: customerBizplace,
         refOrderId: vasOrder.id,
         orderVasId: foundWorksheetDetail.targetVas.id,

package/server/graphql/resolvers/worksheet/vas-transactions/common-utils.ts

@@ -47,7 +47,7 @@ export async function getWorksheetDetailByName(
   name: string
 ): Promise<WorksheetDetail> {
   const worksheetDetail: WorksheetDetail = await trxMgr.getRepository(WorksheetDetail).findOne({
-    where: { domain, name },
+    where: { domain: { id: domain.id }, name },
     relations: [
       'bizplace',
       'targetVas',
@@ -90,7 +90,7 @@ export async function updateRelatedOrderVas<T>(
 ): Promise<OrderVas> {
   const worksheet: Worksheet = wsd.worksheet
   const relatedWSDs: WorksheetDetail[] = await trxMgr.getRepository(WorksheetDetail).find({
-    where: { domain, bizplace, worksheet },
+    where: { domain: { id: domain.id }, bizplace: { id: bizplace.id }, worksheet: { id: worksheet.id } },
     relations: ['targetVas', 'targetVas.vas']
   })
 
@@ -178,7 +178,13 @@ export async function getRemainInventoryAmount(
   if (refOrder instanceof ReleaseGood) {
     // Find loading order inventory to figure out uomValue
     const orderInv: OrderInventory = await trxMgr.getRepository(OrderInventory).findOne({
-      where: { domain, bizplace, inventory: originInv, releaseGood: refOrder, type: ORDER_TYPES.RELEASE_OF_GOODS }
+      where: {
+        domain: { id: domain.id },
+        bizplace,
+        inventory: originInv,
+        releaseGood: refOrder,
+        type: ORDER_TYPES.RELEASE_OF_GOODS
+      }
     })
 
     remainQty = orderInv.releaseQty - reducedQty
@@ -275,7 +281,13 @@ export async function temporaryGetRemainInventoryAmount(
   if (refOrder instanceof ReleaseGood) {
     // Find loading order inventory to figure out uomValue
     const orderInv: OrderInventory = await trxMgr.getRepository(OrderInventory).findOne({
-      where: { domain, bizplace, inventory: originInv, releaseGood: refOrder, type: ORDER_TYPES.RELEASE_OF_GOODS }
+      where: {
+        domain: { id: domain.id },
+        bizplace,
+        inventory: originInv,
+        releaseGood: refOrder,
+        type: ORDER_TYPES.RELEASE_OF_GOODS
+      }
     })
 
     remainUomValue = orderInv.releaseUomValue - reducedUomValue
@@ -303,7 +315,12 @@ export async function updateOriginInventories(
 
   for (let inv of repackedFroms) {
     let foundInventory: Inventory = await trxMgr.getRepository(Inventory).findOne({
-      where: { domain, bizplace, palletId: inv.fromPalletId, status: Not(Equal(INVENTORY_STATUS.TERMINATED)) }
+      where: {
+        domain: { id: domain.id },
+        bizplace,
+        palletId: inv.fromPalletId,
+        status: Not(Equal(INVENTORY_STATUS.TERMINATED))
+      }
     })
 
     if (foundInventory) {
@@ -367,7 +384,7 @@ export async function temporaryUpsertInventory(
   packingUnit?: string
 ): Promise<Inventory> {
   const location: Location = await trxMgr.getRepository(Location).findOne({
-    where: { domain, name: locationName },
+    where: { domain: { id: domain.id }, name: locationName },
     relations: ['warehouse']
   })
   if (!location) throw new Error(`Location is not found by (${locationName})`)
@@ -376,7 +393,7 @@ export async function temporaryUpsertInventory(
 
   let inv: Inventory = await trxMgr.getRepository(Inventory).findOne({
     where: {
-      domain,
+      domain: { id: domain.id },
       bizplace,
       palletId,
       batchId: originInv.batchId,
@@ -418,7 +435,7 @@ export async function temporaryUpsertInventory(
 
     // Check whether the pallet is resuable or not
     const pallet: Pallet = await trxMgr.getRepository(Pallet).findOne({
-      where: { domain, name: palletId, inventory: IsNull() }
+      where: { domain: { id: domain.id }, name: palletId, inventory: IsNull() }
     })
     // If it's exists => it's reusable pallet and need to update it's inventory field
     if (pallet) {
@@ -463,7 +480,7 @@ export async function temporaryDeductProductAmount(
 ) {
   if (refOrder instanceof ReleaseGood) {
     const loadingWS: Worksheet = await trxMgr.getRepository(Worksheet).findOne({
-      where: { domain, bizplace, releaseGood: refOrder, type: WORKSHEET_TYPE.LOADING },
+      where: { domain: { id: domain.id }, bizplace, releaseGood: refOrder, type: WORKSHEET_TYPE.LOADING },
       relations: ['worksheetDetails', 'worksheetDetails.targetInventory', 'worksheetDetails.targetInventory.inventory']
     })
 
@@ -577,7 +594,7 @@ export async function assignInventory(
     // Case 1. When the VAS Order comes with Arrival Notice
     inventory = await trxMgr.getRepository(Inventory).findOne({
       where: {
-        domain,
+        domain: { id: domain.id },
         bizplace,
         palletId,
         status: In([INVENTORY_STATUS.UNLOADED, INVENTORY_STATUS.PUTTING_AWAY]),
@@ -597,7 +614,7 @@ export async function assignInventory(
     // In this case, every available inventories are picked by picking worksheet.
     // So target inventories should be found by relation with order inventory which has PICKED status
     let pickedOrdInv: OrderInventory = await trxMgr.getRepository(OrderInventory).find({
-      where: { domain, bizplace, releaseGood: refOrder, status: ORDER_INVENTORY_STATUS.PICKED },
+      where: { domain: { id: domain.id }, bizplace, releaseGood: refOrder, status: ORDER_INVENTORY_STATUS.PICKED },
       relations: ['inventory']
     })
     pickedOrdInv = pickedOrdInv.find((oi: OrderInventory) => oi.inventory.palletId === palletId)
@@ -649,7 +666,8 @@ export async function dismissInventory(
   // If there's no more item assigned with current from pallet id
   if (!palletChanges.find((rf: PalletChangesInterface) => rf.fromPalletId === palletId)) {
     targetVas.inventory = null
-    const worksheet: Worksheet = await trxMgr.getRepository(Worksheet).findOne(wsd.worksheet.id, {
+    const worksheet: Worksheet = await trxMgr.getRepository(Worksheet).findOne({
+      where: { id: wsd.worksheet.id },
       relations: [
         'worksheetDetails',
         'worksheetDetails.targetVas',
@@ -750,7 +768,7 @@ export async function upsertInventory(
   packingUnit?: string
 ): Promise<Inventory> {
   const location: Location = await trxMgr.getRepository(Location).findOne({
-    where: { domain, name: locationName },
+    where: { domain: { id: domain.id }, name: locationName },
     relations: ['warehouse']
   })
   if (!location) throw new Error(`Location is not found by (${locationName})`)
@@ -759,7 +777,7 @@ export async function upsertInventory(
 
   let inv: Inventory = await trxMgr.getRepository(Inventory).findOne({
     where: {
-      domain,
+      domain: { id: domain.id },
       bizplace,
       palletId,
       batchId: originInv.batchId,
@@ -802,7 +820,7 @@ export async function upsertInventory(
 
     // Check whether the pallet is resuable or not
     const pallet: Pallet = await trxMgr.getRepository(Pallet).findOne({
-      where: { domain, name: palletId, inventory: IsNull() }
+      where: { domain: { id: domain.id }, name: palletId, inventory: IsNull() }
     })
     // If it's exists => it's reusable pallet and need to update it's inventory field
     if (pallet) {
@@ -846,7 +864,7 @@ export async function deductProductAmount(
 ) {
   if (refOrder instanceof ReleaseGood) {
     const loadingWS: Worksheet = await trxMgr.getRepository(Worksheet).findOne({
-      where: { domain, bizplace, releaseGood: refOrder, type: WORKSHEET_TYPE.LOADING },
+      where: { domain: { id: domain.id }, bizplace, releaseGood: refOrder, type: WORKSHEET_TYPE.LOADING },
       relations: ['worksheetDetails', 'worksheetDetails.targetInventory', 'worksheetDetails.targetInventory.inventory']
     })
 
@@ -947,7 +965,7 @@ export async function createPutawayWorksheet(
   changedInv: Inventory
 ): Promise<void> {
   const putawayWS: Worksheet = await trxMgr.getRepository(Worksheet).findOne({
-    where: { domain, bizplace, arrivalNotice: refOrder, type: WORKSHEET_TYPE.PUTAWAY },
+    where: { domain: { id: domain.id }, bizplace, arrivalNotice: refOrder, type: WORKSHEET_TYPE.PUTAWAY },
     relations: ['worksheetDetails', 'worksheetDetails.targetInventory', 'worksheetDetails.targetInventory.inventory']
   })
 
@@ -1023,7 +1041,7 @@ export async function createLoadingWorksheet(
   const changedQty: number = changedInv.qty
   const changedUomValue: number = changedInv.uomValue
   const loadingWS: Worksheet = await trxMgr.getRepository(Worksheet).findOne({
-    where: { domain, bizplace, releaseGood: refOrder, type: WORKSHEET_TYPE.LOADING },
+    where: { domain: { id: domain.id }, bizplace, releaseGood: refOrder, type: WORKSHEET_TYPE.LOADING },
     relations: ['worksheetDetails', 'worksheetDetails.targetInventory', 'worksheetDetails.targetInventory.inventory']
   })
 

package/server/graphql/resolvers/worksheet/vas-transactions/relabeling/check-relabelable.ts

@@ -1,9 +1,9 @@
-import { User } from '@things-factory/auth-base'
+import { EntityManager, Equal, Not } from 'typeorm'
+
 import { Bizplace, getMyBizplace } from '@things-factory/biz-base'
 import { Product } from '@things-factory/product-base'
 import { Domain } from '@things-factory/shell'
 import { Inventory, INVENTORY_STATUS } from '@things-factory/warehouse-base'
-import { EntityManager, Equal, Not } from 'typeorm'
 
 export const checkRelabelableResolver = {
   async checkRelabelable(
@@ -16,10 +16,10 @@ export const checkRelabelableResolver = {
     }: { batchId: string; productId: string; packingType: string; unitUomValue: number },
     context: any
   ): Promise<boolean> {
-    const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
+    const { tx, domain, user } = context.state
     const bizplace: Bizplace = await getMyBizplace(user)
     const product: Product = await tx.getRepository(Product).findOne({
-      where: { domain, bizplace, id: productId }
+      where: { domain: { id: domain.id }, bizplace, id: productId }
     })
     if (!product) throw new Error(`Couldn't find product by ID (${productId})`)
 
@@ -80,7 +80,14 @@ export async function checkRelabelable(
   // The condition is same batch id same product same packing type
   // If there's *NO* duplicated inventory the target inventory for this vas can be executed
   const duplicatedInvCnt: number = await tx.getRepository(Inventory).count({
-    where: { domain, bizplace, batchId, product, packingType, status: Not(Equal(INVENTORY_STATUS.TERMINATED)) }
+    where: {
+      domain: { id: domain.id },
+      bizplace,
+      batchId,
+      product,
+      packingType,
+      status: Not(Equal(INVENTORY_STATUS.TERMINATED))
+    }
   })
   if (!duplicatedInvCnt) return true
 

package/server/graphql/resolvers/worksheet/vas-transactions/relabeling/complete-relabeling.ts

@@ -1,10 +1,12 @@
+import { EntityManager } from 'typeorm'
+
 import { User } from '@things-factory/auth-base'
 import { Bizplace } from '@things-factory/biz-base'
 import { Product } from '@things-factory/product-base'
 import { ArrivalNotice, OrderVas, ReleaseGood } from '@things-factory/sales-base'
 import { Domain } from '@things-factory/shell'
 import { Inventory, INVENTORY_TRANSACTION_TYPE } from '@things-factory/warehouse-base'
-import { EntityManager } from 'typeorm'
+
 import {
   createLoadingWorksheet,
   createPutawayWorksheet,
@@ -21,7 +23,8 @@ import {
 } from '../interfaces'
 
 export async function completeRelabeling(trxMgr: EntityManager, orderVas: OrderVas, user: User): Promise<void> {
-  orderVas = await trxMgr.getRepository(OrderVas).findOne(orderVas.id, {
+  orderVas = await trxMgr.getRepository(OrderVas).findOne({
+    where: { id: orderVas.id },
     relations: ['domain', 'bizplace', 'inventory', 'inventory.product', 'arrivalNotice', 'releaseGood', 'vasOrder']
   })
 
@@ -40,7 +43,7 @@ export async function completeRelabeling(trxMgr: EntityManager, orderVas: OrderV
 
   let copiedInv: Inventory = Object.assign({}, originInv)
   if (toBatchId) copiedInv.batchId = toBatchId
-  if (toProduct) copiedInv.product = await trxMgr.getRepository(Product).findOne(toProduct.id)
+  if (toProduct) copiedInv.product = await trxMgr.getRepository(Product).findOneBy({ id: toProduct.id })
 
   copiedInv.refInventory = originInv
 

package/server/graphql/resolvers/worksheet/vas-transactions/relabeling/relabeling.ts

@@ -1,9 +1,9 @@
-import { User } from '@things-factory/auth-base'
+import { Equal, Not } from 'typeorm'
+
 import { Bizplace } from '@things-factory/biz-base'
 import { OrderVas } from '@things-factory/sales-base'
-import { Domain } from '@things-factory/shell'
 import { Inventory, INVENTORY_STATUS } from '@things-factory/warehouse-base'
-import { EntityManager, Equal, Not } from 'typeorm'
+
 import { WorksheetDetail } from '../../../../../entities'
 import { executeVas } from '../../vas/execute-vas'
 import {
@@ -20,7 +20,7 @@ export const relabelingResolver = {
     { worksheetDetailName, fromPalletId, toPalletId, locationName },
     context: any
   ): Promise<void> {
-    const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
+    const { tx, domain, user } = context.state
 
     // Find target worksheet detail & target order vas & bizplace
     const wsd: WorksheetDetail = await getWorksheetDetailByName(tx, domain, worksheetDetailName)
@@ -29,7 +29,12 @@ export const relabelingResolver = {
     // Check whether to pallet id is duplicated or not.
     if (
       await tx.getRepository(Inventory).count({
-        where: { domain, bizplace, palletId: toPalletId, status: Not(Equal(INVENTORY_STATUS.TERMINATED)) }
+        where: {
+          domain: { id: domain.id },
+          bizplace,
+          palletId: toPalletId,
+          status: Not(Equal(INVENTORY_STATUS.TERMINATED))
+        }
       })
     ) {
       throw new Error(`Pallet (${toPalletId}) is already exists`)
@@ -71,7 +76,10 @@ export const relabelingResolver = {
     if (locationName) {
       newPalletChange.locationName = locationName
     } else {
-      originInv = await tx.getRepository(Inventory).findOne(originInv.id, { relations: ['location'] })
+      originInv = await tx.getRepository(Inventory).findOne({
+        where: { id: originInv.id },
+        relations: ['location']
+      })
       newPalletChange.locationName = originInv.location.name
     }
 

package/server/graphql/resolvers/worksheet/vas-transactions/relabeling/undo-relabeling.ts

@@ -1,11 +1,9 @@
-import { User } from '@things-factory/auth-base'
 import { Bizplace } from '@things-factory/biz-base'
 import { OrderVas, VasOrder } from '@things-factory/sales-base'
-import { Domain } from '@things-factory/shell'
-import { EntityManager } from 'typeorm'
-import { WorksheetDetail, } from '../../../../../entities'
-import { getWorksheetDetailByName, updateRelatedOrderVas, dismissInventory } from '../common-utils'
-import { OperationGuideInterface, PalletChangesInterface, RelabelingGuide, RefOrderType } from '../interfaces'
+
+import { WorksheetDetail } from '../../../../../entities'
+import { dismissInventory, getWorksheetDetailByName, updateRelatedOrderVas } from '../common-utils'
+import { OperationGuideInterface, PalletChangesInterface, RefOrderType, RelabelingGuide } from '../interfaces'
 
 export const undoRelabelingResolver = {
   async undoRelabeling(
@@ -14,7 +12,7 @@ export const undoRelabelingResolver = {
     context: any
   ): Promise<void> {
     /** Initialize required variables */
-    const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
+    const { tx, domain, user } = context.state
     const wsd: WorksheetDetail = await getWorksheetDetailByName(tx, domain, worksheetDetailName)
     const { bizplace, targetVas }: { bizplace: Bizplace; targetVas: OrderVas } = wsd
 

package/server/graphql/resolvers/worksheet/vas-transactions/repackaging/complete-repackaging.ts

@@ -19,7 +19,8 @@ import {
 } from '../interfaces'
 
 export async function completeRepackaging(trxMgr: EntityManager, orderVas: OrderVas, user: User): Promise<void> {
-  orderVas = await trxMgr.getRepository(OrderVas).findOne(orderVas.id, {
+  orderVas = await trxMgr.getRepository(OrderVas).findOne({
+    where: { id: orderVas.id },
     relations: [
       'domain',
       'bizplace',
@@ -100,7 +101,7 @@ export async function completeRepackaging(trxMgr: EntityManager, orderVas: Order
   for (const rf of repackedFroms) {
     let foundInventory: Inventory = await trxMgr.getRepository(Inventory).findOne({
       where: {
-        domain,
+        domain: { id: domain.id },
         bizplace,
         palletId: rf.fromPalletId
       }

package/server/graphql/resolvers/worksheet/vas-transactions/repackaging/repackaging.ts

@@ -1,6 +1,5 @@
 import { EntityManager } from 'typeorm'
 
-import { User } from '@things-factory/auth-base'
 import { Bizplace } from '@things-factory/biz-base'
 import { OrderVas } from '@things-factory/sales-base'
 import { Domain } from '@things-factory/shell'
@@ -26,10 +25,14 @@ import {
 } from '../interfaces'
 
 export const repackagingResolver = {
-  async repackaging(_: any, { worksheetDetailName, fromPalletId, toPalletId, locationName, packageQty }, context: any) {
-    const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
+  async repackaging(
+    _: any,
+    { worksheetDetailName, fromPalletId, toPalletId, locationName, packageQty },
+    context: ResolverContext
+  ) {
+    const { tx, domain, user } = context.state
     const location: Location = await tx.getRepository(Location).findOne({
-      where: { domain, name: locationName },
+      where: { domain: { id: domain.id }, name: locationName },
       relations: ['warehouse']
     })
     if (!location) throw new Error(`Couldn't find location by its name (${locationName})`)
@@ -272,7 +275,7 @@ async function getRequiredPackageQty(
   remainder: number
 ): Promise<number> {
   const relatedWSDs: WorksheetDetail[] = await tx.getRepository(WorksheetDetail).find({
-    where: { domain, bizplace, worksheet },
+    where: { domain: { id: domain.id }, bizplace: { id: bizplace.id }, worksheet: { id: worksheet.id } },
     relations: ['targetVas', 'targetVas.vas', 'targetVas.inventory']
   })
 

package/server/graphql/resolvers/worksheet/vas-transactions/repackaging/undo-repackaging.ts

@@ -1,22 +1,12 @@
 import { EntityManager } from 'typeorm'
 
-import { User } from '@things-factory/auth-base'
 import { Bizplace } from '@things-factory/biz-base'
-import {
-  OrderVas,
-  VasOrder
-} from '@things-factory/sales-base'
+import { OrderVas, VasOrder } from '@things-factory/sales-base'
 import { Domain } from '@things-factory/shell'
 import { Inventory } from '@things-factory/warehouse-base'
 
-import {
-  Worksheet,
-  WorksheetDetail
-} from '../../../../../entities'
-import {
-  getWorksheetDetailByName,
-  updateRelatedOrderVas
-} from '../common-utils'
+import { Worksheet, WorksheetDetail } from '../../../../../entities'
+import { getWorksheetDetailByName, updateRelatedOrderVas } from '../common-utils'
 import {
   FeaturedInventoryInterface,
   OperationGuideInterface,
@@ -36,11 +26,11 @@ import {
  */
 
 export const undoRepackagingResolver = {
-  async undoRepackaging(_: any, { worksheetDetailName, fromPalletId, toPalletId }, context: any) {
+  async undoRepackaging(_: any, { worksheetDetailName, fromPalletId, toPalletId }, context: ResolverContext) {
     /**
      * Initialize required variables
      */
-    const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
+    const { tx, domain, user } = context.state
     const wsd: WorksheetDetail = await getWorksheetDetailByName(tx, domain, worksheetDetailName)
     const bizplace: Bizplace = wsd.bizplace
     const targetVas: OrderVas = wsd.targetVas
@@ -146,7 +136,7 @@ async function getRequiredPackageQty(
   stdAmount: number
 ): Promise<number> {
   const relatedWSDs: WorksheetDetail[] = await tx.getRepository(WorksheetDetail).find({
-    where: { domain, bizplace, worksheet },
+    where: { domain: { id: domain.id }, bizplace: { id: bizplace.id }, worksheet: { id: worksheet.id } },
     relations: ['targetVas', 'targetVas.vas', 'targetVas.inventory']
   })
 

package/server/graphql/resolvers/worksheet/vas-transactions/repalletizing/complete-repalletizing.ts

@@ -1,9 +1,11 @@
+import { EntityManager } from 'typeorm'
+
 import { User } from '@things-factory/auth-base'
 import { Bizplace } from '@things-factory/biz-base'
 import { ArrivalNotice, OrderVas, ReleaseGood } from '@things-factory/sales-base'
 import { Domain } from '@things-factory/shell'
 import { Inventory, INVENTORY_TRANSACTION_TYPE } from '@things-factory/warehouse-base'
-import { EntityManager } from 'typeorm'
+
 import {
   createLoadingWorksheet,
   createPutawayWorksheet,
@@ -20,7 +22,8 @@ import {
 } from '../interfaces'
 
 export async function completeRepalletizing(trxMgr: EntityManager, orderVas: OrderVas, user: User): Promise<void> {
-  orderVas = await trxMgr.getRepository(OrderVas).findOne(orderVas.id, {
+  orderVas = await trxMgr.getRepository(OrderVas).findOne({
+    where: { id: orderVas.id },
     relations: ['domain', 'bizplace', 'inventory', 'inventory.product', 'arrivalNotice', 'releaseGood', 'vasOrder']
   })
   const domain: Domain = orderVas.domain

package/server/graphql/resolvers/worksheet/vas-transactions/repalletizing/repalletizing.ts

@@ -1,9 +1,7 @@
-import { User } from '@things-factory/auth-base'
 import { Bizplace } from '@things-factory/biz-base'
 import { OrderVas } from '@things-factory/sales-base'
-import { Domain } from '@things-factory/shell'
 import { Inventory, Location, Pallet, PALLET_TYPES, Warehouse } from '@things-factory/warehouse-base'
-import { EntityManager } from 'typeorm'
+
 import { WorksheetDetail } from '../../../../../entities'
 import { checkPalletDuplication, checkPalletIdenticallity } from '../../../../../utils'
 import { executeVas } from '../../vas/execute-vas'
@@ -23,10 +21,14 @@ import {
 } from '../interfaces'
 
 export const repalletizingResolver = {
-  async repalletizing(_: any, { worksheetDetailName, fromPalletId, toPalletId, locationName }, context: any) {
-    const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
+  async repalletizing(
+    _: any,
+    { worksheetDetailName, fromPalletId, toPalletId, locationName },
+    context: ResolverContext
+  ) {
+    const { tx, domain, user } = context.state
     const location: Location = await tx.getRepository(Location).findOne({
-      where: { domain, name: locationName },
+      where: { domain: { id: domain.id }, name: locationName },
       relations: ['warehouse']
     })
     if (!location) throw new Error(`Couldn't find location by its name (${locationName})`)
@@ -72,8 +74,8 @@ export const repalletizingResolver = {
     if (palletType === PALLET_TYPES.REUSABLE_PALLET) {
       // Check whether the pallet is available
       const pallet: Pallet = await tx.getRepository(Pallet).findOne({
-        where: { domain, name: toPalletId },
-        relatoins: ['inventory']
+        where: { domain: { id: domain.id }, name: toPalletId },
+        relations: ['inventory']
       })
       if (!pallet) throw new Error(`Couldn't find reusable pallet by its ID (${toPalletId})`)
       if (pallet.inventory) throw new Error(`The pallet (${toPalletId}) is located already.`)

package/server/graphql/resolvers/worksheet/vas-transactions/repalletizing/undo-repalletizing.ts

@@ -1,8 +1,6 @@
-import { User } from '@things-factory/auth-base'
 import { Bizplace } from '@things-factory/biz-base'
 import { OrderVas, VasOrder } from '@things-factory/sales-base'
-import { Domain } from '@things-factory/shell'
-import { EntityManager } from 'typeorm'
+
 import { WorksheetDetail } from '../../../../../entities'
 import { dismissInventory, getWorksheetDetailByName, updateRelatedOrderVas } from '../common-utils'
 import {
@@ -14,11 +12,11 @@ import {
 } from '../interfaces'
 
 export const undoRepalletizingResolver = {
-  async undoRepalletizing(_: any, { worksheetDetailName, fromPalletId, toPalletId }, context: any) {
+  async undoRepalletizing(_: any, { worksheetDetailName, fromPalletId, toPalletId }, context: ResolverContext) {
     /**
      * Initialize required variables
      */
-    const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
+    const { tx, domain, user } = context.state
     const wsd: WorksheetDetail = await getWorksheetDetailByName(tx, domain, worksheetDetailName)
     const bizplace: Bizplace = wsd.bizplace
     const targetVas: OrderVas = wsd.targetVas

package/server/graphql/resolvers/worksheet/vas-transactions/unpacking/complete-unpacking.ts

@@ -1,15 +1,15 @@
+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 { EntityManager } from 'typeorm'
 import { OrderVas } from '@things-factory/sales-base'
-import { Worksheet } from '../../../../../entities'
-import { activateUnloading } from '../../../worksheet/unloading/activate-unloading'
+import { Domain } from '@things-factory/shell'
+
 import { RefOrderType } from '../interfaces'
-import { WORKSHEET_TYPE } from '../../../../../constants'
 
 export async function completeUnpacking(trxMgr: EntityManager, orderVas: OrderVas, user: User): Promise<void> {
-  orderVas = await trxMgr.getRepository(OrderVas).findOne(orderVas.id, {
+  orderVas = await trxMgr.getRepository(OrderVas).findOne({
+    where: { id: orderVas.id },
     relations: ['domain', 'bizplace', 'inventory', 'inventory.product', 'arrivalNotice', 'releaseGood', 'vasOrder']
   })