@things-factory/warehouse-base 4.3.135 → 4.3.138

package/server/service/inventory-product/inventory-product.ts

@@ -11,7 +11,7 @@ import {
 } from 'typeorm'
 
 import { User } from '@things-factory/auth-base'
-import { Product } from '@things-factory/product-base'
+import { Product, ProductDetail } from '@things-factory/product-base'
 import { Domain } from '@things-factory/shell'
 
 @Entity()
@@ -60,6 +60,10 @@ export class InventoryProduct {
   @RelationId((inventoryProduct: InventoryProduct) => inventoryProduct.product)
   productId?: string
 
+  @ManyToOne(type => ProductDetail, { nullable: true })
+  @Field({ nullable: true })
+  productDetail: ProductDetail
+
   @CreateDateColumn()
   @Field({ nullable: true })
   createdAt?: Date

package/server/service/location/location-mutation.ts

@@ -77,10 +77,12 @@ export class LocationMutation {
   @Mutation(returns => Boolean)
   async deleteAllLocations(@Arg('warehouseId') warehouseId: string, @Ctx() context: any) {
     const { tx }: { tx: EntityManager } = context.state
+    let warehouse = await tx.getRepository(Warehouse).findOne(warehouseId)
 
     await tx.getRepository(Location).delete({
-      warehouse: await tx.getRepository(Warehouse).findOne(warehouseId)
+      warehouse
     })
+    return true
   }
 }
 

package/server/service/pallet/pallet-mutation.ts

@@ -1,5 +1,5 @@
 import { Arg, Ctx, Directive, Mutation, Resolver } from 'type-graphql'
-import { EntityManager, In } from 'typeorm'
+import { EntityManager, In, getRepository } from 'typeorm'
 
 import { User } from '@things-factory/auth-base'
 import { Bizplace } from '@things-factory/biz-base'
@@ -8,6 +8,7 @@ import { Domain } from '@things-factory/shell'
 import { PalletHistory } from '../pallet-history/pallet-history'
 import { Pallet } from './pallet'
 import { NewPallet, PalletPatch } from './pallet-types'
+import i18next from 'i18next'
 
 @Resolver(Pallet)
 export class PalletMutation {
@@ -25,12 +26,8 @@ export class PalletMutation {
   }
 
   @Directive('@transaction')
-  @Mutation(returns => Pallet)
-  async updatePallet(
-    @Arg('name') name: string,
-    @Arg('patch') patch: PalletPatch,
-    @Ctx() context: any
-  ): Promise<Pallet> {
+  @Mutation(returns => Boolean)
+  async updatePallet(@Arg('name') name: string, @Arg('patch') patch: PalletPatch, @Ctx() context: any) {
     const { domain, user, tx }: { domain: Domain; user: User; tx: EntityManager } = context.state
 
     const repository = tx.getRepository(Pallet)
@@ -46,80 +43,66 @@ export class PalletMutation {
   }
 
   @Directive('@transaction')
-  @Mutation(returns => [Pallet])
-  async updateMultiplePallet(
-    @Arg('patches', type => [PalletPatch]) patches: PalletPatch[],
-    @Ctx() context: any
-  ): Promise<Pallet[]> {
+  @Mutation(returns => Boolean)
+  async updateMultiplePallet(@Arg('patches', type => [PalletPatch]) patches: PalletPatch[], @Ctx() context: any) {
     const { domain, user, tx }: { domain: Domain; user: User; tx: EntityManager } = context.state
 
-    let results = []
-    const _createRecords = patches.filter((patch: any) => patch.cuFlag.toUpperCase() === '+')
-    const _updateRecords = patches.filter((patch: any) => patch.cuFlag.toUpperCase() === 'M')
-
-    if (_createRecords.length > 0) {
-      for (let i = 0; i < _createRecords.length; i++) {
-        const newRecord = _createRecords[i]
+    for (let patch of patches) {
+      let foundPallet: Pallet
 
-        if (newRecord.owner && newRecord.owner.id) {
-          newRecord.owner = await tx.getRepository(Bizplace).findOne(newRecord.owner.id)
-        }
+      if (patch.name) {
+        foundPallet = await getRepository(Pallet).findOne({
+          where: {
+            domain,
+            name: patch.name
+          },
+          relations: ['owner', 'holder']
+        })
+      } else if (patch.id) {
+        foundPallet = await getRepository(Pallet).findOne({
+          where: {
+            domain,
+            id: patch.id
+          },
+          relations: ['owner', 'holder']
+        })
+      }
 
-        if (newRecord.holder && newRecord.holder.id) {
-          newRecord.holder = await tx.getRepository(Bizplace).findOne(newRecord.holder.id)
-        }
+      if (!foundPallet) {
+        delete patch?.id
 
-        const result: Pallet = await tx.getRepository(Pallet).save({
-          domain: domain,
-          creator: user,
-          updater: user,
-          ...newRecord
-        })
+        let newPallet = await tx.getRepository(Pallet).save({ ...patch, domain, creator: user, updater: user })
 
         await tx.getRepository(PalletHistory).save({
-          ...newRecord,
-          pallet: result,
+          ...patch,
+          pallet: newPallet,
           domain: domain,
           creator: user,
           updater: user,
           transactionType: 'NEW'
         })
-
-        results.push({ ...result, cuFlag: '+' })
-      }
-    }
-
-    if (_updateRecords.length > 0) {
-      for (let i = 0; i < _updateRecords.length; i++) {
-        const newRecord = _updateRecords[i]
-        const pallet = await tx.getRepository(Pallet).findOne({
-          where: { id: newRecord.id },
-          relations: ['owner', 'holder']
-        })
-        const seq = pallet.seq + 1
-
-        if (newRecord.owner && newRecord.owner.id) {
-          newRecord.owner = await tx.getRepository(Bizplace).findOne(newRecord.owner.id)
-        }
-
-        if (newRecord.holder && newRecord.holder.id) {
-          newRecord.holder = await tx.getRepository(Bizplace).findOne(newRecord.holder.id)
+      } else {
+        if (patch.cuFlag === '+') {
+          throw new Error(i18next.t('error.pallet (x) already exists', { x: patch.name }))
         }
-
-        const result = await tx.getRepository(Pallet).save({
-          ...pallet,
-          ...newRecord,
-          seq,
-          updater: user,
-          refOrderNo: null
-        })
+        delete patch.cuFlag
+
+        let updatedPallet: any = await tx.getRepository(Pallet).update(
+          { id: foundPallet.id },
+          {
+            ...patch,
+            updater: user,
+            seq: foundPallet.seq++,
+            refOrderNo: null
+          }
+        )
 
         let newHistory = {
-          ...pallet,
-          ...newRecord,
-          pallet: result,
-          seq,
-          domain: domain,
+          ...foundPallet,
+          ...patch,
+          pallet: updatedPallet,
+          seq: updatedPallet.seq,
+          domain,
           creator: user,
           updater: user,
           transactionType: 'UPDATE'
@@ -130,12 +113,10 @@ export class PalletMutation {
         await tx.getRepository(PalletHistory).save({
           ...newHistory
         })
-
-        results.push({ ...result, cuFlag: 'M' })
       }
     }
 
-    return results
+    return true
   }
 
   @Directive('@transaction')

package/server/service/tote/tote-mutation.ts

@@ -97,7 +97,7 @@ export class ToteMutation {
 
         let foundTote = await tx
           .getRepository(Tote)
-          .findOne({ where: { domain, name: newRecord.name, bizplace: newRecord.bizplace } })
+          .findOne({ where: { domain, name: tote.name, bizplace: newRecord.bizplace } })
 
         if (foundTote) {
           throw new Error('Duplicated tote found')

package/server/service/tote/tote-query.ts

@@ -1,5 +1,5 @@
-import { Arg, Ctx, FieldResolver, Query, Resolver, Root } from 'type-graphql'
-import { getRepository, IsNull } from 'typeorm'
+import { Arg, Ctx, FieldResolver, Query, Resolver, Root, Directive } from 'type-graphql'
+import { getRepository, IsNull, EntityManager } from 'typeorm'
 
 import { User } from '@things-factory/auth-base'
 import { Bizplace } from '@things-factory/biz-base'
@@ -10,6 +10,7 @@ import { ToteList } from './tote-types'
 
 @Resolver(Tote)
 export class ToteQuery {
+  @Directive('@transaction')
   @Query(returns => ToteList)
   async totes(
     @Ctx() context: any,
@@ -17,14 +18,14 @@ export class ToteQuery {
     @Arg('pagination', type => Pagination, { nullable: true }) pagination?: Pagination,
     @Arg('sortings', type => [Sorting], { nullable: true }) sortings?: Sorting[]
   ): Promise<ToteList> {
-    const { domain }: { domain: Domain } = context.state
+    const { domain, tx }: { domain: Domain; tx: EntityManager } = context.state
 
     const nameFilter: any = filters.find((filter: any) => filter.name === 'name')
     const bizplaceFilter: any = filters.find((filter: any) => filter.name === 'bizplace')
     const statusFilter: any = filters.find((filter: any) => filter.name === 'status')
     const deletedFilter: any = filters.find((filter: any) => filter.name === 'deleted' && filter.value == true)
 
-    const queryBuilder = getRepository(Tote).createQueryBuilder()
+    const queryBuilder = tx.getRepository(Tote).createQueryBuilder()
     buildQuery(queryBuilder, { filters, pagination, sortings }, context)
 
     queryBuilder
@@ -32,7 +33,7 @@ export class ToteQuery {
       .leftJoinAndSelect('Tote.bizplace', 'Bizplace')
       .leftJoinAndSelect('Tote.creator', 'Creator')
       .leftJoinAndSelect('Tote.updater', 'Updater')
-      .where('Domain.id = :domainId', { domainId: domain.id })
+      .andWhere('Domain.id = :domainId', { domainId: domain.id })
 
     if (nameFilter) {
       queryBuilder.andWhere('Tote.name ilike :name', { name: nameFilter.value })

package/server/service/warehouse/warehouse-mutation.ts

@@ -7,6 +7,8 @@ import { Domain } from '@things-factory/shell'
 import { Warehouse } from './warehouse'
 import { NewWarehouse, WarehousePatch } from './warehouse-types'
 
+import i18next from 'i18next'
+
 @Resolver(Warehouse)
 export class WarehouseMutation {
   @Directive('@privilege(category: "warehouse", privilege: "mutation")')
@@ -29,32 +31,47 @@ export class WarehouseMutation {
 
   @Directive('@privilege(category: "warehouse", privilege: "mutation")')
   @Directive('@transaction')
-  @Mutation(returns => [Warehouse])
+  @Mutation(returns => Boolean)
   async updateMultipleWarehouse(
     @Arg('patches', type => [WarehousePatch]) patches: WarehousePatch[],
     @Ctx() context: any
-  ): Promise<Warehouse[]> {
-    let results = []
-    const _createRecords = patches.filter((patch: any) => patch.cuFlag === '+')
-    const _updateRecords = patches.filter((patch: any) => patch.cuFlag.toUpperCase() === 'M')
-
-    if (_createRecords.length > 0) {
-      for (let i = 0; i < _createRecords.length; i++) {
-        const patch = _createRecords[i]
-        const result = await createWarehouse(patch as NewWarehouse, context)
-        results.push({ ...result, cuFlag: '+' })
+  ) {
+    const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
+
+    for (let patch of patches) {
+      let foundWarehouse: Warehouse
+
+      if (patch?.name) {
+        foundWarehouse = await tx.getRepository(Warehouse).findOne({
+          domain,
+          name: patch.name
+        })
+      } else if (patch?.id) {
+        foundWarehouse = await tx.getRepository(Warehouse).findOne({
+          domain,
+          id: patch.id
+        })
       }
-    }
 
-    if (_updateRecords.length > 0) {
-      for (let i = 0; i < _updateRecords.length; i++) {
-        const patch: WarehousePatch = _updateRecords[i]
-        const result = await updateWarehouse(patch.id, patch, context)
-        results.push({ ...result, cuFlag: 'M' })
+      if (!foundWarehouse) {
+        delete patch?.id
+        await tx.getRepository(Warehouse).save({ ...patch, domain, creator: user, updater: user })
+      } else {
+        if (patch.cuFlag === '+') {
+          throw new Error(i18next.t('error.warehouse (x) already exists', { x: patch.name }))
+        }
+        delete patch.cuFlag
+        await tx.getRepository(Warehouse).update(
+          { id: foundWarehouse.id },
+          {
+            ...patch,
+            updater: user
+          }
+        )
       }
     }
 
-    return results
+    return true
   }
 
   @Directive('@privilege(category: "warehouse", privilege: "mutation")')

package/server/utils/inventory-util.ts

@@ -131,7 +131,7 @@ export async function generateInventoryHistory(
 
   inventory = await invRepo.findOne({
     where: { id: inventory.id },
-    relations: ['domain', 'bizplace', 'product', 'warehouse', 'location']
+    relations: ['domain', 'bizplace', 'product', 'warehouse', 'location', 'productDetail']
   })
 
   const domain: Domain = inventory.domain
@@ -147,68 +147,133 @@ export async function generateInventoryHistory(
     }
   })
 
-  let seq: number = 0
-  let openingQty: number = 0
-  let openingUomValue: number = 0
-
-  if (lastInvHistory) {
-    openingQty = lastInvHistory.openingQty + lastInvHistory.qty
-    openingUomValue = lastInvHistory.openingUomValue + lastInvHistory.uomValue
-    seq = lastInvHistory.seq + 1
-  }
-
-  let remainQty = (openingQty || 0) + (qty || 0)
-
-  let inventoryHistory: any = new InventoryHistory()
-
-  inventoryHistory = {
-    ...inventory,
-    name: InventoryNoGenerator.inventoryHistoryName(),
-    inventory,
-    seq: seq,
-    status: remainQty == 0 ? INVENTORY_STATUS.TERMINATED : inventory.status,
-    transactionType,
+  let lastSeq: number
+  let res: any
+  let inventoryHistoryFields: any = {
     refOrderId: refOrder?.id || null,
     orderNo: refOrder?.name || null,
     orderRefNo: refOrder?.refNo || null,
-    qty,
-    openingQty,
-    uomValue,
-    openingUomValue: openingUomValue,
+    uom: inventory?.uom,
+
     creator: user,
-    updater: user
+    updater: user,
+    domain: inventory?.domain,
+    bizplace: inventory?.bizplace,
+    reusablePallet: inventory?.reusablePallet,
+    inventory: inventory,
+    product: inventory?.product,
+    productDetail: inventory?.productDetail,
+    warehouse: inventory?.warehouse,
+    location: inventory?.location,
+
+    palletId: inventory?.palletId,
+    batchId: inventory?.batchId,
+    zone: inventory?.zone,
+    packingType: inventory?.packingType,
+    description: inventory?.description,
+    expirationDate: inventory?.expirationDate,
+    unitCost: inventory?.unitCost,
+    batchIdRef: inventory?.batchIdRef,
+    cartonId: inventory?.cartonId,
+    manufactureYear: inventory?.manufactureYear,
+    packingSize: inventory?.packingSize,
+    manufactureDate: inventory?.manufactureDate,
+    status: inventory.status
   }
 
-  delete inventoryHistory.updatedAt
-  delete inventoryHistory.createdAt
-  delete inventoryHistory.id
-
-  let newInventoryHistory = await invHistoryRepo.save(inventoryHistory)
-
-  if (remainQty == 0) {
-    seq = seq + 1
-    let terminatedHistory = {
-      ...newInventoryHistory,
-      name: InventoryNoGenerator.inventoryHistoryName(),
-      seq: seq,
-      status: INVENTORY_STATUS.TERMINATED,
-      transactionType: INVENTORY_TRANSACTION_TYPE.TERMINATED,
-      uom: inventory.uom,
-      qty: 0,
-      openingQty: 0,
-      uomValue: 0,
-      openingUomValue: 0
+  if (!lastInvHistory) {
+    res = await invHistoryRepo
+      .createQueryBuilder()
+      .insert()
+      .into(InventoryHistory)
+      .values([
+        {
+          ...inventoryHistoryFields,
+          name: InventoryNoGenerator.inventoryHistoryName(),
+          status: inventory.status,
+          transactionType,
+          qty,
+          openingQty: 0,
+          uomValue,
+          openingUomValue: 0,
+          seq: 0
+        }
+      ])
+      .returning('*')
+      .execute()
+  } else {
+    if (transactionType == 'PICKING' || transactionType == 'UNLOADING') {
+      const findSameOrderHistory: InventoryHistory[] = await invHistoryRepo.find({
+        domain: inventory.domain,
+        palletId: inventory.palletId,
+        refOrderId: refOrder.id
+      })
+
+      if (findSameOrderHistory.length > 0) {
+        let prevTotalQty = 0
+        let prevTotalUomValue = 0
+        for (let oh of findSameOrderHistory) {
+          prevTotalQty += oh.qty
+          prevTotalUomValue += oh.uomValue
+        }
+        qty -= prevTotalQty
+        uomValue -= prevTotalUomValue
+      }
     }
 
-    delete terminatedHistory.id
+    res = await invHistoryRepo
+      .createQueryBuilder()
+      .insert()
+      .into(InventoryHistory)
+      .values([
+        {
+          ...inventoryHistoryFields,
+          name: InventoryNoGenerator.inventoryHistoryName(),
+          transactionType,
+          qty,
+          openingQty: () =>
+            `(select opening_qty from inventory_histories where pallet_id = '${inventory.palletId}' and domain_id = '${domain.id}' order by seq desc limit 1) + (select qty from inventory_histories where pallet_id = '${inventory.palletId}' and domain_id = '${domain.id}' order by seq desc limit 1)`,
+          uomValue,
+          openingUomValue: () =>
+            `(select opening_uom_value from inventory_histories where pallet_id = '${inventory.palletId}' and domain_id = '${domain.id}' order by seq desc limit 1) + ${uomValue}`,
+          seq: () =>
+            `(select seq from inventory_histories where pallet_id = '${inventory.palletId}' and domain_id = '${domain.id}' order by seq desc limit 1) + 1`
+        }
+      ])
+      .returning('*')
+      .execute()
+  }
 
-    newInventoryHistory = await invHistoryRepo.save(terminatedHistory)
+  let newInventoryHistory: InventoryHistory = res.generatedMaps[0]
+  lastSeq = newInventoryHistory.seq
+
+  if (newInventoryHistory.openingQty + qty == 0 && transactionType != 'UNDO_UNLOADING') {
+    let terminatedRes = await invHistoryRepo
+      .createQueryBuilder()
+      .insert()
+      .into(InventoryHistory)
+      .values([
+        {
+          ...inventoryHistoryFields,
+          name: InventoryNoGenerator.inventoryHistoryName(),
+          status: INVENTORY_STATUS.TERMINATED,
+          transactionType: INVENTORY_TRANSACTION_TYPE.TERMINATED,
+          qty: 0,
+          openingQty: 0,
+          uomValue: 0,
+          openingUomValue: 0,
+          seq: () =>
+            `(select seq from inventory_histories where inventory_id = '${inventory.id}' order by seq desc limit 1) + 1`
+        }
+      ])
+      .returning('seq')
+      .execute()
+
+    lastSeq = terminatedRes.generatedMaps[0].seq
     inventory.status = INVENTORY_STATUS.TERMINATED
   }
 
-  if (inventory.lastSeq !== seq) {
-    await invRepo.update(inventory.id, { lastSeq: newInventoryHistory.seq, updater: user })
-  }
+  await invRepo.update(inventory.id, { lastSeq, updater: user })
 
   await switchLocationStatus(domain, location, user, trxMgr)
   return newInventoryHistory

package/translations/en.json

@@ -1,4 +1,7 @@
 {
+  "error.no_location_found": "no location found",
+  "error.pallet (x) already exists": "Pallet ({x}) already exists",
+  "error.warehouse (x) already exists": "Warehouse ({x}) already exists",
   "field.location": "location",
   "field.product_batch": "product batch",
   "field.lot": "lot",
@@ -16,6 +19,5 @@
   "field.qty": "qty",
   "field.state": "state",
   "field.date": "date",
-  "field.type": "type",
-  "error.no_location_found": "no location found"
+  "field.type": "type"
 }

package/translations/ko.json

@@ -1,4 +1,7 @@
 {
+  "error.no_location_found": "발견된 로케이션이 없습니다",
+  "error.pallet (x) already exists": "[ko] Pallet ({x}) already exists",
+  "error.warehouse (x) already exists": "[ko] Warehouse ({x}) already exists",
   "field.location": "로케이션",
   "field.product_batch": "제품 배치",
   "field.lot": "롯트",
@@ -16,6 +19,5 @@
   "field.qty": "수량",
   "field.state": "국가",
   "field.date": "날짜",
-  "field.type": "유형",
-  "error.no_location_found": "발견된 로케이션이 없습니다"
+  "field.type": "유형"
 }

package/translations/ms.json

@@ -1,4 +1,7 @@
 {
+  "error.no_location_found": "[ms]no location found",
+  "error.pallet (x) already exists": "[ms] Pallet ({x}) already exists",
+  "error.warehouse (x) already exists": "[ko] Warehouse ({x}) already exists",
   "field.location": "lokasi",
   "field.product_batch": "kumpulan produk",
   "field.lot": "lot",
@@ -16,6 +19,5 @@
   "field.qty": "kuantiti",
   "field.state": "keadaan",
   "field.date": "tarikh",
-  "field.type": "jenis",
-  "error.no_location_found": "[ms]no location found"
+  "field.type": "jenis"
 }

package/translations/zh.json

@@ -1,21 +1,23 @@
 {
-  "field.location": "位置",
-  "field.product_batch": "产品批次",
-  "field.lot": "地块",
-  "field.warehouse": "仓库",
-  "field.zone": "区",
-  "field.section": "段",
-  "field.unit": "单元",
-  "field.shelf": "架子",
+  "error.no_location_found": "[zh]no location found",
+  "error.pallet (x) already exists": "[zh] Pallet ({x}) already exists",
+  "error.warehouse (x) already exists": "[ko] Warehouse ({x}) already exists",
   "field.bizplace": "分部",
-  "field.start_qty": "开始数量",
+  "field.date": "日期",
+  "field.end_qty": "最终数量",
   "field.in_qty": "进口数量",
+  "field.location": "位置",
+  "field.lot": "地块",
   "field.out_qty": "出口数量",
-  "field.end_qty": "最终数量",
+  "field.product_batch": "产品批次",
   "field.product": "产品",
   "field.qty": "数量",
+  "field.section": "段",
+  "field.shelf": "架子",
+  "field.start_qty": "开始数量",
   "field.state": "状态",
-  "field.date": "日期",
   "field.type": "类型",
-  "error.no_location_found": "[zh]no location found"
+  "field.unit": "单元",
+  "field.warehouse": "仓库",
+  "field.zone": "区"
 }