jason
/
FPSMS-backend
2
0
Fork 0
Code Issues 0 Pull Requests 0 Releases 0 Wiki Activity
Browse Source

fix scan lot and scan not match lt and new issue handle

master
CANCERYS\kw093 1 week ago
parent
10a8de81e5
commit
dac9b90e74
7 changed files with 865 additions and 575 deletions
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. +396
    -197
      src/main/java/com/ffii/fpsms/modules/pickOrder/service/PickExecutionIssueService.kt
  2. +28
    -14
      src/main/java/com/ffii/fpsms/modules/pickOrder/service/PickOrderService.kt
  3. +2
    -1
      src/main/java/com/ffii/fpsms/modules/pickOrder/web/models/PickExecutionIssueRequest.kt
  4. +3
    -0
      src/main/java/com/ffii/fpsms/modules/stock/entity/InventoryLotLine.kt
  5. +22
    -0
      src/main/java/com/ffii/fpsms/modules/stock/entity/StockOutLIneRepository.kt
  6. +409
    -363
      src/main/java/com/ffii/fpsms/modules/stock/service/SuggestedPickLotService.kt
  7. +5
    -0
      src/main/resources/db/changelog/changes/20260122_01_Enson/01_alter_table.sql

+ 396
- 197
src/main/java/com/ffii/fpsms/modules/pickOrder/service/PickExecutionIssueService.kt View File

@@ -11,7 +11,9 @@ import com.ffii.fpsms.modules.stock.entity.StockOutLIneRepository
import com.ffii.fpsms.modules.stock.entity.InventoryLotLine
import com.ffii.fpsms.modules.stock.entity.InventoryLotLineRepository
import com.ffii.fpsms.modules.stock.entity.InventoryRepository
import com.ffii.fpsms.modules.stock.service.StockOutLineService

