@things-factory/operato-wms 4.3.752 → 4.3.755

package/server/graphql/resolvers/outbound/sort-item.ts

@@ -1,12 +1,67 @@
-import { EntityManager } from 'typeorm'
-import { Brackets } from 'typeorm'
+import { EntityManager, Brackets, IsNull, In, Not } from 'typeorm'
 
 import { User } from '@things-factory/auth-base'
 import { Domain } from '@things-factory/shell'
-import { ORDER_INVENTORY_STATUS, OrderInventory } from '@things-factory/sales-base'
+import {
+  ORDER_INVENTORY_STATUS,
+  OrderInventory,
+  OrderNoGenerator,
+  OrderTote,
+  OrderToteItem,
+  ReleaseGood
+} from '@things-factory/sales-base'
+import { Tote, TOTE_STATUS } from '@things-factory/warehouse-base'
+
+/**
+ * Calculates the available quantity that can still be sorted for an order inventory
+ */
+function getAvailableQty(oi: OrderInventory): number {
+  const available = Math.min(oi.releaseQty, oi.pickedQty) - oi.sortedQty
+  return available > 0 ? available : 0
+}
+
+/**
+ * Creates or updates an order tote item with the given quantity
+ */
+async function upsertOrderToteItem(
+  tx: EntityManager,
+  domain: Domain,
+  user: User,
+  orderTote: OrderTote,
+  orderInventory: OrderInventory,
+  qtyToAdd: number
+): Promise<void> {
+  const orderToteItemRepo = tx.getRepository(OrderToteItem)
+  const existingItem = (await orderToteItemRepo.findOne({
+    where: {
+      domain,
+      orderTote,
+      orderInventory,
+      orderProduct: orderInventory.orderProduct
+    }
+  })) as OrderToteItem | null
+
+  if (!existingItem) {
+    await orderToteItemRepo.save({
+      domain,
+      name: OrderNoGenerator.orderToteItem(),
+      orderTote,
+      orderInventory,
+      orderProduct: orderInventory.orderProduct,
+      qty: qtyToAdd,
+      updater: user
+    })
+  } else {
+    await orderToteItemRepo.update(existingItem.id, {
+      qty: Number(existingItem.qty ?? 0) + qtyToAdd,
+      updater: user,
+      updatedAt: new Date()
+    } as any)
+  }
+}
 
 export const sortItem = {
-  async sortItem(_: any, { releaseGoodNo, productBarcode, qty, worksheetDetails }, context: any) {
+  async sortItem(_: any, { releaseGoodNo, productBarcode, qty, worksheetDetails, toteNo }, context: any) {
     const { domain, user, tx }: { domain: Domain; user: User; tx: EntityManager } = context.state
 
     // Single query to get order inventories based on either releaseGood name or binLocation
@@ -15,21 +70,22 @@ export const sortItem = {
       .createQueryBuilder('orderInventory')
       .innerJoinAndSelect('orderInventory.productDetail', 'productDetail')
       .innerJoinAndSelect('productDetail.productBarcodes', 'productBarcode')
+      .leftJoinAndSelect('orderInventory.orderProduct', 'orderProduct')
       .leftJoinAndSelect('orderInventory.releaseGood', 'releaseGood')
+      .leftJoinAndSelect('releaseGood.bizplace', 'bizplace')
       .leftJoinAndSelect('orderInventory.binLocation', 'binLocation')
       .where('orderInventory.domain_id = :domainId', { domainId: domain.id })
       .andWhere('orderInventory.status IN (:...statuses)', {
-        statuses: [
-          ORDER_INVENTORY_STATUS.SORTING,
-          ORDER_INVENTORY_STATUS.LOADING
-        ]
+        statuses: [ORDER_INVENTORY_STATUS.SORTING, ORDER_INVENTORY_STATUS.LOADING]
       })
       .andWhere('productBarcode.gtin = :gtin', { gtin: productBarcode })
-      .andWhere(new Brackets(qb => {
-        qb
-          .where('orderInventory.sortedQty < orderInventory.pickedQty')
-          .andWhere('orderInventory.sortedQty < orderInventory.releaseQty')
-      }))
+      .andWhere(
+        new Brackets(qb => {
+          qb.where('orderInventory.sortedQty < orderInventory.pickedQty').andWhere(
+            'orderInventory.sortedQty < orderInventory.releaseQty'
+          )
+        })
+      )
       .andWhere(
         new Brackets(qb => {
           qb.where('releaseGood.name = :releaseGoodNo', { releaseGoodNo }).orWhere(
@@ -42,11 +98,55 @@ export const sortItem = {
 
     if (!orderInventories.length) throw new Error('No matching product barcode found')
 
-    // Calculate total available quantity (minimum of releaseQty and pickedQty for each order inventory)
-    const totalAvailableQty = orderInventories.reduce((sum, oi) => {
-      const availableQty = Math.min(oi.releaseQty, oi.pickedQty) - oi.sortedQty
-      return sum + (availableQty > 0 ? availableQty : 0)
-    }, 0)
+    let resolvedReleaseGood: ReleaseGood | null = null
+    let resolvedOrderTote: OrderTote | null = null
+
+    if (toteNo) {
+      // Ensure we can identify a single release order when scanning by BIN
+      const uniqueReleaseGoodIds = [...new Set(orderInventories.map(oi => oi.releaseGoodId).filter(Boolean))]
+      if (uniqueReleaseGoodIds.length > 1) {
+        throw new Error('Multiple release orders detected. Please select a release order before tote scanning.')
+      }
+
+      resolvedReleaseGood = await tx.getRepository(ReleaseGood).findOne({
+        where: { domain, id: uniqueReleaseGoodIds[0] },
+        relations: ['bizplace']
+      })
+
+      if (!resolvedReleaseGood) {
+        throw new Error('Release good not found for tote scanning')
+      }
+
+      resolvedOrderTote = await tx.getRepository(OrderTote).findOne({
+        where: { domain, name: toteNo, releaseGood: resolvedReleaseGood }
+      })
+
+      if (!resolvedOrderTote) {
+        // Query for valid totes (NOT dispatched or damaged)
+        const foundTote: Tote = await tx.getRepository(Tote).findOne({
+          where: {
+            bizplace: resolvedReleaseGood.bizplace,
+            name: toteNo,
+            deletedAt: IsNull(),
+            status: Not(In([TOTE_STATUS.DISPATCHED, TOTE_STATUS.DAMAGED]))
+          }
+        })
+
+        resolvedOrderTote = await tx.getRepository(OrderTote).save({
+          name: toteNo,
+          domain,
+          releaseGood: resolvedReleaseGood,
+          tote: foundTote ?? null,
+          creator: user,
+          updater: user
+        })
+      } else if (resolvedOrderTote.closedDate) {
+        throw new Error('Tote has been sealed, please try another tote!')
+      }
+    }
+
+    // Calculate total available quantity using helper function
+    const totalAvailableQty = orderInventories.reduce((sum, oi) => sum + getAvailableQty(oi), 0)
 
     if (qty > totalAvailableQty) {
       throw new Error(`Sort qty (${qty}) exceeds total available quantity (${totalAvailableQty})`)
@@ -57,20 +157,24 @@ export const sortItem = {
     for (const orderInventory of orderInventories) {
       if (remainingQty <= 0) break
 
-      const availableQty = Math.min(orderInventory.releaseQty, orderInventory.pickedQty) - orderInventory.sortedQty
+      const availableQty = getAvailableQty(orderInventory)
       if (availableQty <= 0) continue
 
       const qtyToAdd = Math.min(remainingQty, availableQty)
-      const newSortQty = orderInventory.sortedQty + qtyToAdd
 
       // Update the order inventory
       await tx.getRepository(OrderInventory).update(orderInventory.id, {
-        sortedQty: newSortQty,
+        sortedQty: orderInventory.sortedQty + qtyToAdd,
         status: ORDER_INVENTORY_STATUS.LOADING,
         updatedAt: new Date(),
         updater: user
       })
 
+      // Create / update order tote items to reflect tote allocation during QC
+      if (resolvedOrderTote) {
+        await upsertOrderToteItem(tx, domain, user, resolvedOrderTote, orderInventory, qtyToAdd)
+      }
+
       remainingQty -= qtyToAdd
     }
 

package/server/graphql/resolvers/route-label/index.ts

@@ -0,0 +1,16 @@
+import {
+  reserveRouteLabelSequence,
+  routeLabelReleaseGoodsInExecutingWorksheet,
+  routeLabelSequenceLogs,
+  routeLabelSequenceStatuses
+} from './route-label'
+
+export const Query = {
+  ...routeLabelReleaseGoodsInExecutingWorksheet,
+  ...routeLabelSequenceStatuses,
+  ...routeLabelSequenceLogs
+}
+
+export const Mutation = {
+  ...reserveRouteLabelSequence
+}

package/server/graphql/resolvers/route-label/route-label.ts

@@ -0,0 +1,264 @@
+import { EntityManager, In } from 'typeorm'
+import { Domain } from '@things-factory/biz-base'
+import { WORKSHEET_STATUS } from '@things-factory/worksheet-base'
+import { User } from '@things-factory/auth-base'
+
+import { RouteLabelSequenceCounter } from '../../../entities/route-label-sequence-counter'
+import { RouteLabelSequenceLog } from '../../../entities/route-label-sequence-log'
+
+function ensureSeqField(field: string) {
+  if (!['refNo', 'refNo2', 'refNo3'].includes(field)) {
+    throw new Error('Invalid sequence field. Allowed: refNo, refNo2, refNo3')
+  }
+}
+
+function parseNonNegativeInt(value: any): number {
+  const n = parseInt(value ?? '0', 10)
+  return Number.isFinite(n) ? Math.max(0, n) : 0
+}
+
+export const routeLabelReleaseGoodsInExecutingWorksheet = {
+  async routeLabelReleaseGoodsInExecutingWorksheet(_: any, { partnerId, refNo, worksheetType, seqField }, context: any) {
+    const { domain, tx }: { domain: Domain; tx: EntityManager } = context.state
+
+    let filterRefNo = ''
+    if (refNo) {
+      const removeSymbol = refNo
+        .split('')
+        .filter(res => res !== '%')
+        .join('')
+
+      const filterInfos = removeSymbol
+        .toLowerCase()
+        .split(',')
+        .map(value => "'%" + value.trim().replace(/'/g, "''") + "%'")
+        .join(',')
+
+      filterRefNo = ` and (
+        lower(rg.ref_no) like any(array[${filterInfos}])
+        or lower(rg.ref_no_2) like any(array[${filterInfos}])
+        or lower(rg.ref_no_3) like any(array[${filterInfos}])
+      )`
+    }
+
+    const rows = await tx.query(
+      `
+      select distinct
+        rg.id as "id",
+        rg.name as "name",
+        rg.ref_no as "refNo",
+        rg.ref_no_2 as "refNo2",
+        rg.ref_no_3 as "refNo3",
+        rg.route_id as "routeId",
+        rg.store_id as "storeId",
+        rg.store_name as "storeName",
+        rg.stop_id as "stopId",
+        rg.created_at as "createdAt"
+      from worksheets ws
+      inner join worksheet_details wsd on wsd.worksheet_id = ws.id
+      inner join order_inventories oi on oi.id = wsd.target_inventory_id
+      inner join release_goods rg on rg.id = oi.release_good_id
+      where ws.domain_id = $1
+        and ws.type = $2
+        and ws.status = $3
+        and rg.domain_id = $1
+        and rg.bizplace_id = $4
+        ${filterRefNo}
+      order by rg.created_at desc
+      `,
+      [domain.id, worksheetType, WORKSHEET_STATUS.EXECUTING, partnerId]
+    )
+
+    const releaseGoods = rows || []
+
+    // If seqField is provided, fetch and merge sequence data
+    if (seqField && ['refNo', 'refNo2', 'refNo3'].includes(seqField) && releaseGoods.length > 0) {
+      const releaseGoodIds = releaseGoods.map((rg: any) => rg.id)
+
+      // Fetch lastSeq from counters
+      const lastSeqById = new Map<string, number>()
+      const counterRepo = tx.getRepository(RouteLabelSequenceCounter)
+      const counters = await counterRepo.find({
+        where: { domain, releaseGoodId: In(releaseGoodIds), field: seqField }
+      })
+      for (const c of counters) {
+        lastSeqById.set(c.releaseGoodId, parseNonNegativeInt(c.lastSeq))
+      }
+
+      // Fetch lastPrintedBy from logs (most recent per releaseGood)
+      const lastPrintedById = new Map<string, string>()
+      const logRepo = tx.getRepository(RouteLabelSequenceLog)
+      const logs = await logRepo.find({
+        where: { domain, releaseGoodId: In(releaseGoodIds), field: seqField },
+        relations: ['creator'],
+        order: { createdAt: 'DESC' },
+        take: 500
+      })
+
+      for (const log of logs) {
+        if (!lastPrintedById.has(log.releaseGoodId) && log.creator) {
+          lastPrintedById.set(log.releaseGoodId, log.creator.name || '')
+        }
+      }
+
+      // Merge sequence data into release goods
+      return releaseGoods.map((rg: any) => ({
+        ...rg,
+        lastSeq: lastSeqById.get(rg.id) || 0,
+        lastPrintedBy: lastPrintedById.get(rg.id) || null
+      }))
+    }
+
+    return releaseGoods
+  }
+}
+
+export const routeLabelSequenceStatuses = {
+  async routeLabelSequenceStatuses(_: any, { releaseGoodIds, field }, context: any) {
+    const { domain, tx }: { domain: Domain; tx: EntityManager } = context.state
+    ensureSeqField(field)
+
+    const lastSeqById = new Map<string, number>()
+    const counterRepo = tx.getRepository(RouteLabelSequenceCounter)
+    const counters = await counterRepo.find({
+      where: { domain, releaseGoodId: In(releaseGoodIds), field }
+    })
+    for (const c of counters) {
+      lastSeqById.set(c.releaseGoodId, parseNonNegativeInt(c.lastSeq))
+    }
+
+    const histById = new Map<string, string[]>()
+    const lastPrintedById = new Map<string, string>()
+    const logRepo = tx.getRepository(RouteLabelSequenceLog)
+    const logs = await logRepo.find({
+      where: { domain, releaseGoodId: In(releaseGoodIds), field },
+      relations: ['creator'],
+      order: { createdAt: 'DESC' },
+      take: 500
+    })
+
+    for (const log of logs) {
+      const list = histById.get(log.releaseGoodId) || []
+      if (list.length >= 5) continue
+      list.push(`${log.from}-${log.to}`)
+      histById.set(log.releaseGoodId, list)
+
+      // Store the creator name from the most recent log entry (first one due to DESC order)
+      if (!lastPrintedById.has(log.releaseGoodId) && log.creator) {
+        lastPrintedById.set(log.releaseGoodId, log.creator.name || '')
+      }
+    }
+
+    return releaseGoodIds.map((releaseGoodId: string) => {
+      return {
+        releaseGoodId,
+        field,
+        lastSeq: lastSeqById.get(releaseGoodId) || 0,
+        history: histById.get(releaseGoodId) || [],
+        lastPrintedBy: lastPrintedById.get(releaseGoodId) || null
+      }
+    })
+  }
+}
+
+export const reserveRouteLabelSequence = {
+  async reserveRouteLabelSequence(_: any, { releaseGoodId, field, qty }, context: any) {
+    const { domain, tx, user }: { domain: Domain; tx: EntityManager; user: User } = context.state
+    ensureSeqField(field)
+
+    const q = parseNonNegativeInt(qty)
+    if (q <= 0) {
+      throw new Error('Print qty must be greater than 0')
+    }
+
+    const counterRepo = tx.getRepository(RouteLabelSequenceCounter)
+    const logRepo = tx.getRepository(RouteLabelSequenceLog)
+
+    // Lock counter row to avoid duplicated sequences under concurrent prints.
+    let counter = await counterRepo
+      .createQueryBuilder('c')
+      .setLock('pessimistic_write')
+      .where('c.domain = :domainId and c.releaseGoodId = :releaseGoodId and c.field = :field', {
+        domainId: domain.id,
+        releaseGoodId,
+        field
+      })
+      .getOne()
+
+    if (!counter) {
+      try {
+        await counterRepo.save({
+          domain,
+          releaseGoodId,
+          field,
+          lastSeq: 0,
+          creator: user,
+          updater: user
+        })
+      } catch (e) {
+        // ignore: concurrent insert can violate unique index
+      }
+
+      counter = await counterRepo
+        .createQueryBuilder('c')
+        .setLock('pessimistic_write')
+        .where('c.domain = :domainId and c.releaseGoodId = :releaseGoodId and c.field = :field', {
+          domainId: domain.id,
+          releaseGoodId,
+          field
+        })
+        .getOne()
+    }
+
+    if (!counter) {
+      throw new Error('Failed to initialize route label sequence counter')
+    }
+
+    const last = parseNonNegativeInt(counter.lastSeq)
+    const from = last + 1
+    const to = last + q
+
+    await counterRepo.update(counter.id, { lastSeq: to, updater: user, updatedAt: new Date() })
+    await logRepo.save({ domain, releaseGoodId, field, from, to, qty: q, creator: user })
+
+    return { releaseGoodId, field, from, to }
+  }
+}
+
+export const routeLabelSequenceLogs = {
+  async routeLabelSequenceLogs(_: any, { releaseGoodId, field }, context: any) {
+    const { domain, tx }: { domain: Domain; tx: EntityManager } = context.state
+    ensureSeqField(field)
+
+    const rows =
+      (await tx.query(
+        `
+        select
+          l.id as "id",
+          l.release_good_id as "releaseGoodId",
+          l.field as "field",
+          l."from" as "from",
+          l."to" as "to",
+          l.qty as "qty",
+          l.created_at as "createdAt",
+          u.name as "creatorName"
+        from route_label_sequence_logs l
+        left join users u on u.id = l.creator_id
+        where l.domain_id = $1
+          and l.release_good_id = $2
+          and l.field = $3
+        order by l.created_at desc
+        limit 200
+        `,
+        [domain.id, releaseGoodId, field]
+      )) || []
+
+    return rows.map((row: any) => {
+      const createdAt = row.createdAt ? new Date(row.createdAt) : null
+      return {
+        ...row,
+        createdAt: createdAt ? createdAt.toISOString() : null
+      }
+    })
+  }
+}

package/server/graphql/resolvers/zone-worksheet/index.ts

@@ -1,5 +1,5 @@
 import { zonePickingWorksheet, zoneWorksheetOverview } from './zone-worksheet'
-import { generateWorksheetZonePicking  } from './generate-zone-worksheet'
+import { generateWorksheetZonePicking } from './generate-zone-worksheet'
 import { activateBulkWorksheetZonePicking, activateWorksheetZonePicking } from './activate-zone-worksheet'
 import { zonePicking } from './zone-picking'
 import { assignSorter } from './assign-sorter'
@@ -7,7 +7,7 @@ import { getZonePickingTask } from './get-zone-picking-task'
 
 export const Query = {
   ...zoneWorksheetOverview,
-  ...zonePickingWorksheet,
+  ...zonePickingWorksheet
 }
 
 export const Mutation = {