414 lines
13 KiB
TypeScript
414 lines
13 KiB
TypeScript
import { DiscreteMaterialPlanDAO } from '../database/discrete-material-plan-dao'
|
|
import { MaterialsToBeDeletedDAO } from '../database/materials-to-be-deleted-dao'
|
|
import { SqlServerService } from '../database/sql-server'
|
|
import { createLogger } from '../logger'
|
|
import type {
|
|
MaterialRecordSummary,
|
|
ValidationRequest,
|
|
ValidationResponse,
|
|
ValidationResult
|
|
} from '../../types/validation.types'
|
|
import type { UserInfo } from '../../types/user.types'
|
|
import { getSourceNumbersFromInputs, readProductionIds } from './production-input-service'
|
|
import { sharedProductionIdsStore } from './shared-production-ids-store'
|
|
import {
|
|
createValidationDatabaseService,
|
|
getValidationTableName,
|
|
type ValidationDatabaseService
|
|
} from './validation-database'
|
|
|
|
const log = createLogger('ValidationApplicationService')
|
|
|
|
type TypeKeyword = {
|
|
materialName: string
|
|
managerName: string
|
|
}
|
|
|
|
export class ValidationApplicationService {
|
|
async validate(
|
|
request: ValidationRequest,
|
|
userInfo: UserInfo,
|
|
senderId: number
|
|
): Promise<ValidationResponse> {
|
|
let dbService: ValidationDatabaseService | null = null
|
|
|
|
try {
|
|
const isAdmin = userInfo.userType === 'Admin'
|
|
const username = userInfo.username
|
|
|
|
log.info('Starting validation', { mode: request.mode, user: username, isAdmin })
|
|
|
|
dbService = await createValidationDatabaseService()
|
|
|
|
let sourceNumbers: string[] | null = null
|
|
|
|
if (request.mode === 'database_filtered') {
|
|
if (request.useSharedProductionIds) {
|
|
const sharedIds = sharedProductionIdsStore.get(senderId)
|
|
log.info(`Using ${sharedIds.length} shared Production IDs`)
|
|
|
|
if (sharedIds.length === 0) {
|
|
return this.emptyFailure(
|
|
'没有可用的共享 Production ID。请在数据提取页面输入 Production ID。'
|
|
)
|
|
}
|
|
|
|
sourceNumbers = await getSourceNumbersFromInputs(sharedIds, dbService)
|
|
log.info(`Got ${sourceNumbers.length} source numbers from shared Production IDs`)
|
|
|
|
if (sourceNumbers.length === 0) {
|
|
return this.emptyFailure(
|
|
'共享的 Production ID 没有找到对应的订单数据。请确保在数据提取页面输入了有效的 Production ID 并成功获取了订单数据。'
|
|
)
|
|
}
|
|
} else if (request.productionIdFile) {
|
|
const inputs = readProductionIds(request.productionIdFile)
|
|
log.info(`Read ${inputs.length} inputs from file`)
|
|
|
|
sourceNumbers = await getSourceNumbersFromInputs(inputs, dbService)
|
|
log.info(`Got ${sourceNumbers.length} source numbers`)
|
|
|
|
if (sourceNumbers.length === 0) {
|
|
return this.emptyFailure(
|
|
'文件中的 Production ID 没有找到对应的订单数据。请检查 Production ID 是否正确，或确保数据库中有对应的订单数据。'
|
|
)
|
|
}
|
|
}
|
|
}
|
|
|
|
const materialDao = new DiscreteMaterialPlanDAO()
|
|
let materialRecords: any[] = []
|
|
|
|
if (request.mode === 'database_full') {
|
|
materialRecords = await materialDao.queryAllDistinctByMaterialCode()
|
|
} else if (sourceNumbers && sourceNumbers.length > 0) {
|
|
materialRecords = await materialDao.queryBySourceNumbersDistinct(sourceNumbers)
|
|
}
|
|
|
|
if (materialRecords.length === 0) {
|
|
return this.emptyFailure('未找到物料记录。请检查数据库中是否有对应订单的物料数据。')
|
|
}
|
|
|
|
const typeKeywords = await this.loadTypeKeywords(dbService)
|
|
const markedCodes = await this.loadMarkedCodes(dbService)
|
|
const results = this.buildValidationResults(materialRecords, typeKeywords, markedCodes, {
|
|
isAdmin,
|
|
username
|
|
})
|
|
|
|
const markedCount = results.filter((result) => result.isMarkedForDeletion).length
|
|
const matchedCount = results.filter((result) => result.managerName).length
|
|
|
|
return {
|
|
success: true,
|
|
results,
|
|
stats: {
|
|
totalRecords: results.length,
|
|
matchedCount,
|
|
markedCount
|
|
}
|
|
}
|
|
} catch (error) {
|
|
const message = error instanceof Error ? error.message : 'Unknown error'
|
|
log.error('Validation error', { error: message })
|
|
return {
|
|
success: false,
|
|
error: `Validation failed: ${message}`
|
|
}
|
|
} finally {
|
|
if (dbService) {
|
|
await this.disconnectQuietly(dbService)
|
|
}
|
|
}
|
|
}
|
|
|
|
async getMaterialsByManager(managerName: string): Promise<MaterialRecordSummary[]> {
|
|
const dao = new MaterialsToBeDeletedDAO()
|
|
const materials = await dao.getMaterialsByManager(managerName)
|
|
const markedCodes = await dao.getAllMaterialCodes()
|
|
return this.enrichMaterials(materials, markedCodes)
|
|
}
|
|
|
|
async getAllMaterials(): Promise<MaterialRecordSummary[]> {
|
|
const dao = new MaterialsToBeDeletedDAO()
|
|
const materials = await dao.getAllRecords()
|
|
const markedCodes = await dao.getAllMaterialCodes()
|
|
return this.enrichMaterials(materials, markedCodes)
|
|
}
|
|
|
|
async getCleanerData(
|
|
userInfo: UserInfo,
|
|
senderId: number
|
|
): Promise<{
|
|
success: boolean
|
|
orderNumbers?: string[]
|
|
materialCodes?: string[]
|
|
error?: string
|
|
}> {
|
|
let dbService: ValidationDatabaseService | null = null
|
|
|
|
try {
|
|
const isAdmin = userInfo.userType === 'Admin'
|
|
const username = userInfo.username
|
|
log.info(`User: ${username}, isAdmin: ${isAdmin}`)
|
|
|
|
dbService = await createValidationDatabaseService()
|
|
|
|
const sharedIds = sharedProductionIdsStore.get(senderId)
|
|
let orderNumbers: string[] = []
|
|
|
|
if (sharedIds.length > 0) {
|
|
log.info(`Using ${sharedIds.length} shared Production IDs`)
|
|
orderNumbers = await getSourceNumbersFromInputs(sharedIds, dbService)
|
|
log.info(`Got ${orderNumbers.length} order numbers`)
|
|
}
|
|
|
|
const materialCodes = await this.loadMaterialCodesForCleaner(dbService, username, isAdmin)
|
|
|
|
return {
|
|
success: true,
|
|
orderNumbers,
|
|
materialCodes
|
|
}
|
|
} catch (error) {
|
|
const message = error instanceof Error ? error.message : 'Unknown error'
|
|
log.error('CleanerData error', { error: message })
|
|
return {
|
|
success: false,
|
|
error: `获取清理数据失败：${message}`
|
|
}
|
|
} finally {
|
|
if (dbService) {
|
|
await this.disconnectQuietly(dbService)
|
|
}
|
|
}
|
|
}
|
|
|
|
private emptyFailure(error: string): ValidationResponse {
|
|
return {
|
|
success: false,
|
|
error,
|
|
stats: {
|
|
totalRecords: 0,
|
|
matchedCount: 0,
|
|
markedCount: 0
|
|
}
|
|
}
|
|
}
|
|
|
|
private async loadTypeKeywords(dbService: ValidationDatabaseService): Promise<TypeKeyword[]> {
|
|
const typeKeywordTableName = getValidationTableName('dbo_MaterialsTypeToBeDeleted')
|
|
const sql = `
|
|
SELECT MaterialName, ManagerName
|
|
FROM ${typeKeywordTableName}
|
|
WHERE MaterialName IS NOT NULL
|
|
`
|
|
const result = await dbService.query(sql)
|
|
return result.rows.map((row) => ({
|
|
materialName: row.MaterialName as string,
|
|
managerName: row.ManagerName as string
|
|
}))
|
|
}
|
|
|
|
private async loadMarkedCodes(
|
|
dbService: ValidationDatabaseService
|
|
): Promise<Map<string, string>> {
|
|
const markedTableName = getValidationTableName('dbo_MaterialsToBeDeleted')
|
|
const sql = `
|
|
SELECT MaterialCode, ManagerName
|
|
FROM ${markedTableName}
|
|
WHERE MaterialCode IS NOT NULL AND ManagerName IS NOT NULL
|
|
`
|
|
const result = await dbService.query(sql)
|
|
const markedCodes = new Map<string, string>()
|
|
|
|
for (const row of result.rows) {
|
|
markedCodes.set(row.MaterialCode as string, row.ManagerName as string)
|
|
}
|
|
|
|
return markedCodes
|
|
}
|
|
|
|
private buildValidationResults(
|
|
materialRecords: any[],
|
|
typeKeywords: TypeKeyword[],
|
|
markedCodes: Map<string, string>,
|
|
context: { isAdmin: boolean; username: string }
|
|
): ValidationResult[] {
|
|
return materialRecords.map((record) => {
|
|
const materialName = (record.MaterialName as string) || ''
|
|
const materialCode = (record.MaterialCode as string) || ''
|
|
const specification = (record.Specification as string) || ''
|
|
const model = (record.Model as string) || ''
|
|
|
|
let managerName = markedCodes.get(materialCode) || null
|
|
const isMarkedForDeletion = managerName !== null
|
|
let matchedTypeKeyword: string | undefined
|
|
|
|
if (!managerName) {
|
|
for (const typeKeyword of typeKeywords) {
|
|
if (typeKeyword.materialName && materialName.includes(typeKeyword.materialName)) {
|
|
matchedTypeKeyword = typeKeyword.materialName
|
|
managerName = typeKeyword.managerName
|
|
break
|
|
}
|
|
}
|
|
}
|
|
|
|
if (!context.isAdmin && context.username) {
|
|
const userKeywords = typeKeywords.filter(
|
|
(keyword) => keyword.managerName === context.username
|
|
)
|
|
for (const userKeyword of userKeywords) {
|
|
if (userKeyword.materialName && materialName.includes(userKeyword.materialName)) {
|
|
matchedTypeKeyword = userKeyword.materialName
|
|
managerName = userKeyword.managerName
|
|
break
|
|
}
|
|
}
|
|
}
|
|
|
|
return {
|
|
materialName,
|
|
materialCode,
|
|
specification,
|
|
model,
|
|
managerName: managerName || '',
|
|
isMarkedForDeletion,
|
|
matchedTypeKeyword
|
|
}
|
|
})
|
|
}
|
|
|
|
private async enrichMaterials(
|
|
materials: Array<{ materialCode: string; managerName: string }>,
|
|
markedCodes: Set<string>
|
|
): Promise<MaterialRecordSummary[]> {
|
|
let dbService: ValidationDatabaseService | null = null
|
|
|
|
try {
|
|
dbService = await createValidationDatabaseService()
|
|
const detailTableName = getValidationTableName('dbo_DiscreteMaterialPlanData')
|
|
const enrichedMaterials: MaterialRecordSummary[] = []
|
|
|
|
for (const material of materials) {
|
|
const detailResult = await this.queryMaterialDetail(
|
|
dbService,
|
|
detailTableName,
|
|
material.materialCode
|
|
)
|
|
const firstRow = detailResult.rows[0]
|
|
|
|
enrichedMaterials.push({
|
|
materialCode: material.materialCode,
|
|
materialName: firstRow ? (firstRow.MaterialName as string) : '',
|
|
specification: firstRow ? (firstRow.Specification as string) : '',
|
|
model: firstRow ? (firstRow.Model as string) : '',
|
|
managerName: material.managerName,
|
|
isMarked: markedCodes.has(material.materialCode)
|
|
})
|
|
}
|
|
|
|
return enrichedMaterials
|
|
} finally {
|
|
if (dbService) {
|
|
await this.disconnectQuietly(dbService)
|
|
}
|
|
}
|
|
}
|
|
|
|
private async queryMaterialDetail(
|
|
dbService: ValidationDatabaseService,
|
|
detailTableName: string,
|
|
materialCode: string
|
|
) {
|
|
if (dbService.type === 'sqlserver') {
|
|
const sql = await import('mssql')
|
|
return (dbService as SqlServerService).queryWithParams(
|
|
`
|
|
SELECT TOP 1 MaterialName, Specification, Model
|
|
FROM ${detailTableName}
|
|
WHERE MaterialCode = @materialCode
|
|
`,
|
|
{
|
|
materialCode: { value: materialCode, type: sql.default.NVarChar }
|
|
}
|
|
)
|
|
}
|
|
|
|
return dbService.query(
|
|
`
|
|
SELECT MaterialName, Specification, Model
|
|
FROM ${detailTableName}
|
|
WHERE MaterialCode = ?
|
|
LIMIT 1
|
|
`,
|
|
[materialCode]
|
|
)
|
|
}
|
|
|
|
private async loadMaterialCodesForCleaner(
|
|
dbService: ValidationDatabaseService,
|
|
username: string,
|
|
isAdmin: boolean
|
|
): Promise<string[]> {
|
|
const markedTableName = getValidationTableName('dbo_MaterialsToBeDeleted')
|
|
|
|
if (isAdmin) {
|
|
const result = await dbService.query(
|
|
`
|
|
SELECT MaterialCode
|
|
FROM ${markedTableName}
|
|
WHERE MaterialCode IS NOT NULL
|
|
`
|
|
)
|
|
const materialCodes = result.rows.map((row) => row.MaterialCode as string).filter(Boolean)
|
|
log.info(`Admin user: got ${materialCodes.length} materials`)
|
|
return materialCodes
|
|
}
|
|
|
|
if (dbService.type === 'sqlserver') {
|
|
const sql = await import('mssql')
|
|
const result = await (dbService as SqlServerService).queryWithParams(
|
|
`
|
|
SELECT MaterialCode
|
|
FROM ${markedTableName}
|
|
WHERE ManagerName = @username AND MaterialCode IS NOT NULL
|
|
`,
|
|
{
|
|
username: { value: username, type: sql.default.NVarChar }
|
|
}
|
|
)
|
|
const materialCodes = result.rows
|
|
.map((row: Record<string, unknown>) => row.MaterialCode as string)
|
|
.filter(Boolean)
|
|
log.info(`Regular user: got ${materialCodes.length} materials`)
|
|
return materialCodes
|
|
}
|
|
|
|
const result = await dbService.query(
|
|
`
|
|
SELECT MaterialCode
|
|
FROM ${markedTableName}
|
|
WHERE ManagerName = ? AND MaterialCode IS NOT NULL
|
|
`,
|
|
[username]
|
|
)
|
|
const materialCodes = result.rows.map((row) => row.MaterialCode as string).filter(Boolean)
|
|
log.info(`Regular user: got ${materialCodes.length} materials`)
|
|
return materialCodes
|
|
}
|
|
|
|
private async disconnectQuietly(dbService: ValidationDatabaseService): Promise<void> {
|
|
try {
|
|
await dbService.disconnect()
|
|
} catch (closeError) {
|
|
log.warn('Error disconnecting database', {
|
|
error: closeError instanceof Error ? closeError.message : String(closeError)
|
|
})
|
|
}
|
|
}
|
|
}
|
|
|
|
export const validationApplicationService = new ValidationApplicationService()
|