import com.ffii.fpsms.modules.pickOrder.enums.PickOrderLineStatus
import com.ffii.fpsms.modules.stock.service.SuggestedPickLotService
import com.ffii.fpsms.modules.stock.entity.enum.InventoryLotLineStatus
import org.springframework.stereotype.Service
@@ -30,7 +32,7 @@ import com.ffii.fpsms.modules.jobOrder.entity.JoPickOrderRecordRepository
import com.ffii.fpsms.modules.pickOrder.enums.PickExecutionIssueEnum
import com.ffii.fpsms.modules.stock.web.model.StockOutLineStatus
import com.ffii.fpsms.modules.stock.web.model.StockOutStatus
import com.ffii.fpsms.modules.pickOrder.enums.PickOrderLineStatus
import com.ffii.fpsms.modules.pickOrder.enums.PickOrderStatus
import com.ffii.fpsms.modules.pickOrder.web.models.*
import com.ffii.fpsms.modules.common.SecurityUtils
@@ -52,6 +54,7 @@ open class PickExecutionIssueService(
private val pickOrderRepository: PickOrderRepository,
private val jdbcDao: JdbcDao,
private val stockOutRepository: StockOutRepository,
private val stockOutLineService: StockOutLineService,
private val pickOrderLineRepository: PickOrderLineRepository,
private val doPickOrderService: DoPickOrderService,
private val joPickOrderRepository: JoPickOrderRepository,
@@ -62,217 +65,227 @@ open class PickExecutionIssueService(
) {

@Transactional(rollbackFor = [Exception::class])
open fun recordPickExecutionIssue(request: PickExecutionIssueRequest): MessageResponse {
try {
// 1. 检查是否已经存在相同的 pick execution issue 记录
val existingIssues = pickExecutionIssueRepository.findByPickOrderLineIdAndLotIdAndDeletedFalse(
request.pickOrderLineId,
request.lotId ?: 0L
)
if (existingIssues.isNotEmpty()) {
return MessageResponse(
id = null,
name = "Pick execution issue already exists",
code = "DUPLICATE",
type = "pick_execution_issue",
message = "A pick execution issue for this lot has already been recorded",
errorPosition = null
)
}
val pickOrder = pickOrderRepository.findById(request.pickOrderId).orElse(null)
// 2. 获取 inventory_lot_line 并计算账面数量 (bookQty)
val inventoryLotLine = request.lotId?.let {
inventoryLotLineRepository.findById(it).orElse(null)
}
// 计算账面数量（创建 issue 时的快照）
val bookQty = if (inventoryLotLine != null) {
val inQty = inventoryLotLine.inQty ?: BigDecimal.ZERO
val outQty = inventoryLotLine.outQty ?: BigDecimal.ZERO
inQty.subtract(outQty) // bookQty = inQty - outQty
} else {
BigDecimal.ZERO
}
// 3. 获取数量值
val requiredQty = request.requiredQty ?: BigDecimal.ZERO
val actualPickQty = request.actualPickQty ?: BigDecimal.ZERO
val missQty = request.missQty ?: BigDecimal.ZERO
val badItemQty = request.badItemQty ?: BigDecimal.ZERO
// 4. 验证逻辑：如果 actualPickQty == requiredQty，missQty 必须为 0
if (actualPickQty == requiredQty && missQty > BigDecimal.ZERO) {
return MessageResponse(
id = null,
name = "Invalid issue",
code = "INVALID",
type = "pick_execution_issue",
message = "If actual pick qty equals required qty, miss qty must be 0",
errorPosition = null
open fun recordPickExecutionIssue(request: PickExecutionIssueRequest): MessageResponse {
try {
// 1. 检查是否已经存在相同的 pick execution issue 记录
val existingIssues = pickExecutionIssueRepository.findByPickOrderLineIdAndLotIdAndDeletedFalse(
request.pickOrderLineId,
request.lotId ?: 0L
)
}
// 5. 计算 issueQty（实际的问题数量）
val issueQty = when {
// 情况1: 已拣完但有坏品
actualPickQty == requiredQty && badItemQty > BigDecimal.ZERO -> {
badItemQty // issueQty = badItemQty
}
// 情况2: 未拣完（有缺失或坏品）
actualPickQty < requiredQty -> {
// issueQty = bookQty - actualPickQty
// 这是实际缺失的数量（账面应该有的数量 - 实际拣到的数量）
val calculatedIssueQty = bookQty.subtract(actualPickQty)
// 验证：如果用户报告了 missQty，它应该 <= issueQty（但允许用户报告的值）
if (missQty > BigDecimal.ZERO && missQty > calculatedIssueQty) {
println("⚠️ Warning: User reported missQty (${missQty}) exceeds calculated issueQty (${calculatedIssueQty})")
println(" BookQty: ${bookQty}, ActualPickQty: ${actualPickQty}")
}
calculatedIssueQty
if (existingIssues.isNotEmpty()) {
return MessageResponse(
id = null,
name = "Pick execution issue already exists",
code = "DUPLICATE",
type = "pick_execution_issue",
message = "A pick execution issue for this lot has already been recorded",
errorPosition = null
)
}
else -> BigDecimal.ZERO
}
println("=== PICK EXECUTION ISSUE PROCESSING ===")
println("Required Qty: ${requiredQty}")
println("Actual Pick Qty: ${actualPickQty}")
println("Miss Qty (Reported): ${missQty}")
println("Bad Item Qty: ${badItemQty}")
println("Book Qty (inQty - outQty): ${bookQty}")
println("Issue Qty (Calculated): ${issueQty}")
println("Lot ID: ${request.lotId}")
println("Item ID: ${request.itemId}")
println("================================================")
// 6. 创建 pick execution issue 记录
val pickExecutionIssue = PickExecutionIssue(
id = null,
pickOrderId = request.pickOrderId,
pickOrderCode = request.pickOrderCode,
pickOrderCreateDate = request.pickOrderCreateDate,
pickExecutionDate = request.pickExecutionDate ?: LocalDate.now(),
pickOrderLineId = request.pickOrderLineId,
issueNo = generateIssueNo(),
joPickOrderId = pickOrder?.jobOrder?.id,
doPickOrderId = if (pickOrder?.type?.value == "do") pickOrder.id else null,
issueCategory = IssueCategory.valueOf(
request.issueCategory ?: "lot_issue"
),
itemId = request.itemId,
itemCode = request.itemCode,
itemDescription = request.itemDescription,
lotId = request.lotId,
lotNo = request.lotNo,
storeLocation = request.storeLocation,
requiredQty = request.requiredQty,
actualPickQty = request.actualPickQty,
missQty = request.missQty,
badItemQty = request.badItemQty,
bookQty = bookQty, // 添加账面数量
issueQty = issueQty, // 添加计算的问题数量
issueRemark = request.issueRemark,
pickerName = request.pickerName,
handleStatus = HandleStatus.pending,
handleDate = null,
handledBy = request.handledBy,
created = LocalDateTime.now(),
createdBy = "system",
version = 0,
modified = LocalDateTime.now(),
modifiedBy = "system",
deleted = false
)

val savedIssue = pickExecutionIssueRepository.save(pickExecutionIssue)

// 7. 获取相关数据用于后续处理
val actualPickQtyForProcessing = request.actualPickQty ?: BigDecimal.ZERO
val missQtyForProcessing = request.missQty ?: BigDecimal.ZERO
val badItemQtyForProcessing = request.badItemQty ?: BigDecimal.ZERO
val lotId = request.lotId
val itemId = request.itemId

println("=== PICK EXECUTION ISSUE PROCESSING (NEW LOGIC) ===")
println("Actual Pick Qty: ${actualPickQtyForProcessing}")
println("Miss Qty: ${missQtyForProcessing}")
println("Bad Item Qty: ${badItemQtyForProcessing}")
println("Lot ID: ${lotId}")
println("Item ID: ${itemId}")
println("================================================")

// 8. 新的统一处理逻辑
when {
// 情况1: 只有 miss item (actualPickQty = 0, missQty > 0, badItemQty = 0)
actualPickQtyForProcessing == BigDecimal.ZERO && missQtyForProcessing > BigDecimal.ZERO && badItemQtyForProcessing == BigDecimal.ZERO -> {
handleMissItemOnly(request, missQtyForProcessing)
}
val pickOrder = pickOrderRepository.findById(request.pickOrderId).orElse(null)
// 情况2: 只有 bad item (badItemQty > 0, missQty = 0)
badItemQtyForProcessing > BigDecimal.ZERO && missQtyForProcessing == BigDecimal.ZERO -> {
handleBadItemOnly(request, badItemQtyForProcessing)
// 2. 获取 inventory_lot_line 并计算账面数量 (bookQty)
val inventoryLotLine = request.lotId?.let {
inventoryLotLineRepository.findById(it).orElse(null)
}
// 情况3: 既有 miss item 又有 bad item
missQtyForProcessing > BigDecimal.ZERO && badItemQtyForProcessing > BigDecimal.ZERO -> {
handleBothMissAndBadItem(request, missQtyForProcessing, badItemQtyForProcessing)
// 计算账面数量（创建 issue 时的快照）
val bookQty = if (inventoryLotLine != null) {
val inQty = inventoryLotLine.inQty ?: BigDecimal.ZERO
val outQty = inventoryLotLine.outQty ?: BigDecimal.ZERO
inQty.subtract(outQty) // bookQty = inQty - outQty
} else {
BigDecimal.ZERO
}
// 修复：情况4: 有 miss item 的情况（无论 actualPickQty 是多少）
missQtyForProcessing > BigDecimal.ZERO -> {
handleMissItemWithPartialPick(request, actualPickQtyForProcessing, missQtyForProcessing)
}
// 3. 获取数量值
val requiredQty = request.requiredQty ?: BigDecimal.ZERO
val actualPickQty = request.actualPickQty ?: BigDecimal.ZERO
val missQty = request.missQty ?: BigDecimal.ZERO
val badItemQty = request.badItemQty ?: BigDecimal.ZERO
// 情况5: 正常拣货 (actualPickQty > 0, 没有 miss 或 bad item)
actualPickQtyForProcessing > BigDecimal.ZERO -> {
handleNormalPick(request, actualPickQtyForProcessing)
// 4. 计算 issueQty（实际的问题数量）
val issueQty = when {
// 情况1: 已拣完但有坏品
actualPickQty == requiredQty && badItemQty > BigDecimal.ZERO -> {
badItemQty // issueQty = badItemQty
}
// 情况2: 未拣完（有缺失或坏品）
actualPickQty < requiredQty -> {
// issueQty = bookQty - actualPickQty
val calculatedIssueQty = bookQty.subtract(actualPickQty)
if (missQty > BigDecimal.ZERO && missQty > calculatedIssueQty) {
println("⚠️ Warning: User reported missQty (${missQty}) exceeds calculated issueQty (${calculatedIssueQty})")
println(" BookQty: ${bookQty}, ActualPickQty: ${actualPickQty}")
}
calculatedIssueQty
}
else -> BigDecimal.ZERO
}
else -> {
println("Unknown case: actualPickQty=${actualPickQtyForProcessing}, missQty=${missQtyForProcessing}, badItemQty=${badItemQtyForProcessing}")
println("=== PICK EXECUTION ISSUE PROCESSING ===")
println("Required Qty: ${requiredQty}")
println("Actual Pick Qty: ${actualPickQty}")
println("Miss Qty (Reported): ${missQty}")
println("Bad Item Qty: ${badItemQty}")
println("Book Qty (inQty - outQty): ${bookQty}")
println("Issue Qty (Calculated): ${issueQty}")
println("Bad Reason: ${request.badReason}")
println("Lot ID: ${request.lotId}")
println("Item ID: ${request.itemId}")
println("================================================")
// 5. 创建 pick execution issue 记录
val pickExecutionIssue = PickExecutionIssue(
id = null,
pickOrderId = request.pickOrderId,
pickOrderCode = request.pickOrderCode,
pickOrderCreateDate = request.pickOrderCreateDate,
pickExecutionDate = request.pickExecutionDate ?: LocalDate.now(),
pickOrderLineId = request.pickOrderLineId,
issueNo = generateIssueNo(),
joPickOrderId = pickOrder?.jobOrder?.id,
doPickOrderId = if (pickOrder?.type?.value == "do") pickOrder.id else null,
issueCategory = IssueCategory.valueOf(
request.issueCategory ?: "lot_issue"
),
itemId = request.itemId,
itemCode = request.itemCode,
itemDescription = request.itemDescription,
lotId = request.lotId,
lotNo = request.lotNo,
storeLocation = request.storeLocation,
requiredQty = request.requiredQty,
actualPickQty = request.actualPickQty,
missQty = request.missQty,
badItemQty = request.badItemQty,
bookQty = bookQty,
issueQty = issueQty,
issueRemark = request.issueRemark,
pickerName = request.pickerName,
handleStatus = HandleStatus.pending,
handleDate = null,
handledBy = request.handledBy,
created = LocalDateTime.now(),
createdBy = "system",
version = 0,
modified = LocalDateTime.now(),
modifiedBy = "system",
deleted = false
)
val savedIssue = pickExecutionIssueRepository.save(pickExecutionIssue)
// 6. NEW: Update inventory_lot_line.issueQty
if (request.lotId != null && inventoryLotLine != null) {
val currentIssueQty = inventoryLotLine.issueQty ?: BigDecimal.ZERO
val newIssueQty = currentIssueQty.add(issueQty)
inventoryLotLine.issueQty = newIssueQty
inventoryLotLine.modified = LocalDateTime.now()
inventoryLotLine.modifiedBy = "system"
inventoryLotLineRepository.saveAndFlush(inventoryLotLine)
println("Updated inventory_lot_line ${request.lotId} issueQty: ${currentIssueQty} -> ${newIssueQty}")
}
}

val pickOrderForCompletion = pickOrderRepository.findById(request.pickOrderId).orElse(null)
val consoCode = pickOrderForCompletion?.consoCode
if (consoCode != null) {
println("🔍 Checking if pick order $consoCode should be completed after lot rejection...")
try {
checkAndCompletePickOrder(consoCode)
} catch (e: Exception) {
println("⚠️ Error checking pick order completion: ${e.message}")
// 7. 获取相关数据用于后续处理
val actualPickQtyForProcessing = request.actualPickQty ?: BigDecimal.ZERO
val missQtyForProcessing = request.missQty ?: BigDecimal.ZERO
val badItemQtyForProcessing = request.badItemQty ?: BigDecimal.ZERO
val lotId = request.lotId
val itemId = request.itemId
println("=== PICK EXECUTION ISSUE PROCESSING (NEW LOGIC) ===")
println("Actual Pick Qty: ${actualPickQtyForProcessing}")
println("Miss Qty: ${missQtyForProcessing}")
println("Bad Item Qty: ${badItemQtyForProcessing}")
println("Bad Reason: ${request.badReason}")
println("Lot ID: ${lotId}")
println("Item ID: ${itemId}")
println("================================================")
// 8. 新的统一处理逻辑（根据 badReason 决定处理方式）
when {
// 情况1: 只有 miss item (actualPickQty = 0, missQty > 0, badItemQty = 0)
actualPickQtyForProcessing == BigDecimal.ZERO && missQtyForProcessing > BigDecimal.ZERO && badItemQtyForProcessing == BigDecimal.ZERO -> {
handleMissItemOnly(request, missQtyForProcessing)
}
// 情况2: 只有 bad item (badItemQty > 0, missQty = 0)
badItemQtyForProcessing > BigDecimal.ZERO && missQtyForProcessing == BigDecimal.ZERO -> {
// NEW: Check bad reason
if (request.badReason == "package_problem") {
handleBadItemPackageProblem(request, badItemQtyForProcessing)
} else {
// quantity_problem or default: handle as normal bad item
handleBadItemOnly(request, badItemQtyForProcessing)
}
}
// 情况3: 既有 miss item 又有 bad item
missQtyForProcessing > BigDecimal.ZERO && badItemQtyForProcessing > BigDecimal.ZERO -> {
// NEW: Check bad reason
if (request.badReason == "package_problem") {
handleBothMissAndBadItemPackageProblem(request, missQtyForProcessing, badItemQtyForProcessing)
} else {
handleBothMissAndBadItem(request, missQtyForProcessing, badItemQtyForProcessing)
}
}
// 情况4: 有 miss item 的情况（无论 actualPickQty 是多少）
missQtyForProcessing > BigDecimal.ZERO -> {
handleMissItemWithPartialPick(request, actualPickQtyForProcessing, missQtyForProcessing)
}
// 情况5: 正常拣货 (actualPickQty > 0, 没有 miss 或 bad item)
actualPickQtyForProcessing > BigDecimal.ZERO -> {
handleNormalPick(request, actualPickQtyForProcessing)
}
else -> {
println("Unknown case: actualPickQty=${actualPickQtyForProcessing}, missQty=${missQtyForProcessing}, badItemQty=${badItemQtyForProcessing}")
}
}
val pickOrderForCompletion = pickOrderRepository.findById(request.pickOrderId).orElse(null)
val consoCode = pickOrderForCompletion?.consoCode
if (consoCode != null) {
println("🔍 Checking if pick order $consoCode should be completed after lot rejection...")
try {
checkAndCompletePickOrder(consoCode)
} catch (e: Exception) {
println("⚠️ Error checking pick order completion: ${e.message}")
}
}
return MessageResponse(
id = savedIssue.id,
name = "Pick execution issue recorded successfully",
code = "SUCCESS",
type = "pick_execution_issue",
message = "Pick execution issue recorded successfully",
errorPosition = null
)
} catch (e: Exception) {
println("=== ERROR IN recordPickExecutionIssue ===")
e.printStackTrace()
return MessageResponse(
id = null,
name = "Failed to record pick execution issue",
code = "ERROR",
type = "pick_execution_issue",
message = "Error: ${e.message}",
errorPosition = null
)
}

return MessageResponse(
id = savedIssue.id,
name = "Pick execution issue recorded successfully",
code = "SUCCESS",
type = "pick_execution_issue",
message = "Pick execution issue recorded successfully",
errorPosition = null
)

} catch (e: Exception) {
println("=== ERROR IN recordPickExecutionIssue ===")
e.printStackTrace()
return MessageResponse(
id = null,
name = "Failed to record pick execution issue",
code = "ERROR",
type = "pick_execution_issue",
message = "Error: ${e.message}",
errorPosition = null
)
}
}
private fun generateIssueNo(): String {
val now = LocalDateTime.now()
val yearMonth = now.format(java.time.format.DateTimeFormatter.ofPattern("yyMM"))
@@ -1511,7 +1524,8 @@ private fun updateLotLineAfterIssue(lotLineId: Long, qty: BigDecimal) {
val currentOutQty = lotLine.outQty ?: BigDecimal.ZERO
val newOutQty = currentOutQty.add(qty)
lotLine.outQty = newOutQty
val currentIssueQty = lotLine.issueQty ?: BigDecimal.ZERO
lotLine.issueQty = currentIssueQty.subtract(qty)
// If outQty != inQty, set status to AVAILABLE
val inQty = lotLine.inQty ?: BigDecimal.ZERO
if (newOutQty != inQty) {
@@ -1627,4 +1641,189 @@ private fun createStockLedgerForStockOut(stockOutLine: StockOutLine, ledgerType:
println("Balance: ${finalBalance}")
println("===========================")
}



@Transactional(propagation = Propagation.REQUIRES_NEW, rollbackFor = [Exception::class])
private fun handleBadItemPackageProblem(request: PickExecutionIssueRequest, badItemQty: BigDecimal) {
println("=== HANDLING BAD ITEM PACKAGE PROBLEM (DON'T REJECT LOT) ===")
println("Bad Item Qty: ${badItemQty}")
val lotId = request.lotId ?: return
val itemId = request.itemId ?: return
val inventoryLotLine = inventoryLotLineRepository.findById(lotId).orElse(null)
if (inventoryLotLine != null) {
// Package problem: Don't mark as unavailable, just record the issue
// Update outQty for actual picked items if any
if (request.actualPickQty != null && request.actualPickQty > BigDecimal.ZERO) {
val currentOutQty = inventoryLotLine.outQty ?: BigDecimal.ZERO
val newOutQty = currentOutQty.add(request.actualPickQty)
inventoryLotLine.outQty = newOutQty
println("Package problem: Updated outQty: ${currentOutQty} -> ${newOutQty}")
}
// IssueQty is already updated in recordPickExecutionIssue
inventoryLotLine.modified = LocalDateTime.now()
inventoryLotLine.modifiedBy = "system"
inventoryLotLineRepository.saveAndFlush(inventoryLotLine)
println("Package problem: Updated lot ${lotId}, but did NOT mark as unavailable")
}
// Update inventory unavailableQty (still need to track unavailable quantity)
updateInventoryUnavailableQty(itemId, badItemQty)
// DON'T reject stock_out_line for package problem
val stockOutLines = stockOutLineRepository.findByPickOrderLineIdAndInventoryLotLineIdAndDeletedFalse(
request.pickOrderLineId,
request.lotId ?: 0L
)
stockOutLines.forEach { stockOutLine ->
if (request.actualPickQty != null) {
stockOutLine.qty = request.actualPickQty.toDouble()
}
// Determine status based on actual pick qty vs required qty
val requiredQty = request.requiredQty?.toDouble() ?: 0.0
val actualPickQtyDouble = request.actualPickQty?.toDouble() ?: 0.0
val newStatus = if (actualPickQtyDouble >= requiredQty) {
"completed"
} else {
"partially_completed"
}
stockOutLine.status = newStatus
stockOutLine.modified = LocalDateTime.now()
stockOutLine.modifiedBy = "system"
val savedStockOutLine = stockOutLineRepository.saveAndFlush(stockOutLine)
// Create stock ledger for actual picked items
if (request.actualPickQty != null && request.actualPickQty > BigDecimal.ZERO) {
createStockLedgerForStockOut(savedStockOutLine, "Nor")
}
println("Package problem: Updated stock out line ${stockOutLine.id} status to: ${newStatus} (NOT rejected)")
}
try {
// 确保所有更改都已刷新到数据库
stockOutLineRepository.flush()
// 直接查询并检查该 pick order line 下的所有 stock out lines
val allStockOutLines = stockOutLineRepository.findAllByPickOrderLineIdAndDeletedFalse(request.pickOrderLineId)
val unfinishedLines = allStockOutLines.filter {
it.status != StockOutLineStatus.COMPLETE.status
&& it.status != StockOutLineStatus.REJECTED.status
}
println("Package problem: Checking pick order line ${request.pickOrderLineId}")
println(" Total stock out lines: ${allStockOutLines.size}")
println(" Unfinished lines: ${unfinishedLines.size}")
unfinishedLines.forEach { line ->
println(" - Line ${line.id}: status=${line.status}")
}
if (unfinishedLines.isEmpty() && allStockOutLines.isNotEmpty()) {
val pickOrderLine = pickOrderLineRepository.findById(request.pickOrderLineId).orElse(null)
if (pickOrderLine != null) {
pickOrderLine.status = PickOrderLineStatus.COMPLETED
pickOrderLineRepository.saveAndFlush(pickOrderLine)
println("✅ Package problem: Updated pick order line ${request.pickOrderLineId} status to COMPLETED")
} else {
println("⚠️ Package problem: Pick order line ${request.pickOrderLineId} not found")
}
} else {
println("⚠️ Package problem: Pick order line ${request.pickOrderLineId} still has ${unfinishedLines.size} unfinished lines")
}
} catch (e: Exception) {
println("⚠️ Error checking pick order line completion: ${e.message}")
e.printStackTrace()
}
// Don't resuggest for package problem (lot is still available)
println("Package problem: Did NOT resuggest pick order (lot remains available)")
}

// NEW: Handle both miss and bad item with package problem
@Transactional(propagation = Propagation.REQUIRES_NEW, rollbackFor = [Exception::class])
private fun handleBothMissAndBadItemPackageProblem(request: PickExecutionIssueRequest, missQty: BigDecimal, badItemQty: BigDecimal) {
println("=== HANDLING BOTH MISS AND BAD ITEM PACKAGE PROBLEM ===")
println("Miss Qty: ${missQty}, Bad Item Qty: ${badItemQty}")
val lotId = request.lotId ?: return
val itemId = request.itemId ?: return
val inventoryLotLine = inventoryLotLineRepository.findById(lotId).orElse(null)
if (inventoryLotLine != null) {
// Update outQty for actual picked items
if (request.actualPickQty != null && request.actualPickQty > BigDecimal.ZERO) {
val currentOutQty = inventoryLotLine.outQty ?: BigDecimal.ZERO
val newOutQty = currentOutQty.add(request.actualPickQty)
inventoryLotLine.outQty = newOutQty
println("Both miss and bad (package): Updated outQty: ${currentOutQty} -> ${newOutQty}")
}
// Miss item: mark as unavailable
if (missQty > BigDecimal.ZERO) {
inventoryLotLine.status = InventoryLotLineStatus.UNAVAILABLE
println("Both miss and bad (package): Set status to UNAVAILABLE due to missQty: ${missQty}")
}
// IssueQty is already updated in recordPickExecutionIssue
inventoryLotLine.modified = LocalDateTime.now()
inventoryLotLine.modifiedBy = "system"
inventoryLotLineRepository.saveAndFlush(inventoryLotLine)
}
// Update inventory unavailableQty (miss qty + bad qty)
val totalUnavailableQty = missQty.add(badItemQty)
updateInventoryUnavailableQty(itemId, totalUnavailableQty)
// Update stock_out_line: reject only if missQty > 0, otherwise partial/completed
val stockOutLines = stockOutLineRepository.findByPickOrderLineIdAndInventoryLotLineIdAndDeletedFalse(
request.pickOrderLineId,
request.lotId ?: 0L
)
stockOutLines.forEach { stockOutLine ->
if (request.actualPickQty != null) {
stockOutLine.qty = request.actualPickQty.toDouble()
}
val requiredQty = request.requiredQty?.toDouble() ?: 0.0
val actualPickQtyDouble = request.actualPickQty?.toDouble() ?: 0.0
// If missQty > 0, reject; otherwise check completion status
val newStatus = if (missQty > BigDecimal.ZERO) {
"rejected"
} else if (actualPickQtyDouble >= requiredQty) {
"completed"
} else {
"partially_completed"
}
stockOutLine.status = newStatus
stockOutLine.modified = LocalDateTime.now()
stockOutLine.modifiedBy = "system"
val savedStockOutLine = stockOutLineRepository.saveAndFlush(stockOutLine)
if (request.actualPickQty != null && request.actualPickQty > BigDecimal.ZERO) {
createStockLedgerForStockOut(savedStockOutLine, "Nor")
}
println("Both miss and bad (package): Updated stock out line ${stockOutLine.id} status to: ${newStatus}")
}
// Resuggest only for miss qty
if (missQty > BigDecimal.ZERO) {
try {
resuggestPickOrder(request.pickOrderId)
println("Resuggested pick order for miss qty: ${missQty}")
} catch (e: Exception) {
println("Error during resuggest: ${e.message}")
}
} else {
println("Both miss and bad (package): Did NOT resuggest (only bad item with package problem)")
}
}
}

+ 28
- 14
src/main/java/com/ffii/fpsms/modules/pickOrder/service/PickOrderService.kt View File

@@ -3601,8 +3601,8 @@ ORDER BY
val enrichedResults = filteredResults
return enrichedResults
}
// ... existing code ...
open fun getAllPickOrderLotsWithDetailsHierarchical(userId: Long): Map<String, Any?> {
// 修改后的逻辑
open fun getAllPickOrderLotsWithDetailsHierarchical(userId: Long): Map<String, Any?> {
println("=== Debug: getAllPickOrderLotsWithDetailsHierarchical (Repository-based) ===")
println("userId filter: $userId")
@@ -3612,8 +3612,9 @@ ORDER BY
return emptyMap()
}
// Step 1: 先找到分配给该用户的所有 pick orders
val userPickOrders = pickOrderRepository.findAll()
// Step 1: 先找到用户有活跃任务的 do_pick_order（通过 do_pick_order_line）
// 这样可以确保只获取同一个 ticket 的 pick orders
val userPickOrdersForDo = pickOrderRepository.findAll()
.filter {
it.deleted == false &&
it.assignTo?.id == userId &&
@@ -3624,26 +3625,26 @@ ORDER BY
it.status == PickOrderStatus.ASSIGNED)
}
if (userPickOrders.isEmpty()) {
println("❌ No pick orders found for user $userId")
if (userPickOrdersForDo.isEmpty()) {
println("❌ No active pick orders found for user $userId")
return mapOf(
"fgInfo" to null,
"pickOrders" to emptyList<Any>()
)
}
println(" Found ${userPickOrders.size} pick orders assigned to user $userId")
val pickOrderIds = userPickOrders.mapNotNull { it.id }
val activePickOrderIds = userPickOrdersForDo.mapNotNull { it.id }
println(" Found ${activePickOrderIds.size} active pick orders assigned to user $userId")
// Step 2: 通过 do_pick_order_line 找到相关的 do_pick_order
val doPickOrderLineRecords = pickOrderIds.flatMap { poId ->
val doPickOrderLineRecords = activePickOrderIds.flatMap { poId ->
doPickOrderLineRepository.findByPickOrderIdAndDeletedFalse(poId)
}
val doPickOrderIds = doPickOrderLineRecords.mapNotNull { it.doPickOrderId }.distinct()
if (doPickOrderIds.isEmpty()) {
println("❌ No do_pick_order found for pick orders: $pickOrderIds")
println("❌ No do_pick_order found for pick orders: $activePickOrderIds")
return mapOf(
"fgInfo" to null,
"pickOrders" to emptyList<Any>()
@@ -3665,11 +3666,22 @@ ORDER BY
val doPickOrderId = doPickOrder.id!!
println(" Using do_pick_order ID: $doPickOrderId")
// Step 4: 使用 Repository 加载 pick orders 及其关联数据
val pickOrders = pickOrderRepository.findAllById(pickOrderIds)
.filter { it.deleted == false }
// Step 4: 关键修改 - 只获取这个 do_pick_order 下的所有 pick orders（无论状态）
val allDoPickOrderLines = doPickOrderLineRepository.findByDoPickOrderIdAndDeletedFalse(doPickOrderId)
val allPickOrderIdsForThisTicket = allDoPickOrderLines.mapNotNull { it.pickOrderId }.distinct()
println(" Loaded ${pickOrders.size} pick orders")
println(" Found ${allPickOrderIdsForThisTicket.size} pick orders in this do_pick_order (including completed)")
// Step 5: 加载这些 pick orders（包括 COMPLETED 状态）
val pickOrders = pickOrderRepository.findAllById(allPickOrderIdsForThisTicket)
.filter {
it.deleted == false &&
it.assignTo?.id == userId && // 确保是分配给该用户的
it.type?.value == "do"
// 不限制状态，包括 COMPLETED
}
println(" Loaded ${pickOrders.size} pick orders (including completed)")
// 收集所有需要的数据
// 收集所有需要的数据
@@ -3780,6 +3792,7 @@ ORDER BY
"outQty" to ill.outQty,
"holdQty" to ill.holdQty,
"lotStatus" to ill.status?.value,
"stockInLineId" to il?.stockInLine?.id,
"lotAvailability" to when {
isExpired -> "expired"
stockOutLine?.status == "rejected" -> "rejected"
@@ -3866,6 +3879,7 @@ ORDER BY
"outQty" to ill.outQty,
"holdQty" to ill.holdQty,
"lotStatus" to ill.status?.value,
"stockInLineId" to il?.stockInLine?.id,
"lotAvailability" to when {
isExpired -> "expired"
sol.status == "rejected" -> "rejected"


+ 2
- 1
src/main/java/com/ffii/fpsms/modules/pickOrder/web/models/PickExecutionIssueRequest.kt View File

@@ -27,7 +27,8 @@ data class PickExecutionIssueRequest(
val badItemQty: BigDecimal = BigDecimal.ZERO,
val issueRemark: String? = null,
val pickerName: String? = null,
val handledBy: Long? = null
val handledBy: Long? = null,
val badReason: String? = null,
)




+ 3
- 0
src/main/java/com/ffii/fpsms/modules/stock/entity/InventoryLotLine.kt View File

@@ -45,6 +45,9 @@ open class InventoryLotLine : BaseEntity<Long>() {
@Column(name = "holdQty")
open var holdQty: BigDecimal? = null

@Column(name = "issueQty")
open var issueQty: BigDecimal? = null

@Convert(converter = InventoryLotLineStringConverter::class)
@Column(name = "status")
open var status: InventoryLotLineStatus? = null


+ 22
- 0
src/main/java/com/ffii/fpsms/modules/stock/entity/StockOutLIneRepository.kt View File

@@ -47,4 +47,26 @@ fun searchStockOutLines(

@Query("SELECT sol FROM StockOutLine sol WHERE sol.item.id IN :itemIds AND sol.deleted = false")
fun findAllByItemIdInAndDeletedFalse(itemIds: List<Long>): List<StockOutLine>


@Query("""
SELECT sol FROM StockOutLine sol
WHERE sol.pickOrderLine.id IN :pickOrderLineIds
AND sol.deleted = false
""")
fun findAllByPickOrderLineIdInAndDeletedFalse(
@Param("pickOrderLineIds") pickOrderLineIds: List<Long>
): List<StockOutLine>

// 添加批量查询方法：按 (pickOrderLineId, inventoryLotLineId) 组合查询
@Query("""
SELECT sol FROM StockOutLine sol
WHERE sol.pickOrderLine.id IN :pickOrderLineIds
AND sol.inventoryLotLine.id IN :inventoryLotLineIds
AND sol.deleted = false
""")
fun findAllByPickOrderLineIdInAndInventoryLotLineIdInAndDeletedFalse(
@Param("pickOrderLineIds") pickOrderLineIds: List<Long>,
@Param("inventoryLotLineIds") inventoryLotLineIds: List<Long>
): List<StockOutLine>
}

+ 409
- 363
src/main/java/com/ffii/fpsms/modules/stock/service/SuggestedPickLotService.kt View File

@@ -523,249 +523,301 @@ open class SuggestedPickLotService(
return null
}
}
@Transactional(rollbackFor = [Exception::class])
open fun resuggestPickOrder(pickOrderId: Long): MessageResponse {
try {
val pickOrder = pickOrderRepository.findById(pickOrderId).orElseThrow()
println("=== RESUGGEST DEBUG START ===")
println("Pick Order ID: $pickOrderId")
println("Pick Order Code: ${pickOrder.code}")
println("Pick Order Status: ${pickOrder.status}")
// NEW: Get ALL pick orders for the same items
val itemIds = pickOrder.pickOrderLines.mapNotNull { it.item?.id }.distinct()
println("Item IDs in current pick order: $itemIds")
val allCompetingPickOrders = mutableListOf<PickOrder>()
itemIds.forEach { itemId ->
val competingOrders = pickOrderLineRepository.findAllPickOrdersByItemId(itemId)
.filter { it.id != pickOrderId } // Exclude current pick order
println("Found ${competingOrders.size} competing pick orders for item $itemId")
competingOrders.forEach { order ->
println(" - Competing Order: ${order.code} (ID: ${order.id}, Status: ${order.status})")
}
allCompetingPickOrders.addAll(competingOrders)
@Transactional(rollbackFor = [Exception::class])
open fun resuggestPickOrder(pickOrderId: Long): MessageResponse {
try {
val pickOrder = pickOrderRepository.findById(pickOrderId).orElseThrow()
println("=== RESUGGEST DEBUG START ===")
println("Pick Order ID: $pickOrderId")
println("Pick Order Code: ${pickOrder.code}")
println("Pick Order Status: ${pickOrder.status}")
// NEW: Get ALL pick orders for the same items
val itemIds = pickOrder.pickOrderLines.mapNotNull { it.item?.id }.distinct()
println("Item IDs in current pick order: $itemIds")
val allCompetingPickOrders = mutableListOf<PickOrder>()
itemIds.forEach { itemId ->
val competingOrders = pickOrderLineRepository.findAllPickOrdersByItemId(itemId)
.filter { it.id != pickOrderId } // Exclude current pick order
println("Found ${competingOrders.size} competing pick orders for item $itemId")
competingOrders.forEach { order ->
println(" - Competing Order: ${order.code} (ID: ${order.id}, Status: ${order.status})")
}
// FIX: Only resuggest pick orders that have rejected stock out lines
val allPickOrdersToResuggest = (listOf(pickOrder) + allCompetingPickOrders)
.filter { pickOrderToCheck ->
// Only resuggest if the pick order has rejected stock out lines
pickOrderToCheck.pickOrderLines.any { pol ->
val stockOutLines = stockOutLIneRepository.findAllByPickOrderLineIdAndDeletedFalse(pol.id!!)
val hasRejectedStockOutLine = stockOutLines.any { it.status.equals("rejected", ignoreCase = true)}
if (hasRejectedStockOutLine) {
println("Pick Order ${pickOrderToCheck.code} has rejected stock out lines - will resuggest")
stockOutLines.filter { it.status == "rejected" }.forEach { sol ->
println(" - Rejected stock out line: ${sol.id} (lot: ${sol.inventoryLotLineId}, qty: ${sol.qty})")
}
allCompetingPickOrders.addAll(competingOrders)
}
// OPTIMIZATION 3: 批量收集所有需要检查的 pick order line IDs
val allPickOrderLineIdsToCheck = (listOf(pickOrder) + allCompetingPickOrders)
.flatMap { it.pickOrderLines }
.mapNotNull { it.id }
.distinct()
println("Checking ${allPickOrderLineIdsToCheck.size} pick order lines for rejected stock out lines")
// OPTIMIZATION 3: 批量查询所有 stock out lines（一次查询代替 N*M 次查询）
// 注意：findAllByPickOrderLineIdInAndDeletedFalse 返回 List<StockOutLine>（实体类）
val allStockOutLines = if (allPickOrderLineIdsToCheck.isNotEmpty()) {
stockOutLIneRepository.findAllByPickOrderLineIdInAndDeletedFalse(allPickOrderLineIdsToCheck)
} else {
emptyList()
}
println("Found ${allStockOutLines.size} stock out lines in batch query (1 query instead of ${allPickOrderLineIdsToCheck.size} queries)")
// OPTIMIZATION 3: 按 pickOrderLineId 分组，便于后续查找
// 注意：StockOutLine 实体使用 pickOrderLine?.id，不是 pickOrderLineId
val stockOutLinesByPickOrderLineId = allStockOutLines
.groupBy { it.pickOrderLine?.id }
// FIX: Only resuggest pick orders that have rejected stock out lines
val allPickOrdersToResuggest = (listOf(pickOrder) + allCompetingPickOrders)
.filter { pickOrderToCheck ->
// Only resuggest if the pick order has rejected stock out lines
pickOrderToCheck.pickOrderLines.any { pol ->
// OPTIMIZATION 3: 从预加载的 Map 中获取，而不是查询数据库
val stockOutLines = stockOutLinesByPickOrderLineId[pol.id] ?: emptyList()
val hasRejectedStockOutLine = stockOutLines.any {
it.status?.equals("rejected", ignoreCase = true) == true
}
if (hasRejectedStockOutLine) {
println("Pick Order ${pickOrderToCheck.code} has rejected stock out lines - will resuggest")
stockOutLines.filter { it.status?.equals("rejected", ignoreCase = true) == true }.forEach { sol ->
println(" - Rejected stock out line: ${sol.id} (lot: ${sol.inventoryLotLine?.id}, qty: ${sol.qty})")
}
hasRejectedStockOutLine
}
hasRejectedStockOutLine
}
}
println("=== RESUGGEST DEBUG ===")
println("Original pick orders: ${(listOf(pickOrder) + allCompetingPickOrders).size}")
println("Filtered pick orders to resuggest: ${allPickOrdersToResuggest.size}")
println("Pick orders being resuggested: ${allPickOrdersToResuggest.map { "${it.code}(${it.status})" }}")
// FIX: Only resuggest if there are actually pick orders with rejected lots
if (allPickOrdersToResuggest.isEmpty()) {
println("No pick orders need resuggesting - no rejected lots found")
return MessageResponse(
id = pickOrderId,
name = "No resuggest needed",
code = "SUCCESS",
type = "resuggest",
message = "No pick orders have rejected lots, no resuggest needed",
errorPosition = null
)
}
// FIX: Get all pick order line IDs for the orders to resuggest
val allPickOrderLineIds = allPickOrdersToResuggest
.flatMap { it.pickOrderLines }
.mapNotNull { it.id }
println("All pick order line IDs to resuggest: $allPickOrderLineIds")
// FIX: Get all existing suggestions for these pick order lines
val allSuggestions = suggestedPickLotRepository.findAllByPickOrderLineIdIn(allPickOrderLineIds)
println("Found ${allSuggestions.size} existing suggestions")
// OPTIMIZATION 3: 批量查询所有相关的 stock out lines（用于检查 rejected 状态）
val allSuggestionStockOutLines = if (allSuggestions.isNotEmpty()) {
val suggestionLineIds = allSuggestions.mapNotNull { it.pickOrderLine?.id }.distinct()
val suggestionLotIds = allSuggestions.mapNotNull { it.suggestedLotLine?.id }.distinct()
println("=== RESUGGEST DEBUG ===")
println("Original pick orders: ${(listOf(pickOrder) + allCompetingPickOrders).size}")
println("Filtered pick orders to resuggest: ${allPickOrdersToResuggest.size}")
println("Pick orders being resuggested: ${allPickOrdersToResuggest.map { "${it.code}(${it.status})" }}")
// FIX: Only resuggest if there are actually pick orders with rejected lots
if (allPickOrdersToResuggest.isEmpty()) {
println("No pick orders need resuggesting - no rejected lots found")
return MessageResponse(
id = pickOrderId,
name = "No resuggest needed",
code = "SUCCESS",
type = "resuggest",
message = "No pick orders have rejected lots, no resuggest needed",
errorPosition = null
// OPTIMIZATION 3: 使用批量查询方法（一次查询代替 N*M 次查询）
// 注意：返回 List<StockOutLine>（实体类）
if (suggestionLineIds.isNotEmpty() && suggestionLotIds.isNotEmpty()) {
stockOutLIneRepository.findAllByPickOrderLineIdInAndInventoryLotLineIdInAndDeletedFalse(
suggestionLineIds,
suggestionLotIds
)
} else {
emptyList()
}
// FIX: Get all pick order line IDs for the orders to resuggest
val allPickOrderLineIds = allPickOrdersToResuggest
.flatMap { it.pickOrderLines }
.mapNotNull { it.id }
println("All pick order line IDs to resuggest: $allPickOrderLineIds")
// FIX: Get all existing suggestions for these pick order lines
val allSuggestions = suggestedPickLotRepository.findAllByPickOrderLineIdIn(allPickOrderLineIds)
println("Found ${allSuggestions.size} existing suggestions")
// 删除第 376-395 行的旧代码，替换为：
// FIX: Separate suggestions to keep (those WITHOUT rejected stock out lines) and delete
val suggestionsToKeep = allSuggestions.filter { suggestion ->
val pickOrderLineId = suggestion.pickOrderLine?.id
val suggestedLotLineId = suggestion.suggestedLotLine?.id
if (pickOrderLineId != null && suggestedLotLineId != null) {
val stockOutLines = stockOutLIneRepository.findByPickOrderLineIdAndInventoryLotLineIdAndDeletedFalse(
pickOrderLineId,
suggestedLotLineId
)
// 保留没有 rejected stock out lines 的 suggestions
!stockOutLines.any { it.status == "rejected" }
} else {
true // 保留有问题的 suggestions 用于调试
}
}

// 只删除有 rejected stock out lines 的 suggestions
val suggestionsToDelete = allSuggestions.filter { suggestion ->
val pickOrderLineId = suggestion.pickOrderLine?.id
val suggestedLotLineId = suggestion.suggestedLotLine?.id
if (pickOrderLineId != null && suggestedLotLineId != null) {
val stockOutLines = stockOutLIneRepository.findByPickOrderLineIdAndInventoryLotLineIdAndDeletedFalse(
pickOrderLineId,
suggestedLotLineId
)
stockOutLines.any { it.status == "rejected" } // 只删除 rejected 的
} else {
suggestedLotLineId == null
}
}
} else {
emptyList()
}
println("Found ${allSuggestionStockOutLines.size} stock out lines for suggestions in batch query (1 query instead of ${allSuggestions.size} queries)")
// OPTIMIZATION 3: 按 (pickOrderLineId, inventoryLotLineId) 分组
// 注意：StockOutLine 实体使用 pickOrderLine?.id 和 inventoryLotLine?.id
val stockOutLinesByLineAndLot = allSuggestionStockOutLines
.groupBy {
val lineId = it.pickOrderLine?.id
val lotId = it.inventoryLotLine?.id
lineId to lotId
}
// FIX: Separate suggestions to keep (those WITHOUT rejected stock out lines) and delete
val suggestionsToKeep = allSuggestions.filter { suggestion ->
val pickOrderLineId = suggestion.pickOrderLine?.id
val suggestedLotLineId = suggestion.suggestedLotLine?.id
println("Suggestions to keep (with rejected stock out lines): ${suggestionsToKeep.size}")
println("Suggestions to delete: ${suggestionsToDelete.size}")
// FIX: Clear holdQty ONLY for lots that have rejected stock out lines
val rejectedLotIds = suggestionsToDelete.mapNotNull { it.suggestedLotLine?.id }.distinct()
println("Rejected lot IDs (clearing holdQty only): $rejectedLotIds")
rejectedLotIds.forEach { lotId ->
val lot = inventoryLotLineRepository.findById(lotId).orElse(null)
lot?.let {
val originalHoldQty = it.holdQty ?: BigDecimal.ZERO
it.holdQty = BigDecimal.ZERO
inventoryLotLineRepository.save(it)
println("Cleared holdQty for rejected lot ${lot.id}: $originalHoldQty -> 0")
}
if (pickOrderLineId != null && suggestedLotLineId != null) {
// OPTIMIZATION 3: 从预加载的 Map 中获取
val stockOutLines = stockOutLinesByLineAndLot[pickOrderLineId to suggestedLotLineId] ?: emptyList()
// 保留没有 rejected stock out lines 的 suggestions
!stockOutLines.any { it.status?.equals("rejected", ignoreCase = true) == true }
} else {
true // 保留有问题的 suggestions 用于调试
}
}

println("Keeping all suggestions (including rejected ones for display)")
// NEW: Build holdQtyMap with existing holdQty from other pick orders
val existingHoldQtyMap = mutableMapOf<Long?, BigDecimal?>()
// 只删除有 rejected stock out lines 的 suggestions
val suggestionsToDelete = allSuggestions.filter { suggestion ->
val pickOrderLineId = suggestion.pickOrderLine?.id
val suggestedLotLineId = suggestion.suggestedLotLine?.id
// Get all lots that are being used by other pick orders (including those NOT being resuggested)
val allOtherPickOrderLineIds = allCompetingPickOrders
.flatMap { it.pickOrderLines }
.mapNotNull { it.id }
println("Other pick order line IDs: $allOtherPickOrderLineIds")
if (pickOrderLineId != null && suggestedLotLineId != null) {
// OPTIMIZATION 3: 从预加载的 Map 中获取
val stockOutLines = stockOutLinesByLineAndLot[pickOrderLineId to suggestedLotLineId] ?: emptyList()
stockOutLines.any { it.status?.equals("rejected", ignoreCase = true) == true } // 只删除 rejected 的
} else {
suggestedLotLineId == null
}
}
println("Suggestions to keep: ${suggestionsToKeep.size}")
println("Suggestions to delete: ${suggestionsToDelete.size}")
// FIX: Clear holdQty ONLY for lots that have rejected stock out lines
val rejectedLotIds = suggestionsToDelete.mapNotNull { it.suggestedLotLine?.id }.distinct()
println("Rejected lot IDs (clearing holdQty only): $rejectedLotIds")
// OPTIMIZATION 3: 批量加载和更新 lots
val rejectedLots = if (rejectedLotIds.isNotEmpty()) {
inventoryLotLineRepository.findAllById(rejectedLotIds)
} else {
emptyList()
}
rejectedLots.forEach { lot ->
val originalHoldQty = lot.holdQty ?: BigDecimal.ZERO
lot.holdQty = BigDecimal.ZERO
println("Cleared holdQty for rejected lot ${lot.id}: $originalHoldQty -> 0")
}
if (rejectedLots.isNotEmpty()) {
inventoryLotLineRepository.saveAll(rejectedLots)
println("Batch cleared holdQty for ${rejectedLots.size} rejected lots")
}

println("Keeping all suggestions (including rejected ones for display)")
// NEW: Build holdQtyMap with existing holdQty from other pick orders
val existingHoldQtyMap = mutableMapOf<Long?, BigDecimal?>()
// Get all lots that are being used by other pick orders (including those NOT being resuggested)
val allOtherPickOrderLineIds = allCompetingPickOrders
.flatMap { it.pickOrderLines }
.mapNotNull { it.id }
println("Other pick order line IDs: $allOtherPickOrderLineIds")
if (allOtherPickOrderLineIds.isNotEmpty()) {
val otherSuggestions = suggestedPickLotRepository.findAllByPickOrderLineIdIn(allOtherPickOrderLineIds)
println("Found ${otherSuggestions.size} other suggestions")
if (allOtherPickOrderLineIds.isNotEmpty()) {
val otherSuggestions = suggestedPickLotRepository.findAllByPickOrderLineIdIn(allOtherPickOrderLineIds)
println("Found ${otherSuggestions.size} other suggestions")
otherSuggestions.forEach { suggestion ->
val lotId = suggestion.suggestedLotLine?.id
val qty = suggestion.qty
otherSuggestions.forEach { suggestion ->
val lotId = suggestion.suggestedLotLine?.id
val qty = suggestion.qty
println("Processing other suggestion ${suggestion.id}: lotId=$lotId, qty=$qty")
if (lotId != null && qty != null) {
val currentHoldQty = existingHoldQtyMap[lotId] ?: BigDecimal.ZERO
val newHoldQty = currentHoldQty.plus(qty)
existingHoldQtyMap[lotId] = newHoldQty
println(" Updated holdQty for lot $lotId: $currentHoldQty + $qty = $newHoldQty")
}
if (lotId != null && qty != null) {
val currentHoldQty = existingHoldQtyMap[lotId] ?: BigDecimal.ZERO
val newHoldQty = currentHoldQty.plus(qty)
existingHoldQtyMap[lotId] = newHoldQty
}
}
}
println("Final existing holdQtyMap: $existingHoldQtyMap")
// FIX: Create new suggestions for all pick orders to resuggest
allPickOrdersToResuggest.forEach { pickOrderToResuggest ->
// 只获取有 rejected stock out lines 的 pick order lines
// OPTIMIZATION 3: 使用预加载的 Map
val problematicPickOrderLines = pickOrderToResuggest.pickOrderLines.filter { pol ->
val stockOutLines = stockOutLinesByPickOrderLineId[pol.id] ?: emptyList()
stockOutLines.any { it.status?.equals("rejected", ignoreCase = true) == true }
}
println("Final existing holdQtyMap: $existingHoldQtyMap")
// FIX: Create new suggestions for all pick orders to resuggest
allPickOrdersToResuggest.forEach { pickOrderToResuggest ->
// 只获取有 rejected stock out lines 的 pick order lines
val problematicPickOrderLines = pickOrderToResuggest.pickOrderLines.filter { pol ->
val stockOutLines = stockOutLIneRepository.findAllByPickOrderLineIdAndDeletedFalse(pol.id!!)
stockOutLines.any { it.status == "rejected" }
}
if (problematicPickOrderLines.isNotEmpty()) {
println("=== Creating new suggestions for pick order: ${pickOrderToResuggest.code} ===")
if (problematicPickOrderLines.isNotEmpty()) {
println("=== Creating new suggestions for pick order: ${pickOrderToResuggest.code} ===")
// 调用 suggestionForPickOrderLines 生成新的 suggestions
val request = SuggestedPickLotForPolRequest(
pickOrderLines = problematicPickOrderLines,
holdQtyMap = existingHoldQtyMap.toMutableMap()
)
val response = suggestionForPickOrderLines(request)
println("Generated ${response.suggestedList.size} new suggestions")
response.suggestedList.forEach { suggestion ->
println(" - Suggestion: lotId=${suggestion.suggestedLotLine?.id}, qty=${suggestion.qty}")
}
// 调用 suggestionForPickOrderLines 生成新的 suggestions
val request = SuggestedPickLotForPolRequest(
pickOrderLines = problematicPickOrderLines,
holdQtyMap = existingHoldQtyMap.toMutableMap()
)
val response = suggestionForPickOrderLines(request)
println("Generated ${response.suggestedList.size} new suggestions")
if (response.suggestedList.isNotEmpty()) {
println("Saving ${response.suggestedList.size} new suggestions")
if (response.suggestedList.isNotEmpty()) {
println("Saving ${response.suggestedList.size} new suggestions")
// 获取现有的 pending/checked 状态的 suggestions（可以更新的）
// 获取现有的 pending/checked 状态的 suggestions（可以更新的）
val existingUpdatableSuggestions = suggestionsToKeep
.filter { it.suggestedLotLine?.id != null }
.groupBy { it.pickOrderLine?.id to it.suggestedLotLine?.id }
.mapValues { it.value.first() } // 每个 (lineId, lotId) 只取第一个
.filter { it.suggestedLotLine?.id != null }
.groupBy { it.pickOrderLine?.id to it.suggestedLotLine?.id }
.mapValues { it.value.first() } // 每个 (lineId, lotId) 只取第一个

// 处理新的 suggestions：更新现有的或创建新的
val suggestionsToSave = response.suggestedList.mapNotNull { newSugg ->
val key = newSugg.pickOrderLine?.id to newSugg.suggestedLotLine?.id
val lineId = newSugg.pickOrderLine?.id
val lotId = newSugg.suggestedLotLine?.id
val key = newSugg.pickOrderLine?.id to newSugg.suggestedLotLine?.id
val lineId = newSugg.pickOrderLine?.id
val lotId = newSugg.suggestedLotLine?.id

if (lineId != null && lotId != null) {
// 检查这个 lot 是否已有 suggestion
val existingSugg = existingUpdatableSuggestions[key]
if (existingSugg != null) {
// 检查现有 suggestion 的 stock_out_line 状态
val stockOutLines = stockOutLIneRepository.findByPickOrderLineIdAndInventoryLotLineIdAndDeletedFalse(
lineId, lotId
)
if (lineId != null && lotId != null) {
// 检查这个 lot 是否已有 suggestion
val existingSugg = existingUpdatableSuggestions[key]
val canUpdate = stockOutLines.isEmpty() || stockOutLines.all {
it.status == "pending" || it.status == "checked" || it.status == "partially_completed"
if (existingSugg != null) {
// OPTIMIZATION 3: 从预加载的 Map 中获取
val stockOutLines = stockOutLinesByLineAndLot[lineId to lotId] ?: emptyList()
val canUpdate = stockOutLines.isEmpty() || stockOutLines.all {
val status = it.status?.lowercase()
status == "pending" || status == "checked" || status == "partially_completed"
}
if (canUpdate) {
// Case 1: 更新现有的 suggestion
existingSugg.qty = newSugg.qty
existingSugg.modified = LocalDateTime.now()
existingSugg.modifiedBy = "system"
println("⚠️ Updated existing suggestion ${existingSugg.id} for lot $lotId: new qty=${newSugg.qty}")
existingSugg
} else {
// Case 2: 已完成/拒绝，跳过（不更新，也不创建新的）
val firstStatus = stockOutLines.firstOrNull()?.status ?: "unknown"
println("⏭️ Skipping lot $lotId - already $firstStatus")
null
}
} else {
// 没有现有的 suggestion，创建新的
newSugg
}
} else if (lotId == null) {
// lotId=null：检查是否已有 resuggest_issue
val existingResuggestIssues = pickExecutionIssueRepository
.findByPickOrderLineIdAndDeletedFalse(lineId ?: 0L)
.filter { it.issueCategory.name == "resuggest_issue" }
if (canUpdate) {
// Case 1: 更新现有的 suggestion
existingSugg.qty = newSugg.qty
existingSugg.modified = LocalDateTime.now()
existingSugg.modifiedBy = "system"
println("⚠️ Updated existing suggestion ${existingSugg.id} for lot $lotId: new qty=${newSugg.qty}")
existingSugg
if (existingResuggestIssues.isEmpty()) {
newSugg // 创建新的 null suggestion（后续会创建 issue）
} else {
// Case 2: 已完成/拒绝，跳过（不更新，也不创建新的）
println("⏭️ Skipping lot $lotId - already ${stockOutLines.first().status}")
null
println("⏭️ Resuggest issue already exists for line $lineId, skipping null suggestion")
null // 跳过，避免创建重复的 resuggest_issue
}
} else {
// 没有现有的 suggestion，创建新的
newSugg
}
} else if (lotId == null) {
// lotId=null：检查是否已有 resuggest_issue
val existingResuggestIssues = pickExecutionIssueRepository
.findByPickOrderLineIdAndDeletedFalse(lineId ?: 0L)
.filter { it.issueCategory.name == "resuggest_issue" }
if (existingResuggestIssues.isEmpty()) {
newSugg // 创建新的 null suggestion（后续会创建 issue）
} else {
println("⏭️ Resuggest issue already exists for line $lineId, skipping null suggestion")
null // 跳过，避免创建重复的 resuggest_issue
}
} else {
newSugg
}
}.filterNotNull()

val updatedSuggestions = suggestionsToSave.filter { it.id != null } // 有 id 的是更新的
@@ -789,175 +841,169 @@ println("Keeping all suggestions (including rejected ones for display)")

val savedSuggestions = allSavedSuggestions
println("Saved/Updated ${savedSuggestions.size} suggestions")
// 为每个新 suggestion 创建 stock out line 或 issue
savedSuggestions.forEach { suggestion ->
if (suggestion.suggestedLotLine != null) {
val isNewSuggestion = response.suggestedList.any {
it.pickOrderLine?.id == suggestion.pickOrderLine?.id &&
it.suggestedLotLine?.id == suggestion.suggestedLotLine?.id &&
it.id == null // 新的 suggestion 还没有 id
}
val stockOutLine = createStockOutLineForSuggestion(suggestion, pickOrderToResuggest)
if (stockOutLine != null) {
println(" Created stock out line ${stockOutLine.id} for suggestion ${suggestion.id}")
}
} else {
// 如果 lot 是 null，表示没有可用的 lot，创建 resuggest_issue
println("❌ No available lot for pick order line ${suggestion.pickOrderLine?.id}, creating resuggest_issue")
val pickOrderLine = suggestion.pickOrderLine
if (pickOrderLine != null) {
// 获取这个 line 的 rejected stock out lines
val rejectedStockOutLines = stockOutLIneRepository
.findAllByPickOrderLineIdAndDeletedFalse(pickOrderLine.id!!)
.filter { it.status == "rejected" }
println("Rejected stock out lines: ${rejectedStockOutLines.size}")
// 修复：只创建一个 resuggest_issue（如果有 rejected lines）
if (rejectedStockOutLines.isNotEmpty()) {
println("Creating resuggest failure issue")
createResuggestFailureIssue(
pickOrder = pickOrderToResuggest,
pickOrderLine = pickOrderLine,
rejectedStockOutLine = rejectedStockOutLines.first()
)
}
println("Creating stock out line for suggestion")
//createStockOutLineForSuggestion(suggestion, pickOrderToResuggest)
println("Stock out line created")
}
// 为每个新 suggestion 创建 stock out line 或 issue
savedSuggestions.forEach { suggestion ->
if (suggestion.suggestedLotLine != null) {
val isNewSuggestion = response.suggestedList.any {
it.pickOrderLine?.id == suggestion.pickOrderLine?.id &&
it.suggestedLotLine?.id == suggestion.suggestedLotLine?.id &&
it.id == null // 新的 suggestion 还没有 id
}
}
// 更新 holdQty
response.holdQtyMap.forEach { (lotId, newHoldQty) ->
if (lotId != null && newHoldQty != null && newHoldQty > BigDecimal.ZERO) {
val lot = inventoryLotLineRepository.findById(lotId).orElse(null)
lot?.let {
val currentHoldQty = it.holdQty ?: BigDecimal.ZERO
val existingHoldQty = existingHoldQtyMap[lotId] ?: BigDecimal.ZERO
val additionalHoldQty = newHoldQty.minus(existingHoldQty)
val finalHoldQty = currentHoldQty.plus(additionalHoldQty)
it.holdQty = finalHoldQty
inventoryLotLineRepository.save(it)
existingHoldQtyMap[lotId] = newHoldQty
println("Updated holdQty for lot $lotId: $currentHoldQty + $additionalHoldQty = $finalHoldQty")
}
val stockOutLine = createStockOutLineForSuggestion(suggestion, pickOrderToResuggest)
if (stockOutLine != null) {
println(" Created stock out line ${stockOutLine.id} for suggestion ${suggestion.id}")
}
}
} else {
// 如果完全没有生成任何 suggestions
println("No suggestions generated at all for pick order: ${pickOrderToResuggest.code}")
problematicPickOrderLines.forEach { pickOrderLine ->
val rejectedStockOutLines = stockOutLIneRepository
.findAllByPickOrderLineIdAndDeletedFalse(pickOrderLine.id!!)
.filter { it.status == "rejected" }
} else {
// 如果 lot 是 null，表示没有可用的 lot，创建 resuggest_issue
println("❌ No available lot for pick order line ${suggestion.pickOrderLine?.id}, creating resuggest_issue")
if (rejectedStockOutLines.isNotEmpty()) {
rejectedStockOutLines.forEach { rejectedLine ->
val pickOrderLine = suggestion.pickOrderLine
if (pickOrderLine != null) {
// OPTIMIZATION 3: 从预加载的 Map 中获取
val rejectedStockOutLines = stockOutLinesByPickOrderLineId[pickOrderLine.id]
?.filter { it.status?.equals("rejected", ignoreCase = true) == true } ?: emptyList()
println("Rejected stock out lines: ${rejectedStockOutLines.size}")
// 修复：只创建一个 resuggest_issue（如果有 rejected lines）
if (rejectedStockOutLines.isNotEmpty()) {
println("Creating resuggest failure issue")
// 注意：rejectedStockOutLines 是 List<StockOutLine>，需要转换为合适的类型
val firstRejectedLine = rejectedStockOutLines.first()
createResuggestFailureIssue(
pickOrder = pickOrderToResuggest,
pickOrderLine = pickOrderLine,
rejectedStockOutLine = rejectedLine
rejectedStockOutLine = firstRejectedLine
)
}
}


}
}
// 更新 holdQty
response.holdQtyMap.forEach { (lotId, newHoldQty) ->
if (lotId != null && newHoldQty != null && newHoldQty > BigDecimal.ZERO) {
val lot = inventoryLotLineRepository.findById(lotId).orElse(null)
lot?.let {
val currentHoldQty = it.holdQty ?: BigDecimal.ZERO
val existingHoldQty = existingHoldQtyMap[lotId] ?: BigDecimal.ZERO
val additionalHoldQty = newHoldQty.minus(existingHoldQty)
val finalHoldQty = currentHoldQty.plus(additionalHoldQty)
it.holdQty = finalHoldQty
inventoryLotLineRepository.save(it)
existingHoldQtyMap[lotId] = newHoldQty
println("Updated holdQty for lot $lotId: $currentHoldQty + $additionalHoldQty = $finalHoldQty")
}
}
}
} else {
// 如果完全没有生成任何 suggestions
println("No suggestions generated at all for pick order: ${pickOrderToResuggest.code}")
problematicPickOrderLines.forEach { pickOrderLine ->
// OPTIMIZATION 3: 从预加载的 Map 中获取
val rejectedStockOutLines = stockOutLinesByPickOrderLineId[pickOrderLine.id]
?.filter { it.status?.equals("rejected", ignoreCase = true) == true } ?: emptyList()
if (rejectedStockOutLines.isNotEmpty()) {
rejectedStockOutLines.forEach { rejectedLine ->
createResuggestFailureIssue(
pickOrder = pickOrderToResuggest,
pickOrderLine = pickOrderLine,
rejectedStockOutLine = rejectedLine
)
}
}
}
}
}
// FIX: Update inventory table for each pick order
allPickOrdersToResuggest.forEach { pickOrderToUpdate ->
println("=== Updating inventory table for pick order: ${pickOrderToUpdate.code} ===")
updateInventoryTableAfterResuggest(pickOrderToUpdate)
}
println("=== RESUGGEST DEBUG END ===")
return MessageResponse(
id = pickOrderId,
name = "Pick order resuggested successfully",
code = "SUCCESS",
type = "resuggest",
message = "Resuggested ${allPickOrdersToResuggest.size} pick orders",
errorPosition = null
)
} catch (e: Exception) {
println("Error in resuggestPickOrder: ${e.message}")
e.printStackTrace()
return MessageResponse(
id = null,
name = "Failed to resuggest pick order",
code = "ERROR",
type = "resuggest",
message = "Error: ${e.message}",
errorPosition = null
)
}
// FIX: Update inventory table for each pick order
allPickOrdersToResuggest.forEach { pickOrderToUpdate ->
println("=== Updating inventory table for pick order: ${pickOrderToUpdate.code} ===")
updateInventoryTableAfterResuggest(pickOrderToUpdate)
}
println("=== RESUGGEST DEBUG END ===")
return MessageResponse(
id = pickOrderId,
name = "Pick order resuggested successfully",
code = "SUCCESS",
type = "resuggest",
message = "Resuggested ${allPickOrdersToResuggest.size} pick orders",
errorPosition = null
)
} catch (e: Exception) {
println("Error in resuggestPickOrder: ${e.message}")
e.printStackTrace()
return MessageResponse(
id = null,
name = "Failed to resuggest pick order",
code = "ERROR",
type = "resuggest",
message = "Error: ${e.message}",
errorPosition = null
)
}
}


private fun createResuggestFailureIssue(
pickOrder: PickOrder,
pickOrderLine: PickOrderLine,
rejectedStockOutLine: StockOutLineInfo // 使用 StockOutLineInfo
) {
try {
val item = pickOrderLine.item
// 从 StockOutLineInfo 获取 inventoryLotLineId
val inventoryLotLineId = rejectedStockOutLine.inventoryLotLineId
val inventoryLotLine = if (inventoryLotLineId != null) {
inventoryLotLineRepository.findById(inventoryLotLineId).orElse(null)
} else {
null
}
val issue = PickExecutionIssue(
id = null,
pickOrderId = pickOrder.id!!,
pickOrderCode = pickOrder.code!!,
pickOrderCreateDate = pickOrder.created?.toLocalDate(),
pickExecutionDate = LocalDate.now(),
pickOrderLineId = pickOrderLine.id!!,
issueNo = generateIssueNo(),
joPickOrderId=pickOrder.jobOrder?.id,
doPickOrderId=pickOrder.deliveryOrder?.id,
issueCategory = IssueCategory.resuggest_issue,
itemId = item?.id!!,
itemCode = item.code,
itemDescription = item.name,
lotId = inventoryLotLine?.id,
lotNo = inventoryLotLine?.inventoryLot?.lotNo,
storeLocation = inventoryLotLine?.warehouse?.code,
requiredQty = pickOrderLine.qty,
actualPickQty = rejectedStockOutLine.qty ?: BigDecimal.ZERO, // 直接使用，不需要 toBigDecimal()
missQty = (pickOrderLine.qty ?: BigDecimal.ZERO).minus(rejectedStockOutLine.qty ?: BigDecimal.ZERO), // 直接使用
badItemQty = BigDecimal.ZERO,
issueRemark = "Resuggest failed: No alternative lots available for rejected lot ${inventoryLotLine?.inventoryLot?.lotNo}",
pickerName = null,
handleStatus = HandleStatus.pending,
handleDate = null,
handledBy = null,
created = LocalDateTime.now(),
createdBy = "system",
version = 0,
modified = LocalDateTime.now(),
modifiedBy = "system",
deleted = false
)
pickExecutionIssueRepository.save(issue)
println(" Created resuggest_issue: ${issue.issueNo} for pick order ${pickOrder.code}")
} catch (e: Exception) {
println("❌ Error creating resuggest_issue: ${e.message}")
e.printStackTrace()
}
private fun createResuggestFailureIssue(
pickOrder: PickOrder,
pickOrderLine: PickOrderLine,
rejectedStockOutLine: StockOutLine // 改为 StockOutLine
) {
try {
val item = pickOrderLine.item
// 从 StockOutLine 获取 inventoryLotLineId
val inventoryLotLine = rejectedStockOutLine.inventoryLotLine
val inventoryLotLineId = inventoryLotLine?.id
val issue = PickExecutionIssue(
id = null,
pickOrderId = pickOrder.id!!,
pickOrderCode = pickOrder.code!!,
pickOrderCreateDate = pickOrder.created?.toLocalDate(),
pickExecutionDate = LocalDate.now(),
pickOrderLineId = pickOrderLine.id!!,
issueNo = generateIssueNo(),
joPickOrderId = pickOrder.jobOrder?.id,
doPickOrderId = pickOrder.deliveryOrder?.id,
issueCategory = IssueCategory.resuggest_issue,
itemId = item?.id!!,
itemCode = item.code,
itemDescription = item.name,
lotId = inventoryLotLineId,
lotNo = inventoryLotLine?.inventoryLot?.lotNo,
storeLocation = inventoryLotLine?.warehouse?.code,
requiredQty = pickOrderLine.qty,
actualPickQty = rejectedStockOutLine.qty?.let { BigDecimal.valueOf(it) } ?: BigDecimal.ZERO,
missQty = (pickOrderLine.qty ?: BigDecimal.ZERO).minus(
rejectedStockOutLine.qty?.let { BigDecimal.valueOf(it) } ?: BigDecimal.ZERO
),
badItemQty = BigDecimal.ZERO,
issueRemark = "Resuggest failed: No alternative lots available for rejected lot ${inventoryLotLine?.inventoryLot?.lotNo}",
pickerName = null,
handleStatus = HandleStatus.pending,
handleDate = null,
handledBy = null,
created = LocalDateTime.now(),
createdBy = "system",
version = 0,
modified = LocalDateTime.now(),
modifiedBy = "system",
deleted = false
)
val savedIssue = pickExecutionIssueRepository.save(issue)
println(" Created resuggest_issue: ${savedIssue.issueNo} for pick order ${pickOrder.code}")
} catch (e: Exception) {
println("❌ Error creating resuggest_issue: ${e.message}")
e.printStackTrace()
}
}
private fun generateIssueNo(): String {
val now = LocalDateTime.now()
val yearMonth = now.format(DateTimeFormatter.ofPattern("yyMM"))


+ 5
- 0
src/main/resources/db/changelog/changes/20260122_01_Enson/01_alter_table.sql View File

@@ -0,0 +1,5 @@
--liquibase formatted sql
--changeset author:add_time_fields_to_productprocessline

ALTER TABLE `inventory_lot_line`
ADD COLUMN `issueQty` DECIMAL(18,2) NULL AFTER `holdQty`;

Write Preview
Loading…
Cancel
Save