Merge remote-tracking branch 'origin/test' into test
# Conflicts: # deploy/sql/README.md
This commit is contained in:
+6
-3
@@ -16,6 +16,7 @@ import com.baiyue.lastleg.fleet.quote.FleetQuoteModels;
|
||||
import com.baiyue.lastleg.fleet.quote.FleetQuoteService;
|
||||
import com.baiyue.lastleg.fleet.reporting.TripOperationsModels;
|
||||
import com.baiyue.lastleg.fleet.reporting.TripOperationsService;
|
||||
import com.baiyue.lastleg.selfoperated.analytics.query.InventoryTurnoverExport;
|
||||
import com.fasterxml.jackson.databind.JsonNode;
|
||||
import com.fasterxml.jackson.databind.ObjectMapper;
|
||||
import jakarta.annotation.Resource;
|
||||
@@ -41,6 +42,7 @@ public class LastlegExportProviderService {
|
||||
@Resource private VehicleApplicationService vehicles;
|
||||
@Resource private FleetQuoteService fleetQuotes;
|
||||
@Resource private TripOperationsService operations;
|
||||
@Resource private InventoryTurnoverExport turnover;
|
||||
@Resource private ObjectMapper json;
|
||||
@Resource private Validator validator;
|
||||
@Value("${baiyue.security.internal-service-token}") private String signingKey;
|
||||
@@ -51,15 +53,16 @@ public class LastlegExportProviderService {
|
||||
}
|
||||
if (request.taskId() == null || request.requestedBy() == null || request.dispatchVersion() < 1
|
||||
|| request.limit() < 1 || request.limit() > 200) throw invalid("导出批次参数无效");
|
||||
List<ExportColumn> columns;
|
||||
try { columns = LastlegExportColumns.columns(type); }
|
||||
catch (IllegalArgumentException e) { throw invalid("不支持该导出类型"); }
|
||||
int offset = cursor(request.cursor());
|
||||
if (offset % request.limit() != 0) throw invalid("导出游标无效");
|
||||
String snapshot = signature(type, request);
|
||||
boolean first = request.snapshotToken() == null;
|
||||
if ((first && offset != 0) || (!first && !MessageDigest.isEqual(snapshot.getBytes(StandardCharsets.UTF_8),
|
||||
request.snapshotToken().getBytes(StandardCharsets.UTF_8)))) throw invalid("导出筛选快照不匹配");
|
||||
if (InventoryTurnoverExport.TYPE.equals(type)) return turnover.batch(request, offset, snapshot);
|
||||
List<ExportColumn> columns;
|
||||
try { columns = LastlegExportColumns.columns(type); }
|
||||
catch (IllegalArgumentException e) { throw invalid("不支持该导出类型"); }
|
||||
Map<String, Object> parameters = new TreeMap<>(request.parameters() == null ? Map.of() : request.parameters());
|
||||
String customer = text(parameters.remove("customerId"));
|
||||
if (customer != null && !customer.matches("[1-9][0-9]*")) throw invalid("客户参数无效");
|
||||
|
||||
+16
-1
@@ -33,6 +33,7 @@ import java.util.function.Function;
|
||||
public class RestLingxingAnalyticsClient implements LingxingAnalyticsClient {
|
||||
private static final String PREFIX = "/internal/integrations/lingxing/wms";
|
||||
private static final Set<String> PROVIDER_ERROR_CODES = Set.of(
|
||||
"LINGXING_WMS_FLOW_PERMISSION_DENIED",
|
||||
"LINGXING_WMS_AUTHORIZATION_REJECTED", "LINGXING_WMS_SIGNATURE_REJECTED",
|
||||
"LINGXING_WMS_SOURCE_REJECTED", "LINGXING_WMS_INVALID_RESPONSE", "LINGXING_WMS_RATE_LIMITED",
|
||||
"LINGXING_WMS_HTTP_RATE_LIMITED", "LINGXING_WMS_SOURCE_RATE_LIMITED",
|
||||
@@ -122,6 +123,19 @@ public class RestLingxingAnalyticsClient implements LingxingAnalyticsClient {
|
||||
quantity(n,"wmsLength"),quantity(n,"wmsWidth"),quantity(n,"wmsHeight"),optional(n,"wmsSizeUnit")));
|
||||
}
|
||||
|
||||
public JsonNode inventoryFlow(SelfopRequestContext context,String warehouse,String customer,String sku,
|
||||
LocalDateTime start,LocalDateTime end) {
|
||||
gate(context);argument(warehouse,64);argument(customer,64);argument(sku,128);
|
||||
return post(context,"/inventory-flow/query",Map.of("warehouseCode",warehouse,"customerCode",customer,"sku",sku,
|
||||
"startTime",DateTimeFormatter.ISO_LOCAL_DATE_TIME.format(start),"endTime",DateTimeFormatter.ISO_LOCAL_DATE_TIME.format(end)));
|
||||
}
|
||||
|
||||
public JsonNode inventoryFlowPage(SelfopRequestContext context,String warehouse,LocalDateTime start,LocalDateTime end,int current,int size) {
|
||||
gate(context);argument(warehouse,64);paging(current,size,1000);
|
||||
return post(context,"/inventory-flow-page/query",Map.of("warehouseCode",warehouse,"startTime",DateTimeFormatter.ISO_LOCAL_DATE_TIME.format(start),
|
||||
"endTime",DateTimeFormatter.ISO_LOCAL_DATE_TIME.format(end),"current",current,"size",size));
|
||||
}
|
||||
|
||||
private Summary summary(String account, JsonNode n) {
|
||||
List<SelfopPayloads.Item> items = null;
|
||||
JsonNode products = n.get("productList");
|
||||
@@ -160,9 +174,10 @@ public class RestLingxingAnalyticsClient implements LingxingAnalyticsClient {
|
||||
case "/product-inventory/query" -> Operation.PRODUCT_INVENTORY;
|
||||
case "/customers/query" -> Operation.CUSTOMERS;
|
||||
case "/products/query" -> Operation.PRODUCTS;
|
||||
case "/inventory-flow/query", "/inventory-flow-page/query" -> Operation.INVENTORY_FLOW;
|
||||
default -> throw failure("EGRESS_OPERATION_INVALID");
|
||||
};
|
||||
int size = fields.containsKey("size") ? ((Number)fields.get("size")).intValue() : 0;
|
||||
int size = fields.containsKey("size") ? ((Number)fields.get("size")).intValue() : op==Operation.INVENTORY_FLOW?1000:0;
|
||||
String warehouse=(String)fields.get("warehouseCode");
|
||||
String key=op==Operation.OUTBOUND_DETAIL ? SelfopSupport.json(List.of(fields.get("customerCode"),fields.get("deliveryNo"))) : null;
|
||||
var permission = egress.reserve(context,op,size,warehouse,key,SelfopSupport.hash(fields));
|
||||
|
||||
+23
@@ -0,0 +1,23 @@
|
||||
package com.baiyue.lastleg.selfoperated.analytics.controller;
|
||||
import com.baiyue.common.core.api.ApiResponse;
|
||||
import com.baiyue.common.security.AuthenticatedUser;
|
||||
import com.baiyue.lastleg.selfoperated.analytics.sync.InventoryFlowProbeService;
|
||||
import org.springframework.web.bind.annotation.*;
|
||||
import org.springframework.security.access.prepost.PreAuthorize;
|
||||
import org.springframework.security.core.annotation.AuthenticationPrincipal;
|
||||
import org.springframework.web.server.ResponseStatusException;
|
||||
import org.springframework.http.HttpStatus;
|
||||
@RestController
|
||||
@RequestMapping("/api/platform/v1/last-leg/self-operated-analytics/inventory-flow-probe")
|
||||
public class PlatformInventoryFlowProbeController {
|
||||
private final InventoryFlowProbeService service;
|
||||
public PlatformInventoryFlowProbeController(InventoryFlowProbeService service){this.service=service;}
|
||||
@PostMapping
|
||||
@PreAuthorize("hasAuthority('platform:self-operated-analytics:sync')")
|
||||
public ApiResponse<InventoryFlowProbeService.Result> probe(@AuthenticationPrincipal AuthenticatedUser user,
|
||||
@RequestBody InventoryFlowProbeService.Request request) {
|
||||
if(user==null||!Long.valueOf(0).equals(user.tenantId())||!"PLATFORM".equals(user.appCode())||user.impersonated()
|
||||
||!user.permissions().contains("platform:self-operated-analytics:sync"))throw new ResponseStatusException(HttpStatus.FORBIDDEN);
|
||||
return ApiResponse.success(service.probe(request,user.username()));
|
||||
}
|
||||
}
|
||||
+121
@@ -0,0 +1,121 @@
|
||||
package com.baiyue.lastleg.selfoperated.analytics.history;
|
||||
|
||||
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
|
||||
import com.baomidou.mybatisplus.core.toolkit.IdWorker;
|
||||
import com.baiyue.lastleg.selfoperated.analytics.client.*;
|
||||
import com.baiyue.lastleg.selfoperated.analytics.mapper.*;
|
||||
import com.baiyue.lastleg.selfoperated.analytics.model.*;
|
||||
import com.baiyue.lastleg.selfoperated.analytics.request.*;
|
||||
import com.baiyue.lastleg.selfoperated.analytics.sync.SelfopLeaseService;
|
||||
import org.springframework.jdbc.core.JdbcTemplate;
|
||||
import org.springframework.stereotype.Service;
|
||||
import org.springframework.transaction.support.TransactionTemplate;
|
||||
import java.time.*;
|
||||
import java.util.*;
|
||||
import static com.baiyue.lastleg.selfoperated.analytics.model.SelfopSupport.*;
|
||||
|
||||
/** One page per dispatch. Only the HTTP/page checkpoint holds the shared account lease. */
|
||||
@Service
|
||||
public class InventoryFlowCollector {
|
||||
private final SelfopAnalyticsProperties config;
|
||||
private final SelfopSyncTaskMapper tasks; private final SelfopSyncRunMapper runs; private final SelfopSyncStageMapper stages;
|
||||
private final SelfopCoordinationMapper locks; private final SelfopLeaseService leases;
|
||||
private final RestLingxingAnalyticsClient client; private final JdbcTemplate jdbc; private final TransactionTemplate tx;
|
||||
private final String session=UUID.randomUUID().toString();
|
||||
public InventoryFlowCollector(SelfopAnalyticsProperties config,SelfopSyncTaskMapper tasks,SelfopSyncRunMapper runs,
|
||||
SelfopSyncStageMapper stages,SelfopCoordinationMapper locks,SelfopLeaseService leases,RestLingxingAnalyticsClient client,
|
||||
JdbcTemplate jdbc,TransactionTemplate tx){this.config=config;this.tasks=tasks;this.runs=runs;this.stages=stages;this.locks=locks;
|
||||
this.leases=leases;this.client=client;this.jdbc=jdbc;this.tx=tx;}
|
||||
public record Checkpoint(String session,int nextPage,LocalDateTime lastTime) {}
|
||||
public void plan(long accountId,InventoryFlowSlice slice,LocalDate round) {
|
||||
String digest=hash(slice),key="continuous:history:"+round+":"+digest;
|
||||
tx.executeWithoutResult(s->{
|
||||
locks.lockDiscovery(accountId);
|
||||
if(tasks.selectCount(new QueryWrapper<SelfopSyncTask>().eq("source_account",config.getSourceAccount()).eq("request_key",key))>0)return;
|
||||
var now=utcNow();var task=new SelfopSyncTask();task.setId(IdWorker.getId());
|
||||
task.setTaskNo("LXHIST-"+UUID.randomUUID().toString().replace("-",""));task.setSourceAccount(config.getSourceAccount());
|
||||
task.setTaskRole("ACCOUNT_DISCOVERY");task.setDiscoveryScopeId(accountId);task.setTaskType(InventoryFlowSlice.TYPE);
|
||||
task.setExecutionPurpose("BUSINESS");task.setBusinessRootTaskId(task.getId());task.setBusinessBudgetJson(SelfopBusinessBudget.freezeContinuous(now));
|
||||
task.setRequestKey(key);task.setRequestHash(digest);task.setScopeHash(digest);task.setQueryScopeJson(json(slice));
|
||||
task.setQueryFromUtc(LocalDateTime.ofInstant(slice.from(),ZoneOffset.UTC));task.setQueryUntilUtc(LocalDateTime.ofInstant(slice.until(),ZoneOffset.UTC));
|
||||
task.setPlannedAtUtc(round.atStartOfDay());task.setRequestedBy(SelfopCollectionPolicy.CONTINUOUS_PLANNER);
|
||||
task.setStatus("READY");task.setApplyState("NOT_APPLICABLE");task.setAttemptCount(0);task.setCreatedAt(now);task.setUpdatedAt(now);tasks.insert(task);
|
||||
});
|
||||
}
|
||||
public boolean priorityWork() {
|
||||
return !locks.dueContinuous(utcNow(),1,config.getSourceAccount()).isEmpty();
|
||||
}
|
||||
public void page() {
|
||||
if(priorityWork())return;
|
||||
var pending=tasks.selectList(new QueryWrapper<SelfopSyncTask>().eq("source_account",config.getSourceAccount())
|
||||
.eq("task_type",InventoryFlowSlice.TYPE).in("status",List.of("READY","RUNNING","RETRY_WAIT"))
|
||||
.and(q->q.isNull("next_retry_at_utc").or().le("next_retry_at_utc",utcNow())).orderByDesc("query_until_utc").orderByAsc("id").last("LIMIT 1"));
|
||||
if(pending.isEmpty())return;
|
||||
var selected=pending.get(0);var lease=leases.acquireDiscovery(selected.getDiscoveryScopeId(),"history-"+session);
|
||||
try {
|
||||
if(priorityWork())return;
|
||||
var run=tx.execute(s->{
|
||||
leases.verify(lease);var task=locks.lockTask(selected.getId());
|
||||
require(Set.of("READY","RUNNING","RETRY_WAIT").contains(task.getStatus()),"HISTORY_TASK_NOT_READY");
|
||||
var prior=runs.selectOne(new QueryWrapper<SelfopSyncRun>().eq("task_id",task.getId()).orderByDesc("attempt_no").last("LIMIT 1"));
|
||||
if(prior!=null&&"FETCHING".equals(prior.getStatus())&&prior.getProgressSnapshotJson()!=null
|
||||
&&session.equals(read(prior.getProgressSnapshotJson(),Checkpoint.class).session())) {
|
||||
prior.setFenceToken(lease.fence());runs.updateById(prior);return prior;
|
||||
}
|
||||
if(prior!=null&&"FETCHING".equals(prior.getStatus())) {
|
||||
prior.setStatus("ABORTED");prior.setErrorCode("HISTORY_RESTART_PAGE_ONE");prior.setFinishedAtUtc(utcNow());runs.updateById(prior);
|
||||
}
|
||||
if(task.getAttemptCount()>=config.getMaxAttempts()){task.setStatus("DEAD");tasks.updateById(task);return null;}
|
||||
var now=utcNow();var next=new SelfopSyncRun();next.setId(IdWorker.getId());next.setTaskId(task.getId());
|
||||
next.setAttemptNo(task.getAttemptCount()+1);next.setSourceAccount(task.getSourceAccount());next.setExecutionPurpose("BUSINESS");
|
||||
next.setRunRole("ACCOUNT_DISCOVERY");next.setScopeHash(task.getScopeHash());next.setScopeSnapshotJson(task.getQueryScopeJson());
|
||||
next.setFenceToken(lease.fence());next.setStatus("FETCHING");next.setLastPhase("FETCHING");next.setCoverageStatus("UNKNOWN");
|
||||
next.setPageCount(0);next.setUniqueObjectCount(0L);next.setFetchStartedAtUtc(now);next.setCreatedAt(now);next.setUpdatedAt(now);
|
||||
next.setProgressSnapshotJson(json(new Checkpoint(session,1,null)));runs.insert(next);
|
||||
task.setStatus("RUNNING");task.setAttemptCount(next.getAttemptNo());task.setUpdatedAt(now);tasks.updateById(task);return next;
|
||||
});
|
||||
if(run==null)return;
|
||||
var task=tasks.selectById(selected.getId());var slice=read(task.getQueryScopeJson(),InventoryFlowSlice.class);
|
||||
var checkpoint=read(run.getProgressSnapshotJson(),Checkpoint.class);
|
||||
try {
|
||||
var page=slice.validate(client.inventoryFlowPage(SelfopRequestContext.forTask(task,run,config),slice.warehouse(),slice.start(),slice.end(),checkpoint.nextPage(),slice.size()),
|
||||
checkpoint.nextPage(),run.getSourceTotalCount(),checkpoint.lastTime());
|
||||
tx.executeWithoutResult(s->{
|
||||
leases.verify(lease);var current=locks.lockTask(task.getId());require("RUNNING".equals(current.getStatus()),"HISTORY_TASK_STOPPED");
|
||||
var now=utcNow();
|
||||
for(var row:page.rows()) {
|
||||
var stage=new SelfopSyncStage();stage.setId(IdWorker.getId());stage.setRunId(run.getId());stage.setStageBatchId(run.getId());
|
||||
stage.setLastFetchRunId(run.getId());stage.setWarehouseCode(slice.warehouse());stage.setObjectType("INVENTORY_FLOW");
|
||||
stage.setObjectKeyHash(hash(row.path("id").asText()));stage.setContentHash(hash(row));stage.setPayloadJson(json(row));
|
||||
stage.setFirstPageNo(checkpoint.nextPage());stage.setObservedAtUtc(now);stage.setValidationStatus("VALID");stage.setCreatedAt(now);stage.setUpdatedAt(now);
|
||||
stages.insert(stage); // Duplicate IDs across pages roll back this entire page.
|
||||
}
|
||||
run.setPageCount(checkpoint.nextPage());run.setSourceTotalCount(page.total());run.setUniqueObjectCount(run.getUniqueObjectCount()+page.rows().size());
|
||||
run.setProgressSnapshotJson(json(new Checkpoint(session,checkpoint.nextPage()+1,page.lastTime())));run.setUpdatedAt(now);run.setHeartbeatAtUtc(now);
|
||||
if(checkpoint.nextPage()>=page.pages()) {
|
||||
require(run.getUniqueObjectCount()==page.total(),"HISTORY_PAGE_COUNT_MISMATCH");
|
||||
run.setStatus("VALIDATED");run.setLastPhase("VALIDATED");run.setFetchFinishedAtUtc(now);
|
||||
// Coverage becomes usable only after the separate local merge finishes.
|
||||
current.setStatus("WAITING_SOURCE");
|
||||
}
|
||||
runs.updateById(run);current.setProgressUpdatedAtUtc(now);current.setUpdatedAt(now);tasks.updateById(current);
|
||||
});
|
||||
}catch(EgressRejectedException e) {
|
||||
tx.executeWithoutResult(s->{leases.verify(lease);jdbc.update("UPDATE ll_selfop_sync_task SET next_retry_at_utc=?,updated_at=? WHERE id=? AND status='RUNNING'",
|
||||
e.waitUntilUtc()==null?utcNow().plusSeconds(30):e.waitUntilUtc(),utcNow(),task.getId());});
|
||||
}catch(RuntimeException e) {
|
||||
tx.executeWithoutResult(s->{leases.verify(lease);run.setStatus("FAILED");run.setErrorCode("HISTORY_FETCH_FAILED");
|
||||
run.setErrorMessage("分页失败，完整片重试；账号不确定结果仍受出口暂停保护");run.setFinishedAtUtc(utcNow());runs.updateById(run);
|
||||
boolean drift="HISTORY_PAGE_DRIFT_OR_INVALID".equals(e.getMessage())||e instanceof org.springframework.dao.DuplicateKeyException;
|
||||
long seconds=Duration.between(slice.start(),slice.end()).getSeconds();
|
||||
if(drift&&seconds>3600) {
|
||||
var midpoint=slice.start().plusSeconds(seconds/2);
|
||||
plan(task.getDiscoveryScopeId(),new InventoryFlowSlice(slice.warehouse(),slice.start(),midpoint,1000),task.getPlannedAtUtc().toLocalDate());
|
||||
plan(task.getDiscoveryScopeId(),new InventoryFlowSlice(slice.warehouse(),midpoint,slice.end(),1000),task.getPlannedAtUtc().toLocalDate());
|
||||
}
|
||||
jdbc.update("UPDATE ll_selfop_sync_task SET status=?,next_retry_at_utc=?,updated_at=? WHERE id=? AND status='RUNNING'",
|
||||
drift&&seconds>3600||task.getAttemptCount()>=config.getMaxAttempts()?"DEAD":"RETRY_WAIT",utcNow().plusSeconds(60),utcNow(),task.getId());});
|
||||
}
|
||||
}finally{leases.release(lease);}
|
||||
}
|
||||
}
|
||||
+91
@@ -0,0 +1,91 @@
|
||||
package com.baiyue.lastleg.selfoperated.analytics.history;
|
||||
|
||||
import com.baomidou.mybatisplus.core.toolkit.IdWorker;
|
||||
import com.baiyue.lastleg.selfoperated.analytics.model.SelfopSupport;
|
||||
import com.fasterxml.jackson.databind.JsonNode;
|
||||
import org.springframework.jdbc.core.JdbcTemplate;
|
||||
import org.springframework.jdbc.core.namedparam.NamedParameterJdbcTemplate;
|
||||
import org.springframework.stereotype.Repository;
|
||||
import org.springframework.transaction.support.TransactionTemplate;
|
||||
import java.math.BigDecimal;
|
||||
import java.sql.Timestamp;
|
||||
import java.time.*;
|
||||
import java.util.*;
|
||||
|
||||
/** Small local transactions; facts and invalidation commit together, independently of HTTP. */
|
||||
@Repository
|
||||
public class InventoryFlowFacts {
|
||||
private final JdbcTemplate jdbc;private final TransactionTemplate tx;private final InventoryHistoryVersions versions;
|
||||
public InventoryFlowFacts(JdbcTemplate jdbc,TransactionTemplate tx,InventoryHistoryVersions versions){this.jdbc=jdbc;this.tx=tx;this.versions=versions;}
|
||||
public boolean mergeNext(String account) {
|
||||
var pending=jdbc.queryForList("SELECT r.id,t.id task_id,t.query_scope_json FROM ll_selfop_sync_run r JOIN ll_selfop_sync_task t ON t.id=r.task_id WHERE t.source_account=? AND t.task_type=? AND t.status='WAITING_SOURCE' AND r.status='VALIDATED' ORDER BY r.id LIMIT 1",account,InventoryFlowSlice.TYPE);
|
||||
if(pending.isEmpty())return false;
|
||||
long run=((Number)pending.get(0).get("id")).longValue(),task=((Number)pending.get(0).get("task_id")).longValue();
|
||||
var slice=SelfopSupport.read(string(pending.get(0).get("query_scope_json")),InventoryFlowSlice.class);
|
||||
tx.executeWithoutResult(s->{
|
||||
versions.lockWarehouse(account,slice.warehouse());
|
||||
var state=jdbc.queryForMap("SELECT status,COALESCE(applied_fact_revision,0) checkpoint FROM ll_selfop_sync_run WHERE id=? FOR UPDATE",run);
|
||||
if(!"VALIDATED".equals(state.get("status")))return;
|
||||
long after=((Number)state.get("checkpoint")).longValue();
|
||||
var batch=jdbc.queryForList("SELECT id,payload_json,content_hash,observed_at_utc FROM ll_selfop_sync_stage WHERE run_id=? AND object_type='INVENTORY_FLOW' AND id>? ORDER BY id LIMIT 500",run,after);
|
||||
boolean changed=false;
|
||||
for(var stage:batch)changed|=merge(account,slice,run,stage);
|
||||
if(changed)versions.invalidate(account,slice.warehouse(),run,"FLOW_FACT_REVISED");
|
||||
if(!batch.isEmpty()) {
|
||||
jdbc.update("UPDATE ll_selfop_sync_run SET applied_fact_revision=?,updated_at=? WHERE id=?",batch.get(batch.size()-1).get("id"),now(),run);return;
|
||||
}
|
||||
// A previously observed row disappearing is uncertainty, not an invented reversal.
|
||||
int missing=jdbc.update("UPDATE ll_selfop_inventory_flow SET validation_status='UNKNOWN',validation_reason='SOURCE_FLOW_MISSING',revision_no=revision_no+1 WHERE source_account=? AND warehouse_code=? AND event_at_utc>=? AND event_at_utc<? AND validation_reason IS NULL AND last_run_id<>? AND last_observed_at<(SELECT fetch_started_at_utc FROM ll_selfop_sync_run WHERE id=?) LIMIT 100",
|
||||
account,slice.warehouse(),utc(slice.from()),utc(slice.until()),run,run);
|
||||
if(missing>0){versions.invalidate(account,slice.warehouse(),run,"SOURCE_FLOW_MISSING");return;}
|
||||
jdbc.update("UPDATE ll_selfop_sync_run SET status='FACTS_APPLIED',last_phase='FACTS_APPLIED',coverage_status='COMPLETE',covered_from_utc=?,covered_until_utc=?,finished_at_utc=?,updated_at=? WHERE id=?",
|
||||
utc(slice.from()),utc(slice.until()),now(),now(),run);
|
||||
jdbc.update("UPDATE ll_selfop_sync_task SET status='SUCCEEDED',updated_at=? WHERE id=? AND status='WAITING_SOURCE'",now(),task);
|
||||
});
|
||||
return true;
|
||||
}
|
||||
private boolean merge(String account,InventoryFlowSlice slice,long run,Map<String,Object> stage) {
|
||||
var row=SelfopSupport.read(string(stage.get("payload_json")),JsonNode.class);String id=row.path("id").asText();
|
||||
var old=jdbc.queryForList("SELECT id,customer_code,sku_code,product_quality,content_hash,revision_no,validation_reason,last_observed_at FROM ll_selfop_inventory_flow WHERE source_account=? AND warehouse_code=? AND source_flow_id=?",account,slice.warehouse(),id);
|
||||
var observed=instant(stage.get("observed_at_utc"));
|
||||
if(!old.isEmpty()&&instant(old.get(0).get("last_observed_at")).isAfter(observed))return false;
|
||||
if(!old.isEmpty()) {
|
||||
var prior=old.get(0);
|
||||
if("FLOW_IDENTITY_CONFLICT".equals(prior.get("validation_reason")))return false;
|
||||
if(!Objects.equals(prior.get("customer_code"),row.path("customerCode").asText())
|
||||
||!Objects.equals(prior.get("sku_code"),row.path("productSku").asText())
|
||||
||((Number)prior.get("product_quality")).intValue()!=row.path("productQuality").asInt(-1)) {
|
||||
jdbc.update("UPDATE ll_selfop_inventory_flow SET validation_status='UNKNOWN',validation_reason='FLOW_IDENTITY_CONFLICT',revision_no=revision_no+1 WHERE id=?",prior.get("id"));
|
||||
return true;
|
||||
}
|
||||
}
|
||||
if(!old.isEmpty()&&Objects.equals(old.get(0).get("content_hash"),stage.get("content_hash"))&&old.get(0).get("validation_reason")==null){
|
||||
jdbc.update("UPDATE ll_selfop_inventory_flow SET last_run_id=?,last_observed_at=? WHERE id=?",run,utc(observed),old.get(0).get("id"));return false;
|
||||
}
|
||||
var fields=new LinkedHashMap<String,Object>();
|
||||
fields.put("source_account",account);fields.put("warehouse_code",slice.warehouse());fields.put("source_flow_id",id);
|
||||
fields.put("customer_code",row.path("customerCode").asText());fields.put("sku_code",row.path("productSku").asText());fields.put("product_quality",row.path("productQuality").asInt(-1));
|
||||
for(var name:Map.of("cell_no","cellNo","inner_batch_no","innerBatchNo","bill_no","billNo","source_no","sourceNo","bill_type","billType").entrySet())fields.put(name.getKey(),nullable(row,name.getValue()));
|
||||
var at=LocalDateTime.parse(row.path("createTime").asText().replace(' ','T'));
|
||||
fields.put("book_qty",number(row,"bookQty"));fields.put("book_change_qty_raw",nullable(row,"bookChangQty"));fields.put("delta_quantity",number(row,"bookChangQty"));fields.put("close_quantity",number(row,"closeQty"));
|
||||
fields.put("source_create_time",row.path("createTime").asText());fields.put("event_at_utc",at.minusHours(8));fields.put("business_date",at.toLocalDate());fields.put("quantity_unit","PCS");
|
||||
fields.put("content_hash",stage.get("content_hash"));fields.put("stage_id",stage.get("id"));fields.put("last_run_id",run);fields.put("last_observed_at",utc(observed));
|
||||
fields.put("validation_status","VALID");fields.put("validation_reason",null);
|
||||
fields.put("revision_no",old.isEmpty()?1L:((Number)old.get(0).get("revision_no")).longValue()+1);
|
||||
var named=new NamedParameterJdbcTemplate(jdbc);
|
||||
if(old.isEmpty()) {
|
||||
fields.put("id",IdWorker.getId());fields.put("first_run_id",run);
|
||||
named.update("INSERT INTO ll_selfop_inventory_flow ("+String.join(",",fields.keySet())+") VALUES (:"+String.join(",:",fields.keySet())+")",fields);
|
||||
}else{
|
||||
String sets=String.join(",",fields.keySet().stream().map(k->k+"=:"+k).toList());fields.put("id",old.get(0).get("id"));
|
||||
named.update("UPDATE ll_selfop_inventory_flow SET "+sets+" WHERE id=:id",fields);
|
||||
}
|
||||
return true;
|
||||
}
|
||||
static BigDecimal number(JsonNode row,String field){try{var v=new BigDecimal(row.path(field).asText());return v.scale()<=6&&v.precision()-v.scale()<=14?v:null;}catch(RuntimeException e){return null;}}
|
||||
static String nullable(JsonNode row,String field){return row.path(field).isNull()||row.path(field).isMissingNode()?null:row.path(field).asText();}
|
||||
static String string(Object value){return value instanceof byte[] b?new String(b,java.nio.charset.StandardCharsets.UTF_8):String.valueOf(value);}
|
||||
static Instant instant(Object v){return v instanceof Timestamp t?t.toLocalDateTime().toInstant(ZoneOffset.UTC):((LocalDateTime)v).toInstant(ZoneOffset.UTC);}
|
||||
static LocalDateTime now(){return LocalDateTime.now(ZoneOffset.UTC);}
|
||||
private static LocalDateTime utc(Instant instant){return LocalDateTime.ofInstant(instant,ZoneOffset.UTC);}
|
||||
}
|
||||
+54
@@ -0,0 +1,54 @@
|
||||
package com.baiyue.lastleg.selfoperated.analytics.history;
|
||||
|
||||
import com.baiyue.lastleg.selfoperated.analytics.model.SelfopSupport;
|
||||
import com.fasterxml.jackson.databind.JsonNode;
|
||||
import java.time.*;
|
||||
import java.time.format.DateTimeFormatter;
|
||||
import java.util.*;
|
||||
|
||||
/** Fixed inclusive provider bounds; persisted coverage is half open at the next second. */
|
||||
public record InventoryFlowSlice(String warehouse, LocalDateTime start, LocalDateTime end, int size) {
|
||||
public static final String TYPE="INVENTORY_FLOW_HISTORY";
|
||||
public InventoryFlowSlice {
|
||||
if(warehouse==null||warehouse.isBlank()||warehouse.length()>64||start==null||end==null
|
||||
||!start.isBefore(end)||end.isAfter(start.plusDays(1))||start.getNano()!=0||end.getNano()!=0||size!=1000)
|
||||
throw new IllegalArgumentException("HISTORY_SLICE_INVALID");
|
||||
}
|
||||
public Map<String,Object> request(int page) {
|
||||
if(page<1)throw new IllegalArgumentException("HISTORY_PAGE_INVALID");
|
||||
return Map.of("warehouseCode",warehouse,"startTime",DateTimeFormatter.ISO_LOCAL_DATE_TIME.format(start),
|
||||
"endTime",DateTimeFormatter.ISO_LOCAL_DATE_TIME.format(end),"current",page,"size",size);
|
||||
}
|
||||
public String requestHash(int page){return SelfopSupport.hash(request(page));}
|
||||
public Instant from(){return start.toInstant(ZoneOffset.ofHours(8));}
|
||||
public Instant until(){return end.plusSeconds(1).toInstant(ZoneOffset.ofHours(8));}
|
||||
public record Page(long total,long pages,LocalDateTime lastTime,List<JsonNode> rows) {}
|
||||
public Page validate(JsonNode response,int page,Long previousTotal,LocalDateTime previousLast) {
|
||||
if(response==null||!response.path("records").isArray()||response.path("current").asInt()!=page
|
||||
||response.path("size").asInt()!=size)throw invalid();
|
||||
// Internal Long fields are serialized as decimal strings by LongIdJacksonConfiguration.
|
||||
var totalNode=response.path("total");
|
||||
if(!(totalNode.isIntegralNumber()||totalNode.isTextual())||!totalNode.asText().matches("[0-9]{1,19}"))throw invalid();
|
||||
long total;
|
||||
try{total=Long.parseLong(totalNode.asText());}catch(NumberFormatException e){throw invalid();}
|
||||
long pages=total==0?0:(total-1)/size+1;
|
||||
if(total<0||pages>Integer.MAX_VALUE||response.path("pages").asLong(-1)!=pages
|
||||
||previousTotal!=null&&total!=previousTotal||page>Math.max(1,pages)
|
||||
||response.path("records").size()!=Math.min(size,Math.max(0,total-(long)(page-1)*size)))throw invalid();
|
||||
var ids=new HashSet<String>();var rows=new ArrayList<JsonNode>();var last=previousLast;
|
||||
for(var row:response.path("records")) {
|
||||
String id=text(row,"id",64);text(row,"customerCode",64);text(row,"productSku",128);
|
||||
if(!warehouse.equals(text(row,"whCode",64))||!ids.add(id))throw invalid();
|
||||
LocalDateTime at;
|
||||
try{at=LocalDateTime.parse(row.path("createTime").asText().replace(' ','T'));}catch(RuntimeException e){throw invalid();}
|
||||
if(at.isBefore(start)||at.isAfter(end)||last!=null&&at.isBefore(last))throw invalid();
|
||||
last=at;rows.add(row);
|
||||
}
|
||||
return new Page(total,pages,last,List.copyOf(rows));
|
||||
}
|
||||
static String text(JsonNode row,String field,int max) {
|
||||
var value=row.path(field);String text=value.asText();
|
||||
if(!value.isTextual()||text.isBlank()||text.length()>max)throw invalid();return text;
|
||||
}
|
||||
private static IllegalStateException invalid(){return new IllegalStateException("HISTORY_PAGE_DRIFT_OR_INVALID");}
|
||||
}
|
||||
+186
@@ -0,0 +1,186 @@
|
||||
package com.baiyue.lastleg.selfoperated.analytics.history;
|
||||
|
||||
import com.baomidou.mybatisplus.core.toolkit.IdWorker;
|
||||
import com.baiyue.lastleg.selfoperated.analytics.mapper.*;
|
||||
import com.baiyue.lastleg.selfoperated.analytics.model.*;
|
||||
import com.fasterxml.jackson.databind.JsonNode;
|
||||
import org.springframework.jdbc.core.JdbcTemplate;
|
||||
import org.springframework.stereotype.Service;
|
||||
import org.springframework.transaction.support.TransactionTemplate;
|
||||
import java.math.BigDecimal;
|
||||
import java.sql.Timestamp;
|
||||
import java.time.*;
|
||||
import java.util.*;
|
||||
import static com.baiyue.lastleg.selfoperated.analytics.history.InventoryHistoryCalculator.*;
|
||||
import static com.baiyue.lastleg.selfoperated.analytics.model.SelfopSupport.*;
|
||||
|
||||
/** Local reconstruction worker. Source requests and account leases are deliberately absent. */
|
||||
@Service
|
||||
public class InventoryHistoryBuilder {
|
||||
public static final String TYPE="INVENTORY_HISTORY_BUILD";
|
||||
private final JdbcTemplate jdbc;private final TransactionTemplate tx;private final InventoryHistoryVersions versions;
|
||||
private final SelfopSyncTaskMapper tasks;private final SelfopSyncRunMapper runs;private final SelfopSyncStageMapper stages;
|
||||
public InventoryHistoryBuilder(JdbcTemplate jdbc,TransactionTemplate tx,InventoryHistoryVersions versions,
|
||||
SelfopSyncTaskMapper tasks,SelfopSyncRunMapper runs,SelfopSyncStageMapper stages){this.jdbc=jdbc;this.tx=tx;this.versions=versions;this.tasks=tasks;this.runs=runs;this.stages=stages;}
|
||||
public record StockRun(long id,String scopeHash,Instant from,Instant until) {}
|
||||
public StockRun anchor(String account,String warehouse,int offset) {
|
||||
var rows=jdbc.query("SELECT r.id,r.scope_hash,r.fetch_started_at_utc,r.fetch_finished_at_utc FROM ll_selfop_sync_run r JOIN ll_selfop_sync_scope s ON s.id=r.scope_id AND s.scope_hash=r.scope_hash WHERE s.source_account=? AND s.warehouse_code=? AND s.data_family='INVENTORY' AND r.status='PUBLISHED' AND r.execution_purpose='BUSINESS' AND r.coverage_status='COMPLETE' AND r.source_total_count=r.unique_object_count AND r.page_count>0 AND r.fetch_started_at_utc<=r.fetch_finished_at_utc ORDER BY r.published_at_utc DESC,r.id DESC LIMIT 1 OFFSET ?",
|
||||
(rs,n)->new StockRun(rs.getLong(1),rs.getString(2),rs.getTimestamp(3).toLocalDateTime().toInstant(ZoneOffset.UTC),rs.getTimestamp(4).toLocalDateTime().toInstant(ZoneOffset.UTC)),account,warehouse,offset);
|
||||
return rows.isEmpty()?null:rows.get(0);
|
||||
}
|
||||
private record Frozen(InventoryHistoryVersions.Build build,List<InventoryHistoryVersions.Candidate> candidates,
|
||||
long task,StockRun anchor,StockRun reference,LocalDate from,LocalDate until,List<Interval> coverage,List<Long> coverageRuns) {}
|
||||
public void build(String account,String warehouse,int days) {
|
||||
Frozen frozen=tx.execute(s->freeze(account,warehouse,Math.max(30,Math.min(60,days))));
|
||||
if(frozen==null)return;
|
||||
try {
|
||||
long count=0;String owner="",sku="";
|
||||
while(true) {
|
||||
// Keyset paging bounds memory independently of the warehouse's SKU count.
|
||||
var identities=candidates(frozen,owner,sku);
|
||||
if(identities.isEmpty())break;
|
||||
var dailyBatches=new HashMap<LocalDate,List<Daily>>();
|
||||
for(var identity:identities) {
|
||||
var input=input(frozen,identity);var daily=reconstruct(input);
|
||||
String crosscheck=crosscheck(input.anchors(),referenceAnchors(frozen,identity),input.flows(),frozen.coverage());
|
||||
if(crosscheck!=null)daily=daily.stream().map(d->new Daily(d.date(),d.key(),null,"UNKNOWN",crosscheck,d.anchorRun())).toList();
|
||||
var evidence=flowEvidence(frozen,identity);
|
||||
String evidenceHash=hash(evidence);
|
||||
tx.executeWithoutResult(s->{
|
||||
requireBuilding(frozen);saveInput(frozen,identity,evidence,evidenceHash);
|
||||
});
|
||||
for(var d:daily)dailyBatches.computeIfAbsent(d.date(),k->new ArrayList<>()).add(d);
|
||||
owner=identity.owner();sku=identity.sku();count++;
|
||||
}
|
||||
for(var candidate:frozen.candidates()) {
|
||||
var rows=dailyBatches.getOrDefault(candidate.date(),List.of());
|
||||
for(int start=0;start<rows.size();start+=500)versions.append(candidate,rows.subList(start,Math.min(rows.size(),start+500)),hash(List.of(frozen.build().run(),candidate.date())));
|
||||
}
|
||||
heartbeat(frozen);
|
||||
}
|
||||
for(var c:frozen.candidates())versions.ready(c,count);
|
||||
tx.executeWithoutResult(s->{
|
||||
versions.lockWarehouse(account,warehouse);requireBuilding(frozen);
|
||||
versions.publish(frozen.build(),frozen.candidates());
|
||||
jdbc.update("UPDATE ll_selfop_sync_run SET status='FACTS_APPLIED',last_phase='HISTORY_PUBLISHED',published_at_utc=?,finished_at_utc=?,updated_at=? WHERE id=?",utcNow(),utcNow(),utcNow(),frozen.build().run());
|
||||
jdbc.update("UPDATE ll_selfop_sync_task SET status='SUCCEEDED',result_published_run_id=?,updated_at=? WHERE id=?",frozen.build().run(),utcNow(),frozen.task());
|
||||
});
|
||||
}catch(RuntimeException failure) {
|
||||
tx.executeWithoutResult(s->{
|
||||
versions.lockWarehouse(account,warehouse);
|
||||
jdbc.update("UPDATE ll_selfop_inventory_day_version SET status='FAILED' WHERE build_run_id=? AND status IN ('BUILDING','READY')",frozen.build().run());
|
||||
jdbc.update("UPDATE ll_selfop_sync_run SET status='FAILED',error_code='HISTORY_BUILD_FAILED',error_message='输入变化或构建失败，保留候选证据等待下轮重新构建',finished_at_utc=?,updated_at=? WHERE id=? AND status='BUILDING'",utcNow(),utcNow(),frozen.build().run());
|
||||
jdbc.update("UPDATE ll_selfop_sync_task SET status='DEAD',updated_at=? WHERE id=? AND status='RUNNING'",utcNow(),frozen.task());
|
||||
});
|
||||
throw failure;
|
||||
}
|
||||
}
|
||||
private Frozen freeze(String account,String warehouse,int days) {
|
||||
versions.lockWarehouse(account,warehouse);
|
||||
var active=jdbc.queryForList("SELECT t.id,r.id run_id,r.heartbeat_at_utc FROM ll_selfop_sync_task t JOIN ll_selfop_sync_run r ON r.task_id=t.id WHERE t.source_account=? AND JSON_UNQUOTE(JSON_EXTRACT(t.query_scope_json,'$.warehouse'))=? AND t.task_type=? AND t.status='RUNNING' AND r.status='BUILDING' FOR UPDATE",account,warehouse,TYPE);
|
||||
if(!active.isEmpty()) {
|
||||
var row=active.get(0);var beat=row.get("heartbeat_at_utc");
|
||||
if(beat!=null&&InventoryFlowFacts.instant(beat).isAfter(Instant.now().minusSeconds(300)))return null;
|
||||
jdbc.update("UPDATE ll_selfop_inventory_day_version SET status='FAILED' WHERE build_run_id=? AND status IN ('BUILDING','READY')",row.get("run_id"));
|
||||
jdbc.update("UPDATE ll_selfop_sync_run SET status='ABORTED',error_code='HISTORY_BUILD_INTERRUPTED',finished_at_utc=? WHERE id=?",utcNow(),row.get("run_id"));
|
||||
jdbc.update("UPDATE ll_selfop_sync_task SET status='DEAD',updated_at=? WHERE id=?",utcNow(),row.get("id"));
|
||||
}
|
||||
// A quarantined identity cannot silently move to a different customer/SKU/quality.
|
||||
if(jdbc.queryForObject("SELECT COUNT(*) FROM ll_selfop_inventory_flow WHERE source_account=? AND warehouse_code=? AND validation_reason='FLOW_IDENTITY_CONFLICT'",Long.class,account,warehouse)>0)return null;
|
||||
var anchor=anchor(account,warehouse,0);var reference=anchor(account,warehouse,1);
|
||||
if(anchor==null||reference==null)return null;
|
||||
LocalDate until=anchor.from().atOffset(ZoneOffset.ofHours(8)).toLocalDate();
|
||||
Instant retainedFrom=until.minusDays(366).atStartOfDay().toInstant(ZoneOffset.ofHours(8));
|
||||
Instant coverageFrom=reference.from().isBefore(retainedFrom)?reference.from():retainedFrom;
|
||||
var coverageRows=jdbc.queryForList("SELECT r.id,r.covered_from_utc,r.covered_until_utc FROM ll_selfop_sync_run r JOIN ll_selfop_sync_task t ON t.id=r.task_id WHERE t.source_account=? AND t.task_type=? AND r.status='FACTS_APPLIED' AND r.coverage_status='COMPLETE' AND JSON_UNQUOTE(JSON_EXTRACT(t.query_scope_json,'$.warehouse'))=? AND r.covered_until_utc>? ORDER BY r.covered_from_utc",account,InventoryFlowSlice.TYPE,warehouse,utc(coverageFrom));
|
||||
var coverage=union(coverageRows.stream().map(r->new Interval(InventoryFlowFacts.instant(r.get("covered_from_utc")),InventoryFlowFacts.instant(r.get("covered_until_utc")))).toList());
|
||||
var coverageRuns=coverageRows.stream().map(r->((Number)r.get("id")).longValue()).toList();
|
||||
LocalDate from=until;
|
||||
while(from.isAfter(until.minusDays(days))&&covered(coverage,from.minusDays(1).atStartOfDay().toInstant(ZoneOffset.ofHours(8)),anchor.until().plusNanos(1)))from=from.minusDays(1);
|
||||
if(from.equals(until))return null;
|
||||
var heads=versions.heads(account,warehouse,until.minusDays(366),until);
|
||||
// Corrections rebuild every retained date, or remain invalid until its coverage returns.
|
||||
if(!heads.isEmpty()&&heads.keySet().stream().min(LocalDate::compareTo).orElseThrow().isBefore(from)) {
|
||||
LocalDate earliest=heads.keySet().iterator().next();
|
||||
if(!covered(coverage,earliest.atStartOfDay().toInstant(ZoneOffset.ofHours(8)),anchor.until().plusNanos(1)))return null;
|
||||
from=earliest;
|
||||
}
|
||||
if(jdbc.queryForObject("SELECT COUNT(*) FROM ll_selfop_sync_run r JOIN ll_selfop_sync_task t ON t.id=r.task_id WHERE t.source_account=? AND t.task_type=? AND r.status='VALIDATED' AND JSON_UNQUOTE(JSON_EXTRACT(t.query_scope_json,'$.warehouse'))=? AND t.query_until_utc>? AND t.query_from_utc<?",Long.class,account,InventoryFlowSlice.TYPE,warehouse,from.atStartOfDay().minusHours(8),utc(anchor.until()))>0)return null;
|
||||
var sales=jdbc.queryForList("SELECT published_run_id FROM ll_selfop_sync_scope WHERE source_account=? AND warehouse_code=? AND data_family='OUTBOUND'",account,warehouse);
|
||||
Long salesRun=sales.isEmpty()||sales.get(0).get("published_run_id")==null?null:((Number)sales.get(0).get("published_run_id")).longValue();
|
||||
String inputHash=versions.factHash(account,warehouse);
|
||||
String signature=hash(Arrays.asList(RULE,CALCULATION_REVISION,inputHash,anchor,reference,from,until,salesRun,coverage));
|
||||
if(jdbc.queryForObject("SELECT COUNT(*) FROM ll_selfop_sync_task WHERE source_account=? AND task_type=? AND request_hash=? AND status='SUCCEEDED'",Long.class,account,TYPE,signature)>0)return null;
|
||||
// Failed identical inputs get bounded attempts, instead of an infinite hot loop.
|
||||
if(jdbc.queryForObject("SELECT COUNT(*) FROM ll_selfop_sync_task WHERE source_account=? AND task_type=? AND request_hash=?",Long.class,account,TYPE,signature)>=3)return null;
|
||||
long taskId=IdWorker.getId(),runId=IdWorker.getId(),group=IdWorker.getId();var now=utcNow();
|
||||
String evidence=json(Map.of("warehouse",warehouse,"anchor",anchor,"reference",reference,"coverageRuns",coverageRuns,"inputStagesRun",runId,"rule",RULE,"calculationRevision",CALCULATION_REVISION));
|
||||
var task=new SelfopSyncTask();task.setId(taskId);task.setTaskNo("LXRESTORE-"+UUID.randomUUID().toString().replace("-",""));
|
||||
task.setSourceAccount(account);task.setDiscoveryScopeId(jdbc.queryForObject("SELECT id FROM ll_selfop_outbound_discovery_scope WHERE source_account=?",Long.class,account));task.setExecutionPurpose("BUSINESS");
|
||||
task.setTaskRole("ACCOUNT_DISCOVERY");task.setTaskType(TYPE);task.setRequestKey("history-build:"+UUID.randomUUID());task.setRequestHash(signature);
|
||||
task.setScopeHash(anchor.scopeHash());task.setQueryScopeJson(evidence);task.setStatus("RUNNING");task.setApplyState("NOT_APPLICABLE");task.setAttemptCount(1);task.setCreatedAt(now);task.setUpdatedAt(now);tasks.insert(task);
|
||||
var run=new SelfopSyncRun();run.setId(runId);run.setTaskId(taskId);run.setSourceAccount(account);
|
||||
run.setExecutionPurpose("BUSINESS");run.setRunRole("ACCOUNT_DISCOVERY");run.setScopeHash(anchor.scopeHash());run.setScopeSnapshotJson(evidence);run.setFenceToken(0L);run.setAttemptNo(1);
|
||||
run.setBasePublishedRunId(anchor.id());run.setReferenceSalesRunId(salesRun);run.setStatus("BUILDING");run.setLastPhase("BUILDING");run.setCoverageStatus("COMPLETE");run.setPageCount(0);run.setUniqueObjectCount(0L);
|
||||
run.setHeartbeatAtUtc(now);run.setCreatedAt(now);run.setUpdatedAt(now);runs.insert(run);
|
||||
var build=new InventoryHistoryVersions.Build(account,warehouse,anchor.scopeHash(),runId,group,anchor.id(),salesRun,inputHash,evidence,Map.copyOf(heads));
|
||||
var candidates=new ArrayList<InventoryHistoryVersions.Candidate>();for(LocalDate day=from;day.isBefore(until);day=day.plusDays(1))candidates.add(versions.create(build,day));
|
||||
jdbc.update("UPDATE ll_selfop_sync_run SET progress_snapshot_json=? WHERE id=?",json(Map.of("candidates",candidates,"expectedHeads",heads,"inputHash",inputHash)),runId);
|
||||
return new Frozen(build,List.copyOf(candidates),taskId,anchor,reference,from,until,coverage,coverageRuns);
|
||||
}
|
||||
private List<Sku> candidates(Frozen f,String afterOwner,String afterSku) {
|
||||
return jdbc.query("SELECT customer_code,sku_code FROM (SELECT customer_code,sku_code FROM ll_selfop_inventory_snapshot WHERE snapshot_run_id=? UNION SELECT customer_code,sku_code FROM ll_selfop_sku_daily_sales WHERE sales_run_id=? AND business_date>=? AND business_date<? UNION SELECT customer_code,sku_code FROM ll_selfop_inventory_flow WHERE source_account=? AND warehouse_code=? UNION SELECT d.customer_code,d.sku_code FROM ll_selfop_inventory_daily d JOIN ll_selfop_inventory_day_version v ON v.id=d.day_version_id WHERE v.source_account=? AND v.warehouse_code=? AND v.head_slot=1) c WHERE customer_code>? OR (customer_code=? AND sku_code>?) ORDER BY customer_code,sku_code LIMIT 100",
|
||||
(rs,n)->new Sku(rs.getString(1),rs.getString(2)),f.anchor().id(),f.build().sales(),f.from(),f.until(),f.build().account(),f.build().warehouse(),f.build().account(),f.build().warehouse(),afterOwner,afterOwner,afterSku);
|
||||
}
|
||||
private List<Anchor> anchors(StockRun run,Sku sku) {
|
||||
return jdbc.query("SELECT s.product_quality,s.physical_quantity,s.quality_status,s.quality_reason,p.quantity_unit FROM ll_selfop_inventory_snapshot s LEFT JOIN ll_selfop_sku_profile p ON p.profile_run_id=s.snapshot_run_id AND p.customer_code=s.customer_code AND p.sku_code=s.sku_code WHERE s.snapshot_run_id=? AND s.customer_code=? AND s.sku_code=?",
|
||||
(rs,n)->new Anchor(new Key(sku,rs.getInt(1)),("VALID".equals(rs.getString(3))||Set.of("FIELD_MISSING","NEGATIVE_QUANTITY").contains(Objects.toString(rs.getString(4),"")))?rs.getBigDecimal(2):null,
|
||||
rs.getString(5),run.from(),run.until(),run.id()),run.id(),sku.owner(),sku.sku());
|
||||
}
|
||||
private List<Anchor> referenceAnchors(Frozen f,Sku sku){return anchors(f.reference(),sku);}
|
||||
private Input input(Frozen f,Sku sku) {
|
||||
Instant dayStart=f.from().atStartOfDay().toInstant(ZoneOffset.ofHours(8));
|
||||
Instant referenceStart=f.reference().from().truncatedTo(java.time.temporal.ChronoUnit.SECONDS);
|
||||
Instant evidenceFrom=referenceStart.isBefore(dayStart)?referenceStart:dayStart;
|
||||
var flows=jdbc.query("SELECT source_flow_id,product_quality,cell_no,inner_batch_no,bill_type,delta_quantity,book_qty,close_quantity,event_at_utc,validation_reason FROM ll_selfop_inventory_flow WHERE source_account=? AND warehouse_code=? AND customer_code=? AND sku_code=? AND (event_at_utc IS NULL OR (event_at_utc>=? AND event_at_utc<=?)) ORDER BY event_at_utc,source_flow_id",
|
||||
(rs,n)->new Flow(rs.getString(1),new Key(sku,rs.getInt(2)),rs.getString(3),rs.getString(4),rs.getString(5),rs.getString(10)==null?rs.getBigDecimal(6):null,rs.getBigDecimal(7),rs.getBigDecimal(8),rs.getTimestamp(9)==null?null:rs.getTimestamp(9).toLocalDateTime().toInstant(ZoneOffset.UTC)),
|
||||
f.build().account(),f.build().warehouse(),sku.owner(),sku.sku(),utc(evidenceFrom),utc(f.anchor().until()));
|
||||
return new Input(f.from(),f.until(),Set.of(sku),flows,anchors(f.anchor(),sku),f.coverage());
|
||||
}
|
||||
private Object flowEvidence(Frozen f,Sku sku) {
|
||||
return Map.of("sku",sku,"anchor",f.anchor(),"reference",f.reference(),"flowStages",jdbc.queryForList("SELECT source_flow_id,revision_no,stage_id,validation_reason FROM ll_selfop_inventory_flow WHERE source_account=? AND warehouse_code=? AND customer_code=? AND sku_code=? ORDER BY source_flow_id",f.build().account(),f.build().warehouse(),sku.owner(),sku.sku()));
|
||||
}
|
||||
static String crosscheck(List<Anchor> current,List<Anchor> prior,List<Flow> flows,List<Interval> coverage) {
|
||||
if(current.isEmpty()||prior.isEmpty())return "INDEPENDENT_ANCHOR_MISSING";
|
||||
if(!current.stream().map(Anchor::key).collect(java.util.stream.Collectors.toSet()).equals(prior.stream().map(Anchor::key).collect(java.util.stream.Collectors.toSet())))return "INDEPENDENT_ANCHOR_QUALITY_MISSING";
|
||||
for(var a:current) {
|
||||
var p=prior.stream().filter(v->v.key().equals(a.key())).findFirst().orElseThrow();
|
||||
if(p.quantity()==null||a.quantity()==null||!"PCS".equals(p.unit())||!"PCS".equals(a.unit()))return "INDEPENDENT_ANCHOR_INVALID";
|
||||
if(!p.observedUntil().isBefore(a.observedFrom())||!covered(coverage,p.observedFrom(),a.observedUntil().plusNanos(1)))return "INDEPENDENT_ANCHOR_COVERAGE_MISSING";
|
||||
BigDecimal expected=p.quantity();
|
||||
for(var flow:flows)if(flow.key().equals(a.key())) {
|
||||
if(flow.at()==null||flow.delta()==null)return "INDEPENDENT_ANCHOR_FLOW_UNKNOWN";
|
||||
if((!flow.at().isBefore(p.observedFrom().truncatedTo(java.time.temporal.ChronoUnit.SECONDS))&&!flow.at().isAfter(p.observedUntil()))
|
||||
||(!flow.at().isBefore(a.observedFrom().truncatedTo(java.time.temporal.ChronoUnit.SECONDS))&&!flow.at().isAfter(a.observedUntil())))return "ANCHOR_TIME_AMBIGUOUS";
|
||||
if(flow.at().isAfter(p.observedUntil())&&flow.at().isBefore(a.observedFrom()))expected=expected.add(flow.delta());
|
||||
}
|
||||
if(expected.compareTo(a.quantity())!=0)return "INDEPENDENT_ANCHOR_MISMATCH";
|
||||
}
|
||||
return null;
|
||||
}
|
||||
private void saveInput(Frozen f,Sku sku,Object evidence,String digest) {
|
||||
var stage=new SelfopSyncStage();stage.setId(IdWorker.getId());stage.setRunId(f.build().run());stage.setStageBatchId(f.build().run());stage.setLastFetchRunId(f.build().run());stage.setWarehouseCode(f.build().warehouse());
|
||||
stage.setObjectType("HISTORY_INPUT");stage.setObjectKeyHash(hash(sku));stage.setContentHash(digest);stage.setPayloadJson(json(evidence));stage.setFirstPageNo(1);stage.setValidationStatus("VALID");stage.setObservedAtUtc(utcNow());stage.setCreatedAt(utcNow());stage.setUpdatedAt(utcNow());stages.insert(stage);
|
||||
}
|
||||
private void requireBuilding(Frozen f){require("BUILDING".equals(jdbc.queryForObject("SELECT status FROM ll_selfop_sync_run WHERE id=? FOR UPDATE",String.class,f.build().run())),"HISTORY_BUILD_LOST");}
|
||||
private void heartbeat(Frozen f){jdbc.update("UPDATE ll_selfop_sync_run SET heartbeat_at_utc=?,updated_at=? WHERE id=? AND status='BUILDING'",utcNow(),utcNow(),f.build().run());}
|
||||
private static List<Interval> union(List<Interval> input) {
|
||||
var result=new ArrayList<Interval>();
|
||||
for(var next:input.stream().sorted(Comparator.comparing(Interval::from)).toList()) {
|
||||
if(result.isEmpty()||result.get(result.size()-1).until().isBefore(next.from()))result.add(next);
|
||||
else {var old=result.remove(result.size()-1);result.add(new Interval(old.from(),old.until().isAfter(next.until())?old.until():next.until()));}
|
||||
}
|
||||
return List.copyOf(result);
|
||||
}
|
||||
private static LocalDateTime utc(Instant instant){return LocalDateTime.ofInstant(instant,ZoneOffset.UTC);}
|
||||
}
|
||||
+192
@@ -0,0 +1,192 @@
|
||||
package com.baiyue.lastleg.selfoperated.analytics.history;
|
||||
|
||||
import java.math.BigDecimal;
|
||||
import java.time.*;
|
||||
import java.util.*;
|
||||
|
||||
/** Pure reconstruction over frozen, complete source intervals. Never invents absent stock. */
|
||||
public final class InventoryHistoryCalculator {
|
||||
public static final String RULE = "FLOW_EOD_V1";
|
||||
public static final int CALCULATION_REVISION = 2;
|
||||
private static final Set<String> VERIFIED_TYPES = Set.of("DO", "PA", "IMO", "IAT", "RI");
|
||||
private static final ZoneOffset BUSINESS = ZoneOffset.ofHours(8);
|
||||
private InventoryHistoryCalculator() { }
|
||||
public record Sku(String owner, String sku) { }
|
||||
public record Key(Sku sku, int quality) { }
|
||||
public record Interval(Instant from, Instant until) {
|
||||
public Interval { if (from == null || until == null || !from.isBefore(until)) throw new IllegalArgumentException("INVALID_COVERAGE"); }
|
||||
}
|
||||
public record Flow(String id, Key key, String cell, String batch, String type,
|
||||
BigDecimal delta, BigDecimal bookQuantity, BigDecimal closing, Instant at) { }
|
||||
public record Anchor(Key key, BigDecimal quantity, String unit, Instant observedFrom, Instant observedUntil, long runId) { }
|
||||
public record Daily(LocalDate date, Key key, BigDecimal quantity, String status, String reason, long anchorRun) { }
|
||||
public record Input(LocalDate from, LocalDate until, Set<Sku> candidates, List<Flow> flows,
|
||||
List<Anchor> anchors, List<Interval> coverage) { }
|
||||
|
||||
public static List<Daily> reconstruct(Input input) {
|
||||
Objects.requireNonNull(input);
|
||||
if (input.from()==null || input.until()==null || !input.from().isBefore(input.until())
|
||||
|| input.until().isAfter(input.from().plusDays(366))) throw new IllegalArgumentException("INVALID_HISTORY_WINDOW");
|
||||
var byKey = new HashMap<Key,List<Flow>>();
|
||||
var anchors = new HashMap<Key,Anchor>();
|
||||
var reasons = new HashMap<Key,String>();
|
||||
var ids = new HashMap<String,Flow>();
|
||||
var keys = new HashSet<Key>();
|
||||
for (Anchor a : input.anchors()) {
|
||||
requireKey(a.key()); keys.add(a.key());
|
||||
if (anchors.putIfAbsent(a.key(),a)!=null) reasons.put(a.key(),"ANCHOR_DUPLICATE");
|
||||
}
|
||||
for (Flow f : input.flows()) {
|
||||
requireKey(f.key()); keys.add(f.key());
|
||||
if (f.id()==null || f.id().isBlank() || f.id().length()>64) { reasons.put(f.key(),"FLOW_ID_INVALID"); continue; }
|
||||
Flow old=ids.putIfAbsent(f.id(),f);
|
||||
if (old!=null) {
|
||||
if (!old.equals(f)) { reasons.put(old.key(),"FLOW_ID_CONFLICT"); reasons.put(f.key(),"FLOW_ID_CONFLICT"); }
|
||||
continue;
|
||||
}
|
||||
byKey.computeIfAbsent(f.key(),k->new ArrayList<>()).add(f);
|
||||
}
|
||||
var observedSkus=new HashSet<Sku>();for(var key:keys)observedSkus.add(key.sku());
|
||||
for (Sku sku : input.candidates()) if (!observedSkus.contains(sku)) keys.add(new Key(sku,0));
|
||||
var result = new ArrayList<Daily>();
|
||||
var ordered = keys.stream().sorted(Comparator.comparing((Key k)->k.sku().owner()).thenComparing(k->k.sku().sku()).thenComparingInt(Key::quality)).toList();
|
||||
for (Key key : ordered) {
|
||||
Anchor a=anchors.get(key);
|
||||
List<Flow> rows=byKey.getOrDefault(key,List.of());
|
||||
String failure=reasons.get(key);
|
||||
if (failure==null) failure=validateAnchor(a);
|
||||
if (failure==null && key.quality()!=0 && key.quality()!=1) failure="UNKNOWN_QUALITY";
|
||||
if (failure==null) failure=validateRows(rows,a);
|
||||
for (LocalDate day=input.from();day.isBefore(input.until());day=day.plusDays(1)) {
|
||||
Instant boundary=day.plusDays(1).atStartOfDay().toInstant(BUSINESS);
|
||||
String reason=failure;
|
||||
if (reason==null && a.observedFrom().isBefore(boundary)) reason="ANCHOR_BEFORE_DAY_END";
|
||||
if (reason==null && !covered(input.coverage(),boundary,a.observedUntil().plusNanos(1))) reason="FLOW_COVERAGE_GAP";
|
||||
BigDecimal quantity=null;
|
||||
if (reason==null) {
|
||||
quantity=a.quantity();
|
||||
for (Flow f:rows) if (!f.at().isBefore(boundary) && f.at().isBefore(a.observedFrom())) quantity=quantity.subtract(f.delta());
|
||||
if (quantity.signum()<0) { quantity=null; reason="NEGATIVE_RECONSTRUCTED_STOCK"; }
|
||||
}
|
||||
result.add(new Daily(day,key,quantity,reason==null?"VALID":"UNKNOWN",reason,a==null?0:a.runId()));
|
||||
}
|
||||
}
|
||||
return List.copyOf(result);
|
||||
}
|
||||
private static String validateAnchor(Anchor a) {
|
||||
if (a==null) return "ANCHOR_MISSING";
|
||||
if (!"PCS".equals(a.unit())) return "UNIT_UNKNOWN";
|
||||
if (!quantity(a.quantity()) || a.quantity().signum()<0) return "ANCHOR_QUANTITY_INVALID";
|
||||
if (a.runId()<=0 || a.observedFrom()==null || a.observedUntil()==null || a.observedUntil().isBefore(a.observedFrom())) return "ANCHOR_INTERVAL_INVALID";
|
||||
return null;
|
||||
}
|
||||
private static String validateRows(List<Flow> rows, Anchor anchor) {
|
||||
var chains=new HashMap<List<String>,List<Flow>>();
|
||||
for (Flow f:rows) {
|
||||
if (f.at()==null || !quantity(f.delta()) || !quantity(f.bookQuantity()) || !quantity(f.closing())) return "FLOW_QUANTITY_OR_TIME_INVALID";
|
||||
if (f.type()==null || !VERIFIED_TYPES.contains(f.type())) return "FLOW_TYPE_UNVERIFIED";
|
||||
if (f.delta().compareTo(f.bookQuantity())!=0) return "FLOW_QUANTITY_CONFLICT";
|
||||
if (f.closing().signum()<0 || f.closing().subtract(f.delta()).signum()<0) return "NEGATIVE_CHAIN_STOCK";
|
||||
if (f.cell()==null || f.cell().isBlank() || f.batch()==null || f.batch().isBlank()) return "CHAIN_IDENTITY_MISSING";
|
||||
// Source events have second resolution; an event in the anchor's first second is ambiguous.
|
||||
if (!f.at().isBefore(anchor.observedFrom().truncatedTo(java.time.temporal.ChronoUnit.SECONDS))
|
||||
&& !f.at().isAfter(anchor.observedUntil())) return "ANCHOR_TIME_AMBIGUOUS";
|
||||
chains.computeIfAbsent(List.of(f.cell(),f.batch()),k->new ArrayList<>()).add(f);
|
||||
}
|
||||
for (var chain:chains.values()) {
|
||||
var seconds=new TreeMap<Instant,List<Flow>>();
|
||||
for(Flow f:chain) seconds.computeIfAbsent(f.at(),k->new ArrayList<>()).add(f);
|
||||
BigDecimal prior=null;
|
||||
for(var group:seconds.values()) {
|
||||
var resolved=resolveChain(group,prior);
|
||||
if(resolved.reason()!=null) return resolved.reason();
|
||||
prior=resolved.ending();
|
||||
}
|
||||
}
|
||||
var deltas=new TreeMap<Instant,BigDecimal>(Comparator.reverseOrder());
|
||||
for(var row:rows)if(row.at().isBefore(anchor.observedFrom()))deltas.merge(row.at(),row.delta(),BigDecimal::add);
|
||||
BigDecimal balance=anchor.quantity();
|
||||
for(var delta:deltas.values()) {
|
||||
balance=balance.subtract(delta);
|
||||
if(balance.signum()<0)return "NEGATIVE_RECONSTRUCTED_STOCK";
|
||||
}
|
||||
return null;
|
||||
}
|
||||
private record ChainResult(BigDecimal ending,String reason) { }
|
||||
private static ChainResult resolveChain(List<Flow> group,BigDecimal prior) {
|
||||
// Every flow is a distinct directed edge: opening balance -> closing balance.
|
||||
// A valid order is an Euler trail, using every edge exactly once.
|
||||
var degree=new TreeMap<BigDecimal,Integer>();
|
||||
for(var f:group) {
|
||||
degree.merge(f.closing().subtract(f.delta()),1,Integer::sum);
|
||||
degree.merge(f.closing(),-1,Integer::sum);
|
||||
}
|
||||
BigDecimal start=null;int starts=0,ends=0;
|
||||
for(var entry:degree.entrySet()) {
|
||||
int difference=entry.getValue();
|
||||
if(difference==1){start=entry.getKey();starts++;}
|
||||
else if(difference==-1)ends++;
|
||||
else if(difference!=0)return new ChainResult(null,"CHAIN_DISCONTINUITY");
|
||||
}
|
||||
if(!((starts==1&&ends==1)||(starts==0&&ends==0)))return new ChainResult(null,"CHAIN_DISCONTINUITY");
|
||||
if(prior!=null) {
|
||||
if(start!=null&&start.compareTo(prior)!=0)return new ChainResult(null,"CHAIN_DISCONTINUITY");
|
||||
start=prior;
|
||||
} else if(start==null)start=group.get(0).closing().subtract(group.get(0).delta());
|
||||
var first=orderedTrail(group,start,false);
|
||||
if(first==null)return new ChainResult(null,"CHAIN_DISCONTINUITY");
|
||||
// Without a prior balance a circuit with multiple edges admits rotated orders.
|
||||
if(prior==null&&starts==0&&group.size()>1)return new ChainResult(null,"CHAIN_ORDER_AMBIGUOUS");
|
||||
// Hierholzer with opposite edge priorities yields the lexicographically first
|
||||
// and last complete trails. Equality proves uniqueness, including parallel edges.
|
||||
// Input indices only define opposing priorities; neither IDs nor response order
|
||||
// are accepted as chronology. Two iterative passes avoid factorial search/recursion.
|
||||
var last=orderedTrail(group,start,true);
|
||||
if(!Arrays.equals(first,last))return new ChainResult(null,"CHAIN_ORDER_AMBIGUOUS");
|
||||
return new ChainResult(group.get(first[first.length-1]).closing(),null);
|
||||
}
|
||||
private static int[] orderedTrail(List<Flow> group,BigDecimal start,boolean reverse) {
|
||||
var outgoing=new TreeMap<BigDecimal,ArrayDeque<Integer>>();
|
||||
for(int i=0;i<group.size();i++) {
|
||||
var f=group.get(i);
|
||||
outgoing.computeIfAbsent(f.closing().subtract(f.delta()),k->new ArrayDeque<>()).addLast(i);
|
||||
}
|
||||
var stack=new ArrayDeque<Integer>();
|
||||
int[] trail=new int[group.size()];int position=trail.length;
|
||||
BigDecimal balance=start;
|
||||
while(true) {
|
||||
var edges=outgoing.get(balance);
|
||||
if(edges!=null&&!edges.isEmpty()) {
|
||||
int edge=reverse?edges.removeLast():edges.removeFirst();
|
||||
stack.push(edge);balance=group.get(edge).closing();
|
||||
} else {
|
||||
if(stack.isEmpty())break;
|
||||
int edge=stack.pop();trail[--position]=edge;
|
||||
var f=group.get(edge);balance=f.closing().subtract(f.delta());
|
||||
}
|
||||
}
|
||||
if(position!=0)return null; // Disconnected edges cannot be silently discarded.
|
||||
balance=start;
|
||||
for(int edge:trail) {
|
||||
var f=group.get(edge);
|
||||
if(balance.add(f.delta()).compareTo(f.closing())!=0)return null;
|
||||
balance=f.closing();
|
||||
}
|
||||
return trail;
|
||||
}
|
||||
public static boolean covered(List<Interval> intervals,Instant from,Instant until) {
|
||||
Instant cursor=from;
|
||||
for(Interval i:intervals.stream().sorted(Comparator.comparing(Interval::from)).toList()) {
|
||||
if(i.until().isBefore(cursor)) continue;
|
||||
if(i.from().isAfter(cursor)) return false;
|
||||
if(i.until().isAfter(cursor)) cursor=i.until();
|
||||
if(!cursor.isBefore(until)) return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
private static boolean quantity(BigDecimal value) { return value!=null && value.scale()<=6 && value.precision()-value.scale()<=14; }
|
||||
private static void requireKey(Key k) {
|
||||
if(k==null || k.sku()==null || k.sku().owner()==null || k.sku().owner().isBlank() || k.sku().sku()==null || k.sku().sku().isBlank())
|
||||
throw new IllegalArgumentException("HISTORY_IDENTITY_INVALID");
|
||||
}
|
||||
}
|
||||
+100
@@ -0,0 +1,100 @@
|
||||
package com.baiyue.lastleg.selfoperated.analytics.history;
|
||||
|
||||
import com.baomidou.mybatisplus.core.toolkit.IdWorker;
|
||||
import com.baiyue.lastleg.selfoperated.analytics.model.SelfopSupport;
|
||||
import org.springframework.jdbc.core.JdbcTemplate;
|
||||
import org.springframework.stereotype.Repository;
|
||||
import org.springframework.transaction.support.TransactionTemplate;
|
||||
import java.sql.Timestamp;
|
||||
import java.time.*;
|
||||
import java.util.*;
|
||||
import static com.baiyue.lastleg.selfoperated.analytics.history.InventoryHistoryCalculator.*;
|
||||
|
||||
/** Historical day heads have their own publication protocol, separate from raw stock runs. */
|
||||
@Repository
|
||||
public class InventoryHistoryVersions {
|
||||
private final JdbcTemplate jdbc;
|
||||
private final TransactionTemplate tx;
|
||||
public InventoryHistoryVersions(JdbcTemplate jdbc,TransactionTemplate tx) { this.jdbc=jdbc;this.tx=tx; }
|
||||
public record Build(String account,String warehouse,String scopeHash,long run,long group,long anchor,
|
||||
Long sales,String inputHash,String evidence,Map<LocalDate,Long> expectedHeads) {
|
||||
public Build { expectedHeads=Map.copyOf(expectedHeads); }
|
||||
}
|
||||
public record Candidate(long id,LocalDate date) { }
|
||||
public void lockWarehouse(String account,String warehouse) {
|
||||
var rows=jdbc.queryForList("SELECT id FROM ll_selfop_sync_scope WHERE source_account=? AND warehouse_code=? AND data_family='INVENTORY' FOR UPDATE",account,warehouse);
|
||||
if(rows.size()!=1) throw new IllegalStateException("HISTORY_SCOPE_MISSING");
|
||||
}
|
||||
/** Monotone revisions and no deletion make this fingerprint stable under the warehouse lock. */
|
||||
public String factHash(String account,String warehouse) {
|
||||
return SelfopSupport.hash(jdbc.queryForMap("SELECT COUNT(*) n,COALESCE(SUM(revision_no),0) revisions,COALESCE(MAX(id),0) newest FROM ll_selfop_inventory_flow WHERE source_account=? AND warehouse_code=?",account,warehouse));
|
||||
}
|
||||
public Map<LocalDate,Long> heads(String account,String warehouse,LocalDate from,LocalDate until) {
|
||||
var result=new TreeMap<LocalDate,Long>();
|
||||
jdbc.query("SELECT business_date,id FROM ll_selfop_inventory_day_version WHERE source_account=? AND warehouse_code=? AND head_slot=1 AND business_date>=? AND business_date<? ORDER BY business_date",
|
||||
rs->{result.put(rs.getDate(1).toLocalDate(),rs.getLong(2));},account,warehouse,from,until);
|
||||
return result;
|
||||
}
|
||||
public Candidate create(Build build,LocalDate date) {
|
||||
long id=IdWorker.getId();
|
||||
jdbc.update("INSERT INTO ll_selfop_inventory_day_version (id,source_account,warehouse_code,business_date,scope_hash,rule_version,build_run_id,publication_group_id,sales_run_id,anchor_run_id,input_hash,evidence_json,status,created_at) VALUES (?,?,?,?,?,?,?,?,?,?,?,?,'BUILDING',?)",
|
||||
id,build.account(),build.warehouse(),date,build.scopeHash(),RULE,build.run(),build.group(),build.sales(),build.anchor(),build.inputHash(),build.evidence(),now());
|
||||
return new Candidate(id,date);
|
||||
}
|
||||
/** Bounded insert transaction; a failed batch never changes visible day heads. */
|
||||
public void append(Candidate candidate,List<Daily> rows,String evidenceHash) {
|
||||
if(rows.size()>500 || rows.stream().anyMatch(r->!candidate.date().equals(r.date()))) throw new IllegalArgumentException("HISTORY_BATCH_INVALID");
|
||||
tx.executeWithoutResult(status->{
|
||||
String state=jdbc.queryForObject("SELECT status FROM ll_selfop_inventory_day_version WHERE id=? FOR UPDATE",String.class,candidate.id());
|
||||
if(!"BUILDING".equals(state)) throw new IllegalStateException("HISTORY_CANDIDATE_IMMUTABLE");
|
||||
jdbc.batchUpdate("INSERT INTO ll_selfop_inventory_daily (day_version_id,customer_code,sku_code,product_quality,physical_quantity,quality_status,quality_reason,anchor_reference,evidence_hash,source) VALUES (?,?,?,?,?,?,?,?,?,'FLOW_RECONSTRUCTED')",
|
||||
rows,500,(p,r)->{p.setLong(1,candidate.id());p.setString(2,r.key().sku().owner());p.setString(3,r.key().sku().sku());p.setInt(4,r.key().quality());
|
||||
p.setBigDecimal(5,r.quantity());p.setString(6,r.status());p.setString(7,r.reason());
|
||||
if(r.anchorRun()==0)p.setNull(8,java.sql.Types.BIGINT);else p.setLong(8,r.anchorRun());p.setString(9,evidenceHash);});
|
||||
});
|
||||
}
|
||||
public void ready(Candidate candidate,long expectedSkuCount) {
|
||||
tx.executeWithoutResult(s->{
|
||||
String state=jdbc.queryForObject("SELECT status FROM ll_selfop_inventory_day_version WHERE id=? FOR UPDATE",String.class,candidate.id());
|
||||
if(!"BUILDING".equals(state)) throw new IllegalStateException("HISTORY_CANDIDATE_IMMUTABLE");
|
||||
var totals=jdbc.queryForMap("SELECT COUNT(*) total,COALESCE(SUM(valid),0) valid FROM (SELECT customer_code,sku_code,MIN(CASE WHEN quality_status='VALID' THEN 1 ELSE 0 END) valid FROM ll_selfop_inventory_daily WHERE day_version_id=? GROUP BY customer_code,sku_code) x",candidate.id());
|
||||
long count=((Number)totals.get("total")).longValue(),valid=((Number)totals.get("valid")).longValue();
|
||||
if(count!=expectedSkuCount) throw new IllegalStateException("HISTORY_CANDIDATE_INCOMPLETE");
|
||||
jdbc.update("UPDATE ll_selfop_inventory_day_version SET status='READY',valid_sku_count=?,unknown_sku_count=? WHERE id=?",valid,count-valid,candidate.id());
|
||||
});
|
||||
}
|
||||
/** Must be called in the same warehouse-locked transaction that accepts a source revision. */
|
||||
public void invalidate(String account,String warehouse,long run,String reason) {
|
||||
jdbc.update("UPDATE ll_selfop_inventory_day_version SET invalidated_at=COALESCE(invalidated_at,?),invalidation_reason=COALESCE(invalidation_reason,?),rebuild_run_id=? WHERE source_account=? AND warehouse_code=? AND status IN ('PUBLISHED','SUPERSEDED')",
|
||||
now(),reason,run,account,warehouse);
|
||||
}
|
||||
public void publish(Build build,List<Candidate> candidates) {
|
||||
if(candidates.isEmpty() || candidates.size()>366 || candidates.stream().map(Candidate::date).distinct().count()!=candidates.size()) throw new IllegalArgumentException("HISTORY_GROUP_INVALID");
|
||||
tx.executeWithoutResult(s->{
|
||||
lockWarehouse(build.account(),build.warehouse());
|
||||
var stored=jdbc.queryForList("SELECT id,business_date,status FROM ll_selfop_inventory_day_version WHERE publication_group_id=? AND build_run_id=? AND source_account=? AND warehouse_code=? ORDER BY business_date FOR UPDATE",build.group(),build.run(),build.account(),build.warehouse());
|
||||
var expected=candidates.stream().map(Candidate::id).collect(java.util.stream.Collectors.toSet());
|
||||
if(stored.size()!=candidates.size() || stored.stream().anyMatch(r->!expected.contains(((Number)r.get("id")).longValue()))) throw new IllegalStateException("HISTORY_GROUP_INCOMPLETE");
|
||||
for(var row:stored) {
|
||||
var candidate=candidates.stream().filter(c->c.id()==((Number)row.get("id")).longValue()).findFirst().orElseThrow();
|
||||
if(!candidate.date().toString().equals(row.get("business_date").toString()))throw new IllegalStateException("HISTORY_GROUP_DATE_MISMATCH");
|
||||
}
|
||||
if(stored.stream().allMatch(r->"PUBLISHED".equals(r.get("status")))) return;
|
||||
if(!build.scopeHash().equals(jdbc.queryForObject("SELECT scope_hash FROM ll_selfop_sync_scope WHERE source_account=? AND warehouse_code=? AND data_family='INVENTORY'",String.class,build.account(),build.warehouse())))throw new IllegalStateException("HISTORY_SCOPE_CHANGED");
|
||||
if(!build.inputHash().equals(factHash(build.account(),build.warehouse()))) throw new IllegalStateException("HISTORY_INPUT_CHANGED");
|
||||
if(stored.stream().anyMatch(r->!"READY".equals(r.get("status")))) throw new IllegalStateException("HISTORY_GROUP_NOT_READY");
|
||||
for(var c:candidates) {
|
||||
var heads=jdbc.queryForList("SELECT id FROM ll_selfop_inventory_day_version WHERE source_account=? AND warehouse_code=? AND business_date=? AND head_slot=1",Long.class,build.account(),build.warehouse(),c.date());
|
||||
Long old=heads.isEmpty()?null:heads.get(0);
|
||||
if(!Objects.equals(old,build.expectedHeads().get(c.date()))) throw new IllegalStateException("HISTORY_HEAD_CHANGED");
|
||||
}
|
||||
var at=now();
|
||||
for(var c:candidates) {
|
||||
jdbc.update("UPDATE ll_selfop_inventory_day_version SET status='SUPERSEDED',head_slot=NULL,superseded_at=? WHERE source_account=? AND warehouse_code=? AND business_date=? AND head_slot=1",at,build.account(),build.warehouse(),c.date());
|
||||
int updated=jdbc.update("UPDATE ll_selfop_inventory_day_version SET status='PUBLISHED',head_slot=1,published_at=? WHERE id=? AND status='READY' AND invalidated_at IS NULL AND input_hash=?",at,c.id(),build.inputHash());
|
||||
if(updated!=1) throw new IllegalStateException("HISTORY_CANDIDATE_CHANGED");
|
||||
}
|
||||
});
|
||||
}
|
||||
private static LocalDateTime now() { return LocalDateTime.now(ZoneOffset.UTC); }
|
||||
}
|
||||
+56
@@ -0,0 +1,56 @@
|
||||
package com.baiyue.lastleg.selfoperated.analytics.history;
|
||||
|
||||
import com.baiyue.lastleg.selfoperated.analytics.model.*;
|
||||
import jakarta.annotation.PostConstruct;
|
||||
import jakarta.annotation.PreDestroy;
|
||||
import org.slf4j.Logger;
|
||||
import org.slf4j.LoggerFactory;
|
||||
import org.springframework.jdbc.core.JdbcTemplate;
|
||||
import org.springframework.stereotype.Component;
|
||||
import java.time.*;
|
||||
import java.time.temporal.TemporalAdjusters;
|
||||
import java.util.concurrent.*;
|
||||
|
||||
/** Two bounded lanes: provider pages never wait behind local reconstruction or the sales scheduler. */
|
||||
@Component
|
||||
public class InventoryHistoryWorker {
|
||||
private static final Logger LOG=LoggerFactory.getLogger(InventoryHistoryWorker.class);
|
||||
private final SelfopAnalyticsProperties config;private final InventoryFlowCollector collector;
|
||||
private final InventoryFlowFacts facts;private final InventoryHistoryBuilder builder;private final JdbcTemplate jdbc;
|
||||
private final ScheduledExecutorService http=Executors.newSingleThreadScheduledExecutor(r->{var t=new Thread(r,"selfop-history-pages");t.setDaemon(true);return t;});
|
||||
private final ScheduledExecutorService local=Executors.newSingleThreadScheduledExecutor(r->{var t=new Thread(r,"selfop-history-local");t.setDaemon(true);return t;});
|
||||
private Instant nextPlan=Instant.EPOCH;
|
||||
private Instant nextBuild=Instant.EPOCH;
|
||||
public InventoryHistoryWorker(SelfopAnalyticsProperties config,InventoryFlowCollector collector,InventoryFlowFacts facts,InventoryHistoryBuilder builder,JdbcTemplate jdbc){this.config=config;this.collector=collector;this.facts=facts;this.builder=builder;this.jdbc=jdbc;}
|
||||
boolean enabled(){return config.isInventoryHistoryEnabled()&&SelfopCollectionPolicy.continuousBusiness(config)&&"PCS".equals(config.getQuantityUnit())&&"Asia/Shanghai".equals(config.getSourceQueryTimezone());}
|
||||
@PostConstruct public void start(){http.scheduleWithFixedDelay(()->guard(this::page),10,1,TimeUnit.SECONDS);local.scheduleWithFixedDelay(()->guard(this::local),12000,100,TimeUnit.MILLISECONDS);}
|
||||
@PreDestroy public void close(){http.shutdownNow();local.shutdownNow();}
|
||||
private void guard(Runnable action){if(!enabled())return;try{action.run();}catch(RuntimeException e){LOG.warn("Historical inventory worker deferred ({})",e.getClass().getSimpleName());}}
|
||||
void page(){
|
||||
if(Instant.now().isAfter(nextPlan)){plan();nextPlan=Instant.now().plusSeconds(60);}
|
||||
collector.page();
|
||||
}
|
||||
void local(){
|
||||
facts.mergeNext(config.getSourceAccount());
|
||||
if(Instant.now().isBefore(nextBuild))return;
|
||||
nextBuild=Instant.now().plusSeconds(5);
|
||||
for(String warehouse:config.getWarehouses().keySet())if(enabled())builder.build(config.getSourceAccount(),warehouse,config.getInventoryHistoryDays());
|
||||
}
|
||||
void plan(){
|
||||
var now=LocalDateTime.now(ZoneOffset.ofHours(8));if(now.toLocalTime().isBefore(LocalTime.of(0,5)))return;
|
||||
var ids=jdbc.queryForList("SELECT id FROM ll_selfop_outbound_discovery_scope WHERE source_account=?",Long.class,config.getSourceAccount());if(ids.size()!=1)return;
|
||||
LocalDate today=now.toLocalDate();
|
||||
for(String warehouse:config.getWarehouses().keySet()) {
|
||||
var anchor=builder.anchor(config.getSourceAccount(),warehouse,0);if(anchor==null)continue;
|
||||
long published=jdbc.queryForObject("SELECT COUNT(*) FROM ll_selfop_inventory_day_version WHERE source_account=? AND warehouse_code=? AND head_slot=1 AND business_date>=? AND business_date<?",Long.class,config.getSourceAccount(),warehouse,today.minusDays(30),today);
|
||||
int days=published<30?30:Math.max(30,Math.min(60,config.getInventoryHistoryDays()));
|
||||
for(int age=1;age<=days;age++) {
|
||||
LocalDate day=today.minusDays(age);
|
||||
LocalDate round=age<=3?today:age<=30?today.with(TemporalAdjusters.previousOrSame(DayOfWeek.MONDAY)):LocalDate.of(2000,1,1);
|
||||
collector.plan(ids.get(0),new InventoryFlowSlice(warehouse,day.atStartOfDay(),day.plusDays(1).atStartOfDay(),1000),round);
|
||||
}
|
||||
var end=LocalDateTime.ofInstant(anchor.until(),ZoneOffset.ofHours(8)).withNano(0).plusSeconds(1);
|
||||
if(end.toLocalDate().equals(today)&&end.isAfter(today.atStartOfDay()))collector.plan(ids.get(0),new InventoryFlowSlice(warehouse,today.atStartOfDay(),end,1000),today);
|
||||
}
|
||||
}
|
||||
}
|
||||
+2
-2
@@ -15,11 +15,11 @@ public interface SelfopCoordinationMapper {
|
||||
SelfopSyncTask lockTask(long id);
|
||||
@Select("SELECT * FROM ll_selfop_sync_run WHERE id=#{id} FOR UPDATE")
|
||||
SelfopSyncRun lockRun(long id);
|
||||
@Select("SELECT * FROM ll_selfop_sync_task WHERE execution_purpose=#{purpose} AND status IN ('READY','RETRY_WAIT','RUNNING') AND (execution_purpose='BUSINESS' OR (status='READY' AND validation_root_task_id=id)) AND (next_retry_at_utc IS NULL OR next_retry_at_utc<=#{now}) ORDER BY CASE WHEN task_type IN ('RECHECK','REBUILD') THEN 1 WHEN task_role='WAREHOUSE_SYNC' THEN 0 WHEN task_type='BACKFILL' THEN 3 ELSE 2 END,id LIMIT #{limit}")
|
||||
@Select("SELECT * FROM ll_selfop_sync_task WHERE execution_purpose=#{purpose} AND task_type NOT IN ('INVENTORY_FLOW_PROBE','INVENTORY_FLOW_HISTORY','INVENTORY_HISTORY_BUILD') AND status IN ('READY','RETRY_WAIT','RUNNING') AND (execution_purpose='BUSINESS' OR (status='READY' AND validation_root_task_id=id)) AND (next_retry_at_utc IS NULL OR next_retry_at_utc<=#{now}) ORDER BY CASE WHEN task_type IN ('RECHECK','REBUILD') THEN 1 WHEN task_role='WAREHOUSE_SYNC' THEN 0 WHEN task_type='BACKFILL' THEN 3 ELSE 2 END,id LIMIT #{limit}")
|
||||
List<SelfopSyncTask> due(@Param("now") LocalDateTime now, @Param("limit") int limit, @Param("purpose") String purpose);
|
||||
// Started inventory work may resume across midnight; unstarted historical slots remain excluded.
|
||||
// Publication independently requires the planned day and observation day to match for daily samples.
|
||||
@Select("SELECT t.* FROM ll_selfop_sync_task t JOIN ll_selfop_sync_task r ON r.id=t.business_root_task_id AND r.business_root_task_id=r.id AND r.source_account=t.source_account AND r.execution_purpose='BUSINESS' AND r.validation_root_task_id IS NULL AND r.status<>'DEAD' WHERE t.source_account=#{account} AND t.execution_purpose='BUSINESS' AND t.validation_root_task_id IS NULL AND (r.request_key LIKE 'manual:%' OR (r.requested_by='SELFOP_CONTINUOUS_PLANNER' AND r.request_key LIKE 'continuous:%')) AND t.status IN ('READY','RETRY_WAIT','RUNNING') AND (t.next_retry_at_utc IS NULL OR t.next_retry_at_utc<=#{now}) AND (r.request_key NOT LIKE 'continuous:inventory:%' OR DATE(DATE_ADD(r.planned_at_utc,INTERVAL 8 HOUR))=DATE(DATE_ADD(#{now},INTERVAL 8 HOUR)) OR (r.attempt_count>0 AND r.planned_at_utc<=#{now})) ORDER BY CASE WHEN r.task_role='ACCOUNT_DISCOVERY' AND r.query_until_utc>=DATE_SUB(DATE(DATE_ADD(#{now},INTERVAL 8 HOUR)),INTERVAL 8 HOUR) THEN 0 WHEN r.request_key LIKE 'continuous:inventory:%' THEN 1 WHEN t.task_role='WAREHOUSE_SYNC' THEN 2 WHEN t.task_type IN ('RECHECK','REBUILD') THEN 3 ELSE 4 END,t.query_until_utc DESC,t.id LIMIT #{limit}")
|
||||
@Select("SELECT t.* FROM ll_selfop_sync_task t JOIN ll_selfop_sync_task r ON r.id=t.business_root_task_id AND r.business_root_task_id=r.id AND r.source_account=t.source_account AND r.execution_purpose='BUSINESS' AND r.validation_root_task_id IS NULL AND r.status<>'DEAD' WHERE t.task_type NOT IN ('INVENTORY_FLOW_HISTORY','INVENTORY_HISTORY_BUILD') AND t.source_account=#{account} AND t.execution_purpose='BUSINESS' AND t.validation_root_task_id IS NULL AND (r.request_key LIKE 'manual:%' OR (r.requested_by='SELFOP_CONTINUOUS_PLANNER' AND r.request_key LIKE 'continuous:%')) AND t.status IN ('READY','RETRY_WAIT','RUNNING') AND (t.next_retry_at_utc IS NULL OR t.next_retry_at_utc<=#{now}) AND (r.request_key NOT LIKE 'continuous:inventory:%' OR DATE(DATE_ADD(r.planned_at_utc,INTERVAL 8 HOUR))=DATE(DATE_ADD(#{now},INTERVAL 8 HOUR)) OR (r.attempt_count>0 AND r.planned_at_utc<=#{now})) ORDER BY CASE WHEN r.task_role='ACCOUNT_DISCOVERY' AND r.query_until_utc>=DATE_SUB(DATE(DATE_ADD(#{now},INTERVAL 8 HOUR)),INTERVAL 8 HOUR) THEN 0 WHEN r.request_key LIKE 'continuous:inventory:%' THEN 1 WHEN t.task_role='WAREHOUSE_SYNC' THEN 2 WHEN t.task_type IN ('RECHECK','REBUILD') THEN 3 ELSE 4 END,t.query_until_utc DESC,t.id LIMIT #{limit}")
|
||||
List<SelfopSyncTask> dueContinuous(@Param("now") LocalDateTime now,@Param("limit") int limit,@Param("account") String account);
|
||||
@Select("SELECT COUNT(*) FROM ll_selfop_sync_task WHERE source_account=#{account} AND apply_state IN ('APPLYING','BLOCKED') AND JSON_CONTAINS(affected_warehouse_codes_json,JSON_QUOTE(#{warehouse}))")
|
||||
long barriers(@Param("account") String account, @Param("warehouse") String warehouse);
|
||||
|
||||
+3
@@ -15,6 +15,9 @@ public class SelfopAnalyticsProperties {
|
||||
private String collectionMode = "OFF";
|
||||
/** Explicit account-owner continuous BUSINESS planner/egress mode; off by default. */
|
||||
private boolean continuousBusinessCollectionEnabled = false;
|
||||
/** Requires the history tables and both services from the same release. */
|
||||
private boolean inventoryHistoryEnabled = false;
|
||||
private int inventoryHistoryDays = 60;
|
||||
private String environment = "test";
|
||||
private String exclusiveGrantId;
|
||||
private LocalDateTime exclusiveGrantExpiresAtUtc;
|
||||
|
||||
+11
@@ -37,6 +37,17 @@ public final class SelfopCollectionPolicy {
|
||||
if(task==null||!"BUSINESS".equals(task.getExecutionPurpose())||task.getUpstreamTaskId()!=null
|
||||
||task.getValidationRootTaskId()!=null||!CONTINUOUS_PLANNER.equals(task.getRequestedBy())||task.getScopeHash()==null||!task.getScopeHash().matches("[a-f0-9]{64}"))return false;
|
||||
String key=task.getRequestKey();if(key==null)return false;
|
||||
if(com.baiyue.lastleg.selfoperated.analytics.history.InventoryFlowSlice.TYPE.equals(task.getTaskType())) {
|
||||
try {
|
||||
var slice=read(task.getQueryScopeJson(),com.baiyue.lastleg.selfoperated.analytics.history.InventoryFlowSlice.class);
|
||||
return "ACCOUNT_DISCOVERY".equals(task.getTaskRole())&&task.getDiscoveryScopeId()!=null&&task.getScopeId()==null
|
||||
&&task.getWarehouseCode()==null&&task.getPlannedAtUtc()!=null&&task.getId().equals(task.getBusinessRootTaskId())
|
||||
&&task.getScopeHash().equals(SelfopSupport.hash(slice))&&task.getRequestHash().equals(task.getScopeHash())
|
||||
&&key.equals("continuous:history:"+task.getPlannedAtUtc().toLocalDate()+":"+task.getScopeHash())
|
||||
&&java.time.LocalDateTime.ofInstant(slice.from(),java.time.ZoneOffset.UTC).equals(task.getQueryFromUtc())
|
||||
&&java.time.LocalDateTime.ofInstant(slice.until(),java.time.ZoneOffset.UTC).equals(task.getQueryUntilUtc());
|
||||
}catch(RuntimeException invalid){return false;}
|
||||
}
|
||||
if("MASTER_DATA".equals(task.getTaskType())) {
|
||||
if(!"ACCOUNT_DISCOVERY".equals(task.getTaskRole())||task.getDiscoveryScopeId()==null||task.getScopeId()!=null
|
||||
||task.getWarehouseCode()!=null||task.getPlannedAtUtc()==null||task.getQueryFromUtc()!=null||task.getQueryUntilUtc()!=null)return false;
|
||||
|
||||
+35
-13
@@ -9,11 +9,13 @@ import org.springframework.beans.factory.annotation.Autowired;
|
||||
import org.springframework.stereotype.Component;
|
||||
import static com.baiyue.lastleg.selfoperated.analytics.query.InventoryTurnoverResponses.*;
|
||||
|
||||
/** Tokens carry evidence, not authority: all versions and missing dates are reconstructed at asOf. */
|
||||
/** Signed evidence fixes exact committed day versions; corrections explicitly revoke their validity. */
|
||||
@Component
|
||||
public class InventoryTurnoverContext {
|
||||
static final ZoneId ZONE=ZoneId.of("Asia/Shanghai");
|
||||
static final String RULE="DAILY_SCHEDULED_FIRST_V1";
|
||||
static final String RULE="FLOW_EOD_V1";
|
||||
// A service restart expires open pages/exports, which must request a fresh consistent snapshot.
|
||||
private static final byte[] TOKEN_KEY=new java.security.SecureRandom().generateSeed(32);
|
||||
private final AnalyticsReadMapper analytics;
|
||||
private final InventoryTurnoverReadMapper mapper;
|
||||
private final ObjectMapper json;
|
||||
@@ -28,7 +30,7 @@ public class InventoryTurnoverContext {
|
||||
}
|
||||
public record Evidence(String account,String warehouse,LocalDate end,int days,Instant asOf,
|
||||
Long salesRun,Long inventoryRun,String salesHash,String inventoryHash,boolean rebuild,
|
||||
String samplesHash,LocalDate accumulationStartedOn) {}
|
||||
String samplesHash,LocalDate accumulationStartedOn,String rule,List<Sample> versions) {}
|
||||
record Frozen(Context response,AnalyticsQueryService.Snapshot snapshot) {}
|
||||
Frozen resolve(InventoryTurnoverRequest q) {
|
||||
Instant now=clock.instant(); q.validate(now.atZone(ZONE).toLocalDate());
|
||||
@@ -37,39 +39,59 @@ public class InventoryTurnoverContext {
|
||||
if(asOf==null||asOf.isAfter(now)||!now.isBefore(asOf.plusSeconds(1800))) throw refresh();
|
||||
LocalDate end=q.end(asOf.atZone(ZONE).toLocalDate());
|
||||
if(supplied!=null&&(!Objects.equals(q.sourceAccount(),supplied.account())||!Objects.equals(q.warehouseCode(),supplied.warehouse())
|
||||
||!end.equals(supplied.end())||q.days()!=supplied.days())) throw refresh();
|
||||
||!end.equals(supplied.end())||q.days()!=supplied.days()||!RULE.equals(supplied.rule())||supplied.versions()==null)) throw refresh();
|
||||
var scopes=analytics.scopes(q.sourceAccount(),q.warehouseCode());
|
||||
var sales=version(scopes,"OUTBOUND",asOf); var stock=version(scopes,"INVENTORY",asOf);
|
||||
var sales=supplied==null?version(scopes,"OUTBOUND",asOf):fixed(supplied.salesRun());
|
||||
var stock=supplied==null?version(scopes,"INVENTORY",asOf):fixed(supplied.inventoryRun());
|
||||
var aq=new AnalyticsQuery(q.sourceAccount(),q.warehouseCode(),null,null,"CUSTOM",end.minusDays(Math.max(30,q.days())-1),end,"DAY",null,1,20,
|
||||
sales==null?0L:sales.id(),stock==null?0L:stock.id(),sales==null?null:sales.scopeHash(),stock==null?null:stock.scopeHash(),asOf);
|
||||
// Staleness is evaluated at queryAsOf, so pagination does not age a fixed snapshot midway.
|
||||
var snapshot=new AnalyticsQueryService(analytics,json,Clock.fixed(asOf,ZoneOffset.UTC),ownerDirectory).context(aq,true,false,false,null);
|
||||
String inventoryHash=scopes.stream().filter(s->"INVENTORY".equals(s.dataFamily())).map(AnalyticsReadRows.Scope::scopeHash).findFirst().orElse(null);
|
||||
var mapping=new TreeMap<LocalDate,Long>();
|
||||
for(var sample:mapper.samples(q.sourceAccount(),q.warehouseCode(),inventoryHash,utc(asOf),end.minusDays(Math.max(30,q.days())-1),end.plusDays(1))) {
|
||||
if(sample.sampleDate()==null||sample.runId()==null||sample.runId()<=0||sample.sampleDate().isBefore(end.minusDays(Math.max(30,q.days())-1))||sample.sampleDate().isAfter(end)
|
||||
||mapping.put(sample.sampleDate(),sample.runId())!=null) throw refresh();
|
||||
List<InventoryTurnoverReadMapper.DayVersion> selected;
|
||||
if(supplied==null)selected=mapper.samples(q.sourceAccount(),q.warehouseCode(),inventoryHash,utc(asOf),end.minusDays(Math.max(30,q.days())-1),end.plusDays(1));
|
||||
else {
|
||||
if(supplied.versions().size()>366||supplied.versions().stream().anyMatch(v->v==null||v.dayVersionId()==null||v.dayVersionId()<=0))throw refresh();
|
||||
selected=supplied.versions().isEmpty()?List.of():mapper.fixedSamples(q.sourceAccount(),q.warehouseCode(),inventoryHash,supplied.versions().stream().map(Sample::dayVersionId).toList());
|
||||
if(!selected.stream().map(v->new Sample(v.sampleDate(),v.dayVersionId())).toList().equals(supplied.versions()))throw refresh();
|
||||
}
|
||||
for(var sample:selected) {
|
||||
if(sample.sampleDate()==null||sample.dayVersionId()==null||sample.dayVersionId()<=0||sample.sampleDate().isBefore(end.minusDays(Math.max(30,q.days())-1))||sample.sampleDate().isAfter(end)
|
||||
||mapping.put(sample.sampleDate(),sample.dayVersionId())!=null) throw refresh();
|
||||
}
|
||||
List<Sample> samples=new ArrayList<>();
|
||||
for(LocalDate date=end.minusDays(Math.max(30,q.days())-1);!date.isAfter(end);date=date.plusDays(1)) samples.add(new Sample(date,mapping.get(date)));
|
||||
var began=mapper.accumulationStartedOn(q.sourceAccount(),q.warehouseCode(),inventoryHash,utc(asOf));
|
||||
var began=supplied==null?mapper.accumulationStartedOn(q.sourceAccount(),q.warehouseCode(),inventoryHash,utc(asOf)):supplied.accumulationStartedOn();
|
||||
var c=snapshot.context();
|
||||
var evidence=new Evidence(q.sourceAccount(),q.warehouseCode(),end,q.days(),asOf,c.salesRunId(),c.inventoryRunId(),
|
||||
c.salesScopeHash(),c.inventoryScopeHash(),c.rebuildRequired(),samplesHash(samples),began);
|
||||
c.salesScopeHash(),c.inventoryScopeHash(),c.rebuildRequired(),samplesHash(samples),began,RULE,samples.stream().filter(v->v.dayVersionId()!=null).toList());
|
||||
if(supplied!=null&&!supplied.equals(evidence)) throw refresh();
|
||||
return new Frozen(new Context(encode(evidence),q.sourceAccount(),q.warehouseCode(),end,q.days(),asOf,c.queryExpiresAt(),c,
|
||||
c.inventoryObservedFrom(),c.inventoryObservedUntil(),RULE,List.copyOf(samples),samples.stream().filter(s->s.runId()==null).map(Sample::date).toList(),began),snapshot);
|
||||
c.inventoryObservedFrom(),c.inventoryObservedUntil(),RULE,List.copyOf(samples),samples.stream().filter(s->s.dayVersionId()==null).map(Sample::date).toList(),began),snapshot);
|
||||
}
|
||||
private AnalyticsReadRows.Run fixed(Long id){if(id==null||id==0)return null;var run=analytics.publishedRun(id);if(run==null)throw refresh();return run;}
|
||||
private AnalyticsReadRows.Run version(List<AnalyticsReadRows.Scope> scopes,String family,Instant asOf) {
|
||||
var scope=scopes.stream().filter(s->family.equals(s.dataFamily())).findFirst().orElse(null);
|
||||
return scope==null?null:mapper.versionAt(scope.id(),scope.scopeHash(),utc(asOf));
|
||||
}
|
||||
private Evidence decode(String token) {
|
||||
try {var value=json.readValue(Base64.getUrlDecoder().decode(token),Evidence.class);if(value==null)throw refresh();return value;} catch(Exception e){throw refresh();}
|
||||
try {
|
||||
if(token.length()>16000)throw refresh();var parts=token.split("\\.",-1);if(parts.length!=2)throw refresh();
|
||||
byte[] compressed=Base64.getUrlDecoder().decode(parts[0]);
|
||||
if(!java.security.MessageDigest.isEqual(sign(compressed),Base64.getUrlDecoder().decode(parts[1])))throw refresh();
|
||||
try(var gzip=new java.util.zip.GZIPInputStream(new java.io.ByteArrayInputStream(compressed))){
|
||||
byte[] bytes=gzip.readNBytes(65537);if(bytes.length>65536)throw refresh();
|
||||
var value=json.readValue(bytes,Evidence.class);if(value==null)throw refresh();return value;
|
||||
}
|
||||
} catch(Exception e){throw refresh();}
|
||||
}
|
||||
private String encode(Evidence evidence) {
|
||||
try{return Base64.getUrlEncoder().withoutPadding().encodeToString(json.writeValueAsBytes(evidence));}catch(Exception e){throw new IllegalStateException("Cannot encode turnover context",e);}
|
||||
try{var output=new java.io.ByteArrayOutputStream();try(var gzip=new java.util.zip.GZIPOutputStream(output)){gzip.write(json.writeValueAsBytes(evidence));}
|
||||
byte[] data=output.toByteArray();var b64=Base64.getUrlEncoder().withoutPadding();return b64.encodeToString(data)+"."+b64.encodeToString(sign(data));
|
||||
}catch(Exception e){throw new IllegalStateException("Cannot encode turnover context",e);}
|
||||
}
|
||||
private static byte[] sign(byte[] bytes)throws java.security.GeneralSecurityException{var mac=javax.crypto.Mac.getInstance("HmacSHA256");mac.init(new javax.crypto.spec.SecretKeySpec(TOKEN_KEY,"HmacSHA256"));return mac.doFinal(bytes);}
|
||||
private String samplesHash(List<Sample> samples) {
|
||||
// Reconstruct the entire ordered calendar at asOf before comparing its digest.
|
||||
// Keep the GET pagination token bounded even for a full year of samples.
|
||||
|
||||
+133
@@ -0,0 +1,133 @@
|
||||
package com.baiyue.lastleg.selfoperated.analytics.query;
|
||||
|
||||
import com.baiyue.common.core.export.ExportContracts.*;
|
||||
import com.baiyue.common.core.exception.BizException;
|
||||
import com.fasterxml.jackson.databind.ObjectMapper;
|
||||
import org.springframework.stereotype.Service;
|
||||
import java.math.BigDecimal;
|
||||
import java.math.RoundingMode;
|
||||
import java.util.*;
|
||||
import static com.baiyue.lastleg.selfoperated.analytics.query.InventoryTurnoverResponses.*;
|
||||
|
||||
/** Download-center projection: the browser supplies column keys, never headings or cell values. */
|
||||
@Service
|
||||
public class InventoryTurnoverExport {
|
||||
public static final String TYPE = "SELFOP_INVENTORY_TURNOVER";
|
||||
private final InventoryTurnoverQueryService queries;
|
||||
private final ObjectMapper json;
|
||||
public InventoryTurnoverExport(InventoryTurnoverQueryService queries, ObjectMapper json) { this.queries=queries; this.json=json; }
|
||||
private static final Map<String,String> LABELS = Map.ofEntries(
|
||||
Map.entry("sku","SKU"), Map.entry("productName","商品名称"), Map.entry("customerCode","所属货主"),
|
||||
Map.entry("physicalQuantity","实物件数"), Map.entry("availableQuantity","正品可售"), Map.entry("transitQuantity","在途"),
|
||||
Map.entry("frozenQuantity","冻结件数"), Map.entry("defectiveQuantity","次品实物"), Map.entry("physicalSkuCount","有实物SKU数"),
|
||||
Map.entry("inventoryVolumeM3","库存立方数"), Map.entry("outboundVolumesM3","出库立方数"), Map.entry("unitVolumeM3","单件体积"),
|
||||
Map.entry("outbound7","7日出库"), Map.entry("outbound15","15日出库"), Map.entry("outbound30","30日出库"),
|
||||
Map.entry("averageDailyOutboundQuantity","日均"), Map.entry("inventoryCoverageDays","预计可售天数"),
|
||||
Map.entry("quantityTurnoverRate","期间周转率"), Map.entry("quantityTurnoverCount","期间件数周转"),
|
||||
Map.entry("averagePhysicalQuantity","期间平均实物"), Map.entry("lastObservedOutboundDate","最近已观测出库日"),
|
||||
Map.entry("noOutboundInWindow","无出库SKU / 实物"), Map.entry("slowCoverage","慢消化SKU / 待判断"),
|
||||
Map.entry("period","统计期间"), Map.entry("periodOutbound","期间出库件数"), Map.entry("historySource","历史库存来源"),
|
||||
Map.entry("historyDays","合格历史库存天数"), Map.entry("historyReason","历史库存说明"));
|
||||
private static final List<String> REQUIRED = List.of("period","periodOutbound","averagePhysicalQuantity","quantityTurnoverRate","historySource","historyDays","historyReason");
|
||||
|
||||
public ExportBatchResponse batch(ExportBatchRequest request, int offset, String signature) {
|
||||
if(request.limit()>100) throw invalid("库存周转每批最多100条");
|
||||
Map<String,Object> parameters=new LinkedHashMap<>(request.parameters()==null?Map.of():request.parameters());
|
||||
Object rawColumns=parameters.remove("columns"), rawTotal=parameters.remove("expectedTotal");
|
||||
if(!(rawColumns instanceof List<?> selected)||selected.isEmpty()||selected.size()>LABELS.size()) throw invalid("导出列无效");
|
||||
Set<String> keys=new LinkedHashSet<>();
|
||||
for(Object key:selected) if(!(key instanceof String s)||!LABELS.containsKey(s)||!keys.add(s)) throw invalid("导出列重复或不支持");
|
||||
keys.addAll(REQUIRED);
|
||||
long expected;
|
||||
try { expected=new BigDecimal(String.valueOf(rawTotal)).longValueExact(); }
|
||||
catch(RuntimeException e) { throw invalid("导出条数无效"); }
|
||||
if(expected<0||expected>200000||offset>expected) throw invalid("导出条数超出范围");
|
||||
if(parameters.containsKey("current")||parameters.containsKey("size")||parameters.containsKey("includeOverview")) throw invalid("导出不接受列表分页参数");
|
||||
InventoryTurnoverRequest.validateParameters(parameters.keySet());
|
||||
parameters.put("current",offset/request.limit()+1);parameters.put("size",request.limit());parameters.put("includeOverview",false);
|
||||
InventoryTurnoverRequest query;
|
||||
try { query=json.convertValue(parameters,InventoryTurnoverRequest.class); }
|
||||
catch(IllegalArgumentException e) { throw invalid("导出筛选无效"); }
|
||||
if(query.snapshotContext()==null||query.snapshotContext().isBlank()||query.endDate()==null||query.baseWindowDays()==null) throw invalid("请先查询后导出");
|
||||
boolean owner="OWNER".equals(query.group());
|
||||
if(owner&&(keys.contains("sku")||keys.contains("productName")||keys.contains("unitVolumeM3")||keys.contains("inventoryCoverageDays"))
|
||||
||!owner&&(keys.contains("physicalSkuCount")||keys.contains("noOutboundInWindow")||keys.contains("slowCoverage"))) throw invalid("导出列不适用于当前分组");
|
||||
Response result=queries.query(query);
|
||||
if(result.total()!=expected||!query.snapshotContext().equals(result.context().snapshotContext())
|
||||
||result.rows().size()!=Math.min(request.limit(),expected-offset)) throw invalid("导出数据范围或版本已变化，请整体刷新后重新导出");
|
||||
Set<List<String>> seen=new HashSet<>();
|
||||
for(Row row:result.rows()) if(!seen.add(Arrays.asList(row.customerCode(),row.sku()))) throw invalid("导出数据重复");
|
||||
List<ExportColumn> columns=keys.stream().map(key->new ExportColumn(key,title(key,query),ExportColumnType.STRING,24)).toList();
|
||||
List<Map<String,Object>> rows=result.rows().stream().map(row->{
|
||||
Map<String,Object> values=new LinkedHashMap<>();for(String key:keys)values.put(key,cell(row,key,query));return values;
|
||||
}).toList();
|
||||
String hash;
|
||||
try { hash="sha256:"+HexFormat.of().formatHex(java.security.MessageDigest.getInstance("SHA-256").digest(json.writeValueAsBytes(columns))); }
|
||||
catch(Exception e) { throw new IllegalStateException("Cannot hash turnover export columns",e); }
|
||||
long next=offset+rows.size();
|
||||
return new ExportBatchResponse(1,hash,signature,request.snapshotToken()==null?columns:List.of(),rows,String.valueOf(next),next<expected,request.snapshotToken()==null?expected:null);
|
||||
}
|
||||
private static String title(String key,InventoryTurnoverRequest q) {
|
||||
if(key.equals("outboundVolumesM3"))return q.days()+"日出库立方数";
|
||||
if(key.equals("averageDailyOutboundQuantity"))return q.days()+"日日均";
|
||||
return LABELS.get(key);
|
||||
}
|
||||
static String cell(Row r,String key,InventoryTurnoverRequest q) {
|
||||
return switch(key) {
|
||||
case "sku" -> text(r.sku()); case "productName" -> text(r.productName());
|
||||
case "customerCode" -> r.customerName()==null||r.customerName().isBlank()?text(r.customerCode()):r.customerName();
|
||||
case "physicalQuantity" -> total(r.physicalQuantity()); case "availableQuantity" -> total(r.availableQuantity());
|
||||
case "transitQuantity" -> total(r.transitQuantity()); case "frozenQuantity" -> total(r.frozenQuantity()); case "defectiveQuantity" -> total(r.defectiveQuantity());
|
||||
case "physicalSkuCount" -> number(r.physicalSkuCount(),2);
|
||||
case "inventoryVolumeM3" -> volume(r.inventoryVolumeM3(),false);
|
||||
case "outboundVolumesM3" -> volume(r.outboundVolumesM3().stream().filter(v->v.days()==q.days()).map(VolumeWindow::volume).findFirst().orElse(null),true);
|
||||
case "unitVolumeM3" -> number(r.unitVolumeM3(),9)+(r.unitVolumeM3()==null?"":" m³")+"；"+switch(text(r.dimensionSource())) { case "WAREHOUSE_MEASURED" -> "仓库实测尺寸";case "PRODUCT_DECLARED" -> "商品尺寸估算";default -> "缺少有效尺寸"; };
|
||||
case "outbound7","outbound15","outbound30" -> window(r,Integer.parseInt(key.substring(8)));
|
||||
case "periodOutbound" -> window(r,q.days());
|
||||
case "averageDailyOutboundQuantity" -> number(r.averageDailyOutboundQuantity(),2);
|
||||
case "inventoryCoverageDays" -> number(r.inventoryCoverageDays(),1)+"；"+reason(r.coverageStatus());
|
||||
case "averagePhysicalQuantity" -> number(r.averagePhysicalQuantity(),2);
|
||||
case "quantityTurnoverRate" -> r.quantityTurnoverCount()==null?"—":number(r.quantityTurnoverCount().multiply(BigDecimal.valueOf(100)),2)+"%";
|
||||
case "quantityTurnoverCount" -> r.quantityTurnoverCount()==null?"—":number(r.quantityTurnoverCount(),2)+" 次/"+q.days()+"日";
|
||||
case "period" -> "截至 "+q.endDate()+"，最近 "+q.days()+" 天";
|
||||
case "historySource" -> "库存流水还原（日末实物库存）";
|
||||
case "historyDays" -> r.qualifiedSampleDays()+"/"+r.requiredSampleDays();
|
||||
case "historyReason" -> reasons(r.sampleReasonCodes());
|
||||
case "lastObservedOutboundDate" -> r.lastObservedOutboundDate()==null?"已采集历史内未见出库":r.lastObservedOutboundDate().toString();
|
||||
case "noOutboundInWindow" -> number(r.noOutboundInWindow().matchedSkuCount(),2)+" SKU / "+number(r.noOutboundInWindow().knownPhysicalQuantity(),2)+" 件；待判断 "+r.noOutboundInWindow().unknownSkuCount()+" SKU";
|
||||
case "slowCoverage" -> q.coverageDaysThreshold()==null?"未设查询阈值":number(r.slowCoverage().matchedSkuCount(),2)+" SKU / "+r.slowCoverage().unknownSkuCount()+" SKU";
|
||||
default -> throw invalid("不支持的导出列");
|
||||
};
|
||||
}
|
||||
static String number(BigDecimal value,int decimals) {
|
||||
if(value==null)return "—";
|
||||
BigDecimal threshold=BigDecimal.ONE.movePointLeft(decimals);
|
||||
if(value.signum()>0&&value.compareTo(threshold)<0)return "<"+threshold.setScale(decimals).toPlainString();
|
||||
var f=new java.text.DecimalFormat("#,##0"+(decimals>0?"."+"#".repeat(decimals):""),java.text.DecimalFormatSymbols.getInstance(Locale.ROOT));
|
||||
f.setRoundingMode(RoundingMode.HALF_UP);return f.format(value);
|
||||
}
|
||||
private static String total(Total t) {
|
||||
if(t.value()!=null)return number(t.value(),2);
|
||||
if(t.knownSubtotal()==null&&t.unknownSkuCount()==0)return reasons(t.reasonCodes());
|
||||
return "已知 "+number(t.knownSubtotal(),2)+"；"+t.unknownSkuCount()+" SKU待核验";
|
||||
}
|
||||
private static String window(Row r,int days) {
|
||||
return r.windows().stream().filter(w->w.days()==days).findFirst().map(w->"COMPLETE".equals(w.dataStatus())?number(w.outboundQuantity(),2):"已采集 "+number(w.observedQuantity(),2)+"，覆盖不足").orElse("—");
|
||||
}
|
||||
private static String volume(Volume v,boolean outbound) {
|
||||
if(v==null)return "—；数量或尺寸待确认";
|
||||
List<String> notes=new ArrayList<>();
|
||||
if(v.value()==null)notes.add(v.knownSubtotal()==null?"暂无已知小计":"已知小计 "+number(v.knownSubtotal(),6)+" m³");
|
||||
if(v.missingDimensionSkuCount()>0)notes.add("缺尺寸 "+v.missingDimensionSkuCount()+" SKU / "+number(v.missingDimensionQuantity(),2)+" 件");
|
||||
if(v.unknownQuantitySkuCount()>0)notes.add("数量待确认 "+v.unknownQuantitySkuCount()+" SKU");
|
||||
if(v.declaredDimensionQuantity()!=null&&v.declaredDimensionQuantity().signum()>0)notes.add("其中 "+number(v.declaredDimensionQuantity(),2)+" 件按商品尺寸估算");
|
||||
if(outbound)notes.add("按当前商品尺寸估算");
|
||||
else if(v.value()!=null&&v.value().signum()==0)notes.add("已知体积为0");
|
||||
else if(v.value()!=null&&(v.declaredDimensionQuantity()==null||v.declaredDimensionQuantity().signum()==0))notes.add("按仓库实测尺寸计算");
|
||||
return number(v.value(),6)+(v.value()==null?"":" m³")+"；"+(notes.isEmpty()?"数量或尺寸待确认":String.join("；",notes));
|
||||
}
|
||||
private static String reasons(List<String> reasons){return reasons==null||reasons.isEmpty()?"—":String.join("、",reasons.stream().map(InventoryTurnoverExport::reason).toList());}
|
||||
private static String reason(String reason){return TurnoverExportReasons.LABELS.getOrDefault(reason==null?"":reason,"数据待核验");}
|
||||
private static String text(String value){return value==null||value.isBlank()?"—":value;}
|
||||
private static BizException invalid(String message){return new BizException(message);}
|
||||
}
|
||||
+6
-1
@@ -77,11 +77,16 @@ public final class InventoryTurnoverPolicy {
|
||||
if(decimal(r,"frozen")!=null&&decimal(r,"frozen").signum()>0)attention.add("FROZEN_STOCK");
|
||||
if(decimal(r,"defective")!=null&&decimal(r,"defective").signum()>0)attention.add("DEFECTIVE_STOCK");
|
||||
if(count(r,"unassessable")>0)attention.add("UNASSESSABLE");
|
||||
var sampleReasons=new LinkedHashSet<String>();
|
||||
if(!"VALID".equals(sampleStatus)) {
|
||||
sampleReasons.add(sampleStatus);String historyReasons=text(r,"history_reasons");
|
||||
if(historyReasons!=null&&!historyReasons.isBlank())sampleReasons.addAll(Arrays.asList(historyReasons.split(",")));
|
||||
}
|
||||
String last=text(r,"last_outbound");
|
||||
return new Row(text(r,"customer_code"),text(r,"customer_name"),owner?null:text(r,"sku_code"),owner?null:text(r,"product_name"),physical,available,
|
||||
total(r,"frozen",owner),total(r,"defective",owner),total(r,"transit",owner),owner?decimal(r,"physical_skus"):physical.value()==null?null:physical.value().signum()>0?BigDecimal.ONE:BigDecimal.ZERO,
|
||||
windows,base.averageDailyOutboundQuantity(),coverage,coverageStatus,average,turnover,sampleStatus,sampleCount,q.days(),List.copyOf(missing),
|
||||
"VALID".equals(sampleStatus)?List.of():List.of(sampleStatus),last==null?null:LocalDate.parse(last.substring(0,10)),List.copyOf(attention),
|
||||
List.copyOf(sampleReasons),last==null?null:LocalDate.parse(last.substring(0,10)),List.copyOf(attention),
|
||||
risk(r,"no_outbound",physical,owner,true),risk(r,"slow",physical,owner,q.coverageDaysThreshold()!=null),count(r,"unassessable"),
|
||||
owner?null:decimal(r,"unit_volume"),owner?null:text(r,"dimension_source"),volume(r,"physical"),volumeWindows(r,context.endDate().plusDays(1),q.windows()));
|
||||
}
|
||||
|
||||
+10
-17
@@ -8,29 +8,22 @@ import org.apache.ibatis.annotations.*;
|
||||
|
||||
@Mapper
|
||||
public interface InventoryTurnoverReadMapper {
|
||||
record SampleRun(LocalDate sampleDate,Long runId) {}
|
||||
record DayVersion(LocalDate sampleDate,Long dayVersionId) {}
|
||||
@Select("SELECT "+AnalyticsReadMapper.RUN_COLUMNS+" FROM ll_selfop_sync_run WHERE scope_id=#{scopeId} "
|
||||
+"AND scope_hash=#{scopeHash} AND status='PUBLISHED' AND run_role='WAREHOUSE_SYNC' AND execution_purpose='BUSINESS' "
|
||||
+"AND published_at_utc<=#{asOf} ORDER BY published_at_utc DESC,id DESC LIMIT 1")
|
||||
AnalyticsReadRows.Run versionAt(@Param("scopeId") Long scopeId,@Param("scopeHash") String scopeHash,@Param("asOf") LocalDateTime asOf);
|
||||
|
||||
// The immutable first-daily marker is set only by publication. Recheck its original schedule evidence.
|
||||
String SAMPLE_WHERE=" r.source_account=#{account} AND r.warehouse_code=#{warehouse} AND r.scope_hash=#{scopeHash,jdbcType=VARCHAR} "
|
||||
+"AND r.inventory_sample_rule_version='DAILY_SCHEDULED_FIRST_V1' AND r.status='PUBLISHED' "
|
||||
+"AND r.execution_purpose='BUSINESS' AND r.run_role='WAREHOUSE_SYNC' AND r.coverage_status='COMPLETE' "
|
||||
+"AND r.published_at_utc<=#{asOf} AND t.execution_purpose='BUSINESS' AND t.task_type='SCHEDULED' "
|
||||
+"AND t.task_role='WAREHOUSE_SYNC' AND t.scope_hash=r.scope_hash "
|
||||
+"AND t.source_account=r.source_account AND t.warehouse_code=r.warehouse_code AND r.page_count>=1 AND r.source_total_count>=0 "
|
||||
+"AND r.source_total_count=r.unique_object_count AND r.fetch_started_at_utc<=r.fetch_finished_at_utc "
|
||||
+"AND DATE(DATE_ADD(t.planned_at_utc,INTERVAL 8 HOUR))=r.inventory_daily_sample_date "
|
||||
+"AND DATE(DATE_ADD(r.fetch_started_at_utc,INTERVAL 8 HOUR))=r.inventory_daily_sample_date "
|
||||
+"AND DATE(DATE_ADD(r.fetch_finished_at_utc,INTERVAL 8 HOUR))=r.inventory_daily_sample_date ";
|
||||
@Select("SELECT r.inventory_daily_sample_date sample_date,r.id run_id FROM ll_selfop_sync_run r "
|
||||
+"JOIN ll_selfop_sync_task t ON t.id=r.task_id WHERE "+SAMPLE_WHERE
|
||||
+"AND r.inventory_daily_sample_date>=#{from} AND r.inventory_daily_sample_date<#{until} ORDER BY r.inventory_daily_sample_date")
|
||||
List<SampleRun> samples(@Param("account") String account,@Param("warehouse") String warehouse,@Param("scopeHash") String scopeHash,
|
||||
String HISTORY_WHERE=" source_account=#{account} AND warehouse_code=#{warehouse} AND scope_hash=#{scopeHash,jdbcType=VARCHAR} "
|
||||
+"AND rule_version='FLOW_EOD_V1' AND status IN ('PUBLISHED','SUPERSEDED') AND invalidated_at IS NULL ";
|
||||
@Select("SELECT business_date sample_date,id day_version_id FROM ll_selfop_inventory_day_version WHERE "+HISTORY_WHERE
|
||||
+"AND head_slot=1 AND published_at<=#{asOf} AND business_date>=#{from} AND business_date<#{until} ORDER BY business_date")
|
||||
List<DayVersion> samples(@Param("account") String account,@Param("warehouse") String warehouse,@Param("scopeHash") String scopeHash,
|
||||
@Param("asOf") LocalDateTime asOf,@Param("from") LocalDate from,@Param("until") LocalDate until);
|
||||
@Select("SELECT MIN(r.inventory_daily_sample_date) FROM ll_selfop_sync_run r JOIN ll_selfop_sync_task t ON t.id=r.task_id WHERE "+SAMPLE_WHERE)
|
||||
@Select("<script>SELECT business_date sample_date,id day_version_id FROM ll_selfop_inventory_day_version WHERE "+HISTORY_WHERE
|
||||
+"AND id IN <foreach collection='ids' item='id' open='(' separator=',' close=')'>#{id}</foreach> ORDER BY business_date</script>")
|
||||
List<DayVersion> fixedSamples(@Param("account") String account,@Param("warehouse") String warehouse,@Param("scopeHash") String scopeHash,@Param("ids") List<Long> ids);
|
||||
@Select("SELECT MIN(business_date) FROM ll_selfop_inventory_day_version WHERE "+HISTORY_WHERE+" AND head_slot=1 AND published_at<=#{asOf}")
|
||||
LocalDate accumulationStartedOn(@Param("account") String account,@Param("warehouse") String warehouse,@Param("scopeHash") String scopeHash,@Param("asOf") LocalDateTime asOf);
|
||||
|
||||
@SelectProvider(type=InventoryTurnoverSql.class,method="page")
|
||||
|
||||
+8
-4
@@ -8,14 +8,15 @@ import org.springframework.format.annotation.DateTimeFormat;
|
||||
/** Separate from DETAIL: its dates, windows and filters must never be silently mixed. */
|
||||
public record InventoryTurnoverRequest(String sourceAccount, String warehouseCode,
|
||||
@DateTimeFormat(iso=DateTimeFormat.ISO.DATE) LocalDate endDate, Integer baseWindowDays,
|
||||
String groupBy, String customerCode, String sku, String focus, Integer coverageDaysThreshold,
|
||||
String groupBy, java.util.List<String> customerCodes, String sku, String focus, Integer coverageDaysThreshold,
|
||||
String turnoverStatus, String sortBy, Integer current, Integer size, Boolean includeOverview,
|
||||
String snapshotContext) {
|
||||
String snapshotContext, Boolean hideZeroInventory) {
|
||||
private static final Set<String> PARAMETERS=Set.of("sourceAccount","warehouseCode","endDate","baseWindowDays",
|
||||
"groupBy","customerCode","sku","focus","coverageDaysThreshold","turnoverStatus","sortBy","current","size","includeOverview","snapshotContext");
|
||||
"groupBy","customerCodes","sku","focus","coverageDaysThreshold","turnoverStatus","sortBy","current","size","includeOverview","snapshotContext","hideZeroInventory");
|
||||
public static void validateParameters(Set<String> keys) {
|
||||
if(!PARAMETERS.containsAll(keys)) throw new BizException("库存周转不接受其他视图的查询参数");
|
||||
}
|
||||
public boolean hideZero(){return !Boolean.FALSE.equals(hideZeroInventory);}
|
||||
public int days(){return baseWindowDays==null?30:baseWindowDays;}
|
||||
public java.util.List<Integer> windows(){return java.util.stream.Stream.of(7,15,30,days()).distinct().sorted().toList();}
|
||||
public String group(){return groupBy==null?"SKU":groupBy;}
|
||||
@@ -28,7 +29,10 @@ public record InventoryTurnoverRequest(String sourceAccount, String warehouseCod
|
||||
public LocalDate end(LocalDate today){return endDate==null?today.minusDays(1):endDate;}
|
||||
public void validate(LocalDate today) {
|
||||
AnalyticsQuery.text(sourceAccount,64,"来源账号"); AnalyticsQuery.text(warehouseCode,64,"仓库");
|
||||
if(customerCode!=null) AnalyticsQuery.text(customerCode,64,"货主");
|
||||
if(customerCodes!=null) {
|
||||
if(customerCodes.size()>100) throw new BizException("最多选择100个货主");
|
||||
for(String code:customerCodes) AnalyticsQuery.text(code,64,"货主");
|
||||
}
|
||||
if(sku!=null) AnalyticsQuery.text(sku,128,"SKU");
|
||||
if(days()<1||days()>366) throw new BizException("统计区间须为1至366个完整自然日");
|
||||
if(!end(today).isBefore(today)) throw new BizException("截止日必须是北京时间已结束的日期");
|
||||
|
||||
+1
-1
@@ -23,7 +23,7 @@ public final class InventoryTurnoverResponses {
|
||||
List<LocalDate> missingSampleDates,List<String> sampleReasonCodes,LocalDate lastObservedOutboundDate,
|
||||
List<String> attentionReasons,Risk noOutboundInWindow,Risk slowCoverage,int unassessableSkuCount,
|
||||
BigDecimal unitVolumeM3,String dimensionSource,Volume inventoryVolumeM3,List<VolumeWindow> outboundVolumesM3) {}
|
||||
public record Sample(LocalDate date,Long runId) {}
|
||||
public record Sample(LocalDate date,Long dayVersionId) {}
|
||||
public record Context(String snapshotContext,String sourceAccount,String warehouseCode,LocalDate endDate,
|
||||
int baseWindowDays,Instant queryAsOf,Instant queryExpiresAt,AnalyticsResponses.Context analyticsContext,
|
||||
Instant inventoryObservedFrom,Instant inventoryObservedUntil,String sampleRuleVersion,
|
||||
|
||||
+33
-28
@@ -6,7 +6,7 @@ import java.util.*;
|
||||
/** Every value is bound. Only validated enums select SQL fragments; no source order/remote API reads. */
|
||||
public final class InventoryTurnoverSql {
|
||||
private InventoryTurnoverSql() {}
|
||||
public record Day(LocalDate date,LocalDateTime startUtc,int coverage,Long sampleRun) {}
|
||||
public record Day(LocalDate date,LocalDateTime startUtc,int coverage,Long historyVersionId) {}
|
||||
public record Input(InventoryTurnoverRequest query,long salesRun,long inventoryRun,boolean stockFresh,
|
||||
boolean salesKnown,List<Day> days,LocalDateTime queryAsOf) {
|
||||
public LocalDate until(){return days.get(days.size()-1).date().plusDays(1);}
|
||||
@@ -31,52 +31,57 @@ public final class InventoryTurnoverSql {
|
||||
var coverage=SalesQueryCoverage.intervals(frozen.snapshot().sales());
|
||||
boolean trusted=frozen.snapshot().sourceKnown()&&(publishedHistory||!frozen.response().analyticsContext().rebuildRequired());
|
||||
var days=frozen.response().dailySamples().stream().map(s->new Day(s.date(),s.date().atStartOfDay().minusHours(8),
|
||||
!trusted?0:SalesQueryCoverage.complete(coverage,s.date(),s.date().plusDays(1))?1:SalesQueryCoverage.at(coverage,s.date())==null?0:2,s.runId())).toList();
|
||||
!trusted?0:SalesQueryCoverage.complete(coverage,s.date(),s.date().plusDays(1))?1:SalesQueryCoverage.at(coverage,s.date())==null?0:2,s.dayVersionId())).toList();
|
||||
return new Input(q,frozen.response().analyticsContext().salesRunId(),frozen.response().analyticsContext().inventoryRunId(),
|
||||
"VALID".equals(frozen.response().analyticsContext().inventoryStatus()),frozen.snapshot().sourceKnown(),days,LocalDateTime.ofInstant(frozen.response().queryAsOf(),ZoneOffset.UTC));
|
||||
}
|
||||
private static String windowStart(int n){return "#{p.from"+(java.util.Set.of(7,15,30).contains(n)?Integer.toString(n):"Base")+"}";}
|
||||
private static String scope(String alias) {
|
||||
return alias+"source_account=#{p.query.sourceAccount} AND "+alias+"warehouse_code=#{p.query.warehouseCode}"
|
||||
+" AND (#{p.query.customerCode,jdbcType=VARCHAR} IS NULL OR "+alias+"customer_code=#{p.query.customerCode,jdbcType=VARCHAR})";
|
||||
private static String scope(Input p,String alias) {
|
||||
String base=alias+"source_account=#{p.query.sourceAccount} AND "+alias+"warehouse_code=#{p.query.warehouseCode}";
|
||||
var owners=p.query.customerCodes();
|
||||
if(owners==null||owners.isEmpty())return base;
|
||||
var values=new ArrayList<String>();
|
||||
for(int i=0;i<owners.size();i++)values.add("#{p.query.customerCodes["+i+"],jdbcType=VARCHAR}");
|
||||
return base+" AND "+alias+"customer_code IN ("+String.join(",",values)+")";
|
||||
}
|
||||
private static String valid(String field){return "product_quality IN (0,1) AND "+field+" IS NOT NULL AND "+field+">=0 AND (quality_status='VALID' OR quality_reason IN ('FIELD_MISSING','NEGATIVE_QUANTITY'))";}
|
||||
private static String amount(String field){return "CASE WHEN MIN(CASE WHEN "+valid(field)+" THEN 1 ELSE 0 END)=1 THEN SUM("+field+") END";}
|
||||
private static String calendar(Input p) {
|
||||
var parts=new ArrayList<String>();
|
||||
for(int i=0;i<p.days().size();i++) parts.add("SELECT CAST(#{p.days["+i+"].date} AS DATE) business_date,CAST(#{p.days["+i+"].startUtc} AS DATETIME) start_utc,"
|
||||
+"CAST(#{p.days["+i+"].coverage} AS SIGNED) coverage,CAST(#{p.days["+i+"].sampleRun,jdbcType=BIGINT} AS SIGNED) sample_run");
|
||||
+"CAST(#{p.days["+i+"].coverage} AS SIGNED) coverage,CAST(#{p.days["+i+"].historyVersionId,jdbcType=BIGINT} AS SIGNED) sample_run");
|
||||
return String.join(" UNION ALL ",parts);
|
||||
}
|
||||
private static String sampleRuns(Input p) {
|
||||
private static String historyVersions(Input p) {
|
||||
// The frozen context already resolved these versions. Bind them directly instead
|
||||
// of repeatedly expanding the 30-day calendar as a membership subquery.
|
||||
var runs=new ArrayList<String>();
|
||||
for(int i=0;i<p.days().size();i++) if(p.days().get(i).sampleRun()!=null)
|
||||
runs.add("#{p.days["+i+"].sampleRun,jdbcType=BIGINT}");
|
||||
for(int i=0;i<p.days().size();i++) if(p.days().get(i).historyVersionId()!=null)
|
||||
runs.add("#{p.days["+i+"].historyVersionId,jdbcType=BIGINT}");
|
||||
return runs.isEmpty()?"NULL":String.join(",",runs);
|
||||
}
|
||||
private static String salesDays() {
|
||||
private static String salesDays(Input p) {
|
||||
return "SELECT customer_code,sku_code,business_date,SUM(outbound_quantity) quantity,MIN(CASE WHEN quantity_unit='PCS' AND outbound_quantity>=0 THEN 1 ELSE 0 END) unit_valid FROM ll_selfop_sku_daily_sales WHERE "
|
||||
+scope("")+" AND sales_run_id=#{p.salesRun} AND business_date>=CAST(#{p.from} AS DATE) AND business_date<CAST(#{p.until} AS DATE) GROUP BY customer_code,sku_code,business_date";
|
||||
+scope(p,"")+" AND sales_run_id=#{p.salesRun} AND business_date>=CAST(#{p.from} AS DATE) AND business_date<CAST(#{p.until} AS DATE) GROUP BY customer_code,sku_code,business_date";
|
||||
}
|
||||
private static String cte(Input p) {
|
||||
String stocks="SELECT snapshot_run_id,customer_code,sku_code,"+amount("physical_quantity")+" physical,"
|
||||
+amount("transit_quantity")+" transit,"+amount("frozen_quantity")+" frozen,"+AnalyticsInventorySql.availableQuantity(valid("available_quantity"))+" available,"
|
||||
+"CASE WHEN MIN(CASE WHEN product_quality NOT IN (0,1) OR product_quality IS NULL THEN 0 WHEN product_quality=1 AND NOT ("+valid("physical_quantity")+") THEN 0 ELSE 1 END)=1 "
|
||||
+"THEN SUM(CASE WHEN product_quality=1 THEN physical_quantity ELSE 0 END) END defective "
|
||||
+"FROM ll_selfop_inventory_snapshot WHERE "+scope("")+" AND (snapshot_run_id=#{p.inventoryRun} OR snapshot_run_id IN ("+sampleRuns(p)+")) "
|
||||
+"FROM ll_selfop_inventory_snapshot WHERE "+scope(p,"")+" AND snapshot_run_id=#{p.inventoryRun} "
|
||||
+"GROUP BY snapshot_run_id,customer_code,sku_code";
|
||||
String profiles="SELECT * FROM ll_selfop_sku_profile WHERE "+scope("")+" AND (profile_run_id IN (#{p.salesRun},#{p.inventoryRun}) OR profile_run_id IN ("+sampleRuns(p)+"))";
|
||||
StringBuilder sql=new StringBuilder("WITH calendar AS (").append(calendar(p)).append("), fixed_profiles AS (").append(profiles)
|
||||
.append("), stocks AS (").append(stocks).append("), sales_days AS (").append(salesDays()).append("), candidates AS (")
|
||||
.append("SELECT customer_code,sku_code FROM fixed_profiles UNION SELECT customer_code,sku_code FROM stocks UNION SELECT customer_code,sku_code FROM sales_days), profiles AS (")
|
||||
String profiles="SELECT * FROM ll_selfop_sku_profile WHERE "+scope(p,"")+" AND profile_run_id IN (#{p.salesRun},#{p.inventoryRun})";
|
||||
String history="SELECT d.day_version_id,d.customer_code,d.sku_code,CASE WHEN MIN(CASE WHEN d.quality_status='VALID' AND d.product_quality IN (0,1) AND d.physical_quantity>=0 THEN 1 ELSE 0 END)=1 THEN SUM(d.physical_quantity) END physical,GROUP_CONCAT(DISTINCT d.quality_reason SEPARATOR ',') reason FROM ll_selfop_inventory_daily d JOIN ll_selfop_inventory_day_version v ON v.id=d.day_version_id WHERE v.source_account=#{p.query.sourceAccount} AND v.warehouse_code=#{p.query.warehouseCode} AND v.rule_version='FLOW_EOD_V1' AND v.invalidated_at IS NULL AND "+scope(p,"d.").replace("d.source_account=#{p.query.sourceAccount} AND d.warehouse_code=#{p.query.warehouseCode}","1=1")+" AND d.day_version_id IN ("+historyVersions(p)+") GROUP BY d.day_version_id,d.customer_code,d.sku_code";
|
||||
StringBuilder sql=new StringBuilder("WITH calendar AS (").append(calendar(p)).append("), history AS (").append(history).append("), fixed_profiles AS (").append(profiles)
|
||||
.append("), stocks AS (").append(stocks).append("), sales_days AS (").append(salesDays(p)).append("), candidates AS (")
|
||||
.append("SELECT customer_code,sku_code FROM fixed_profiles UNION SELECT customer_code,sku_code FROM stocks UNION SELECT customer_code,sku_code FROM sales_days UNION SELECT customer_code,sku_code FROM history), profiles AS (")
|
||||
.append("SELECT c.customer_code,c.sku_code,COALESCE(MAX(CASE WHEN f.profile_run_id=#{p.inventoryRun} THEN f.product_name END),MAX(f.product_name)) product_name,")
|
||||
.append("COALESCE(MAX(CASE WHEN f.profile_run_id=#{p.salesRun} THEN CASE WHEN f.quantity_unit='PCS' THEN 1 ELSE 0 END END),MAX(CASE WHEN f.profile_run_id=#{p.inventoryRun} THEN CASE WHEN f.quantity_unit='PCS' THEN 1 ELSE 0 END END),MIN(CASE WHEN f.quantity_unit='PCS' THEN 1 ELSE 0 END)) unit_valid,")
|
||||
.append("COALESCE(MAX(CASE WHEN f.profile_run_id=#{p.salesRun} THEN CASE WHEN f.quantity_unit='PCS' THEN 1 ELSE 0 END END),MAX(CASE WHEN f.profile_run_id=#{p.inventoryRun} THEN CASE WHEN f.quantity_unit='PCS' THEN 1 ELSE 0 END END),MIN(CASE WHEN f.profile_run_id IS NULL THEN NULL WHEN f.quantity_unit='PCS' THEN 1 ELSE 0 END),CASE WHEN EXISTS (SELECT 1 FROM history h WHERE h.customer_code=c.customer_code AND h.sku_code=c.sku_code AND h.physical IS NOT NULL) THEN 1 ELSE 0 END) unit_valid,")
|
||||
.append("MIN(CASE WHEN f.evidence_run_id IS NOT NULL AND f.evidence_type IN ('VALID_OUTBOUND','INVENTORY_OBSERVATION') THEN f.earliest_evidence_at_utc END) evidence ")
|
||||
.append("FROM candidates c LEFT JOIN fixed_profiles f ON f.customer_code=c.customer_code AND f.sku_code=c.sku_code GROUP BY c.customer_code,c.sku_code)")
|
||||
.append(InventoryVolumeSql.products()).append(skuWindows(p)).append(", last_sales AS (SELECT customer_code,sku_code,MAX(business_date) last_outbound FROM ll_selfop_sku_daily_sales WHERE ")
|
||||
.append(scope("")).append(" AND sales_run_id=#{p.salesRun} AND business_date<CAST(#{p.until} AS DATE) AND outbound_quantity>0 AND quantity_unit='PCS' GROUP BY customer_code,sku_code)");
|
||||
.append(scope(p,"")).append(" AND sales_run_id=#{p.salesRun} AND business_date<CAST(#{p.until} AS DATE) AND outbound_quantity>0 AND quantity_unit='PCS' GROUP BY customer_code,sku_code)");
|
||||
sql.append(", sku_base AS (SELECT c.customer_code,c.sku_code,c.product_name,c.evidence,c.unit_valid,pv.unit_volume,COALESCE(pv.dimension_source,'MISSING') dimension_source");
|
||||
for(int n:p.query().windows()) for(String suffix:List.of("outbound","observed","complete","partial")) sql.append(",w.w").append(n).append('_').append(suffix);
|
||||
sql.append(",w.sample_count,w.sample_total,w.average_physical,w.sample_mask,ls.last_outbound");
|
||||
@@ -84,7 +89,7 @@ public final class InventoryTurnoverSql {
|
||||
sql.append(" FROM profiles c JOIN sku_windows w ON w.customer_code=c.customer_code AND w.sku_code=c.sku_code LEFT JOIN last_sales ls ON ls.customer_code=c.customer_code AND ls.sku_code=c.sku_code LEFT JOIN stocks st ON st.snapshot_run_id=#{p.inventoryRun} AND st.customer_code=c.customer_code AND st.sku_code=c.sku_code ")
|
||||
.append("LEFT JOIN product_volumes pv ON pv.customer_code=c.customer_code AND pv.sku_code=c.sku_code LEFT JOIN fixed_profiles ip ON ip.profile_run_id=#{p.inventoryRun} AND ip.customer_code=c.customer_code AND ip.sku_code=c.sku_code), sku_calculated AS (SELECT b.*,")
|
||||
.append("CASE WHEN available=0 THEN 0 WHEN available>0 AND w").append(p.query.days()).append("_outbound>0 THEN available*#{p.query.days}/w").append(p.query.days()).append("_outbound END coverage_days,")
|
||||
.append("CASE WHEN sample_total>0 AND evidence<=#{p.baseFromUtc} THEN w").append(p.query.days()).append("_outbound*#{p.query.days}/sample_total END turnover,")
|
||||
.append("CASE WHEN sample_total>0 THEN w").append(p.query.days()).append("_outbound*#{p.query.days}/sample_total END turnover,")
|
||||
.append("CASE WHEN physical=0 THEN 0 WHEN physical>0 AND w"+p.query.days()+"_outbound IS NOT NULL THEN CASE WHEN w"+p.query.days()+"_outbound=0 THEN 1 ELSE 0 END END no_outbound,")
|
||||
.append("CASE WHEN physical IS NULL OR available IS NULL OR w").append(p.query.days()).append("_outbound IS NULL THEN 1 ELSE 0 END unassessable FROM sku_base b), sku_result AS (")
|
||||
.append("SELECT b.*").append(InventoryVolumeSql.sku(p)).append(",CASE WHEN #{p.query.coverageDaysThreshold,jdbcType=INTEGER} IS NULL THEN NULL WHEN physical=0 OR available=0 THEN 0 WHEN coverage_days IS NOT NULL AND available>0 THEN CASE WHEN coverage_days>#{p.query.coverageDaysThreshold,jdbcType=INTEGER} THEN 1 ELSE 0 END WHEN available>0 AND w")
|
||||
@@ -123,9 +128,8 @@ public final class InventoryTurnoverSql {
|
||||
// Read only actual qualified samples at the frozen date/run. Missing candidates
|
||||
// remain in sku_zero_counts; absence never creates a zero-valued sample.
|
||||
sql.append(" FROM actual_sku_days GROUP BY customer_code,sku_code), sku_sample_days AS (SELECT st.customer_code,st.sku_code,d.business_date,")
|
||||
.append("st.physical sample_physical FROM calendar d JOIN stocks st ON st.snapshot_run_id=d.sample_run ")
|
||||
.append("JOIN fixed_profiles ip ON ip.profile_run_id=d.sample_run AND ip.customer_code=st.customer_code AND ip.sku_code=st.sku_code ")
|
||||
.append("WHERE ip.quantity_unit='PCS' AND st.physical IS NOT NULL), sku_sample_counts AS (SELECT customer_code,sku_code,")
|
||||
.append("st.physical sample_physical FROM calendar d JOIN history st ON st.day_version_id=d.sample_run ")
|
||||
.append("WHERE st.physical IS NOT NULL), sku_sample_counts AS (SELECT customer_code,sku_code,")
|
||||
.append("COUNT(CASE WHEN business_date>=CAST(#{p.baseFrom} AS DATE) THEN sample_physical END) sample_count,")
|
||||
// Keep the qualified sum exact; do not divide again by a rounded daily mean.
|
||||
.append("CASE WHEN COUNT(CASE WHEN business_date>=CAST(#{p.baseFrom} AS DATE) THEN sample_physical END)=#{p.query.days} THEN SUM(CASE WHEN business_date>=CAST(#{p.baseFrom} AS DATE) THEN sample_physical END) END sample_total,")
|
||||
@@ -142,11 +146,11 @@ public final class InventoryTurnoverSql {
|
||||
// Qualified date membership supports the full selected window without numeric bit overflow.
|
||||
return "GROUP_CONCAT(CASE WHEN sample_physical IS NOT NULL THEN CAST(business_date AS CHAR) END ORDER BY business_date SEPARATOR ',')";
|
||||
}
|
||||
private static String pageMissingDates() {
|
||||
private static String pageMissingDates(Input p) {
|
||||
// Only the selected page expands dates. Numeric qualification and filtering
|
||||
// already used every candidate and every frozen sample before pagination.
|
||||
return ", page_missing AS (SELECT r.*, (SELECT GROUP_CONCAT(CAST(business_date AS CHAR) ORDER BY business_date SEPARATOR ',') FROM calendar d "
|
||||
+"WHERE d.business_date>=CAST(#{p.baseFrom} AS DATE) AND LOCATE(CAST(d.business_date AS CHAR),COALESCE(r.sample_mask,''))=0) missing_dates FROM page_result r)";
|
||||
+"WHERE d.business_date>=CAST(#{p.baseFrom} AS DATE) AND LOCATE(CAST(d.business_date AS CHAR),COALESCE(r.sample_mask,''))=0) missing_dates, (SELECT GROUP_CONCAT(DISTINCT h.reason SEPARATOR ',') FROM history h JOIN calendar d ON d.sample_run=h.day_version_id WHERE h.customer_code=r.customer_code "+("SKU".equals(p.query.group())?"AND h.sku_code=r.sku_code ":"")+"AND d.business_date>=CAST(#{p.baseFrom} AS DATE)) history_reasons FROM page_result r)";
|
||||
}
|
||||
private static String windowAggregates(Input p) {
|
||||
StringBuilder sql=new StringBuilder();
|
||||
@@ -209,6 +213,7 @@ public final class InventoryTurnoverSql {
|
||||
case "UNASSESSABLE" -> "unassessable>0";
|
||||
default -> "1=1";
|
||||
};
|
||||
if(p.query.hideZero()) predicate+=" AND (physical IS NULL OR physical<>0)";
|
||||
if(p.query.turnoverStatus()!=null) predicate+=" AND sample_count<#{p.query.days}";
|
||||
if(!owner&&p.query.sku()!=null) predicate+=" AND sku_code=#{p.query.sku}";
|
||||
return " WHERE "+predicate;
|
||||
@@ -238,7 +243,7 @@ public final class InventoryTurnoverSql {
|
||||
}
|
||||
public static String page(Map<String,Object> args) {
|
||||
Input p=(Input)args.get("p");boolean owner="OWNER".equals(p.query.group());
|
||||
return cte(p)+(owner?ownerCte(p):"")+", page_result AS (SELECT * FROM "+(owner?"owner_result":"sku_result")+filter(p,owner)+order(p,owner)+" LIMIT #{p.query.pageSize} OFFSET #{p.query.offset})"+pageMissingDates()+" SELECT * FROM page_missing"+order(p,owner);
|
||||
return cte(p)+(owner?ownerCte(p):"")+", page_result AS (SELECT * FROM "+(owner?"owner_result":"sku_result")+filter(p,owner)+order(p,owner)+" LIMIT #{p.query.pageSize} OFFSET #{p.query.offset})"+pageMissingDates(p)+" SELECT * FROM page_missing"+order(p,owner);
|
||||
}
|
||||
public static String count(Map<String,Object> args) {
|
||||
Input p=(Input)args.get("p");boolean owner="OWNER".equals(p.query.group());
|
||||
@@ -253,7 +258,7 @@ public final class InventoryTurnoverSql {
|
||||
+"SELECT 'OWNER' kind,customer_code,physical,0 unknown_count FROM ranked_owners UNION ALL SELECT 'META' kind,NULL customer_code,NULL physical,COUNT(*) unknown_count FROM owner_result WHERE physical IS NULL ORDER BY kind DESC,physical DESC,customer_code";
|
||||
}
|
||||
public static String chartWindows(Map<String,Object> args) {
|
||||
Input p=(Input)args.get("p");return "WITH calendar AS ("+calendar(p)+"), sales_days AS ("+salesDays()+"), warehouse_days AS (SELECT d.business_date,"
|
||||
Input p=(Input)args.get("p");return "WITH calendar AS ("+calendar(p)+"), sales_days AS ("+salesDays(p)+"), warehouse_days AS (SELECT d.business_date,"
|
||||
+"CASE WHEN #{p.salesKnown}=1 AND d.coverage=1 AND MIN(COALESCE(s.unit_valid,1))=1 THEN 1 ELSE 0 END complete,"
|
||||
+"CASE WHEN #{p.salesKnown}=1 THEN CASE WHEN COUNT(s.business_date)=0 AND d.coverage>0 THEN 0 ELSE SUM(CASE WHEN s.unit_valid=1 THEN s.quantity END) END END observed "
|
||||
+"FROM calendar d LEFT JOIN sales_days s ON s.business_date=d.business_date GROUP BY d.business_date,d.coverage), warehouse_window_counts AS (SELECT COUNT(*) day_count"+windowAggregates(p)+" FROM warehouse_days) SELECT w.*"+formalWindows(p)+" FROM warehouse_window_counts w";
|
||||
@@ -265,7 +270,7 @@ public final class InventoryTurnoverSql {
|
||||
public static String report(Map<String,Object> args) {
|
||||
Input p=(Input)args.get("p");boolean owner="OWNER".equals(p.query.group()),overview=p.query.overview();
|
||||
String source=owner?"owner_result":"sku_result";
|
||||
List<String> fields=new ArrayList<>(List.of("customer_code","physical","available","frozen","defective","transit","sample_count","average_physical","missing_dates","last_outbound","turnover","unassessable"));
|
||||
List<String> fields=new ArrayList<>(List.of("customer_code","physical","available","frozen","defective","transit","sample_count","average_physical","missing_dates","history_reasons","last_outbound","turnover","unassessable"));
|
||||
for(int n:p.query().windows())for(String suffix:List.of("outbound","observed","complete","partial"))fields.add("w"+n+"_"+suffix);
|
||||
fields.addAll(InventoryVolumeSql.fields(p));
|
||||
if(owner) {
|
||||
@@ -276,7 +281,7 @@ public final class InventoryTurnoverSql {
|
||||
// Stock charts share owner totals, independently of list filters and pagination.
|
||||
String sql=cte(p)+(owner?ownerCte(p):overview?", owner_totals AS ("+totals(p,"customer_code",true)+" FROM sku_result GROUP BY customer_code) ":"")
|
||||
+", page_result AS (SELECT r.*,ROW_NUMBER() OVER ("+order(p,owner)+") ordinal FROM "+source+" r"+filter(p,owner)+order(p,owner)+" LIMIT #{p.query.pageSize} OFFSET #{p.query.offset})";
|
||||
sql+=pageMissingDates();
|
||||
sql+=pageMissingDates(p);
|
||||
if(overview)sql+=", summary_result AS ("+totals(p,null,false)+" FROM sku_result), top_owners AS (SELECT customer_code,physical,ROW_NUMBER() OVER (ORDER BY physical DESC,customer_code) ordinal FROM owner_totals WHERE physical IS NOT NULL ORDER BY physical DESC,customer_code LIMIT 10)"
|
||||
+", top_volume_owners AS (SELECT t.*,ROW_NUMBER() OVER (ORDER BY physical_volume DESC,customer_code) ordinal FROM owner_totals t WHERE physical_volume IS NOT NULL ORDER BY physical_volume DESC,customer_code LIMIT 10)";
|
||||
// Statement-local only: share intermediate relations across report branches;
|
||||
|
||||
+154
@@ -0,0 +1,154 @@
|
||||
package com.baiyue.lastleg.selfoperated.analytics.query;
|
||||
|
||||
import java.util.Map;
|
||||
|
||||
/** Business explanations retained in server-generated spreadsheets. */
|
||||
final class TurnoverExportReasons {
|
||||
private TurnoverExportReasons() {}
|
||||
static final Map<String,String> LABELS = Map.ofEntries(
|
||||
Map.entry("COMPLETE","完整"),
|
||||
Map.entry("PARTIAL","未完整"),
|
||||
Map.entry("UNKNOWN","未知"),
|
||||
Map.entry("QUEUED","排队中"),
|
||||
Map.entry("RUNNING","执行中"),
|
||||
Map.entry("WAITING","等待中"),
|
||||
Map.entry("WAITING_UPSTREAM","等待上游"),
|
||||
Map.entry("WAITING_SOURCE","等待来源数据"),
|
||||
Map.entry("RETRY_WAIT","待重试"),
|
||||
Map.entry("YIELDED","预算等待"),
|
||||
Map.entry("FAILED","失败"),
|
||||
Map.entry("DEAD","待处理"),
|
||||
Map.entry("SUCCEEDED","执行成功"),
|
||||
Map.entry("ROUTED","账号共享采集完成"),
|
||||
Map.entry("SAMPLE_DONE","测试样本结束"),
|
||||
Map.entry("PUBLISHED","已发布"),
|
||||
Map.entry("REUSED","沿用已有结果"),
|
||||
Map.entry("NOT_PUBLISHED","未发布"),
|
||||
Map.entry("PENDING","待处理"),
|
||||
Map.entry("BLOCKED","修订阻断"),
|
||||
Map.entry("OFF","关闭"),
|
||||
Map.entry("VALIDATION","验证采样"),
|
||||
Map.entry("BUSINESS","正式采集"),
|
||||
Map.entry("FRESH","有效"),
|
||||
Map.entry("STALE","过期"),
|
||||
Map.entry("INVALID","异常"),
|
||||
Map.entry("OBSERVING","观察中"),
|
||||
Map.entry("HEALTHY","正常"),
|
||||
Map.entry("STALE_HEARTBEAT","心跳过期，执行状态待确认"),
|
||||
Map.entry("UNCONFIRMED","执行状态待确认"),
|
||||
Map.entry("TERMINATED","尝试已结束"),
|
||||
Map.entry("ABORTED","已停止"),
|
||||
Map.entry("NOT_STARTED","尚未开始"),
|
||||
Map.entry("FETCHING","采集中"),
|
||||
Map.entry("FETCHED","采集完成"),
|
||||
Map.entry("VALIDATING","校验中"),
|
||||
Map.entry("BUILDING","计算中"),
|
||||
Map.entry("READY","待发布"),
|
||||
Map.entry("INITIALIZING","首采中"),
|
||||
Map.entry("COVERED","覆盖完整"),
|
||||
Map.entry("ACCOUNT_DISCOVERY","账号共享出库目录"),
|
||||
Map.entry("WAREHOUSE_SYNC","本仓采集"),
|
||||
Map.entry("VALID","有效"),
|
||||
Map.entry("CURRENT","已核对"),
|
||||
Map.entry("LAGGING","核对滞后"),
|
||||
Map.entry("MISSING","尚无可用数据"),
|
||||
Map.entry("UNCOVERED","覆盖不足"),
|
||||
Map.entry("INCOMPLETE","未完整"),
|
||||
Map.entry("REBUILD_REQUIRED","销量待重新统计发布"),
|
||||
Map.entry("NO_AVAILABLE_INVENTORY","无可售库存"),
|
||||
Map.entry("UNIT_UNKNOWN_OR_CONFLICT","数量单位未知或不一致"),
|
||||
Map.entry("SALES_UNTRUSTED","销量待核对"),
|
||||
Map.entry("COVERAGE_INSUFFICIENT","覆盖不足"),
|
||||
Map.entry("OBSERVATION_INSUFFICIENT","观察期不足"),
|
||||
Map.entry("SALES_UNKNOWN","销量未知"),
|
||||
Map.entry("NO_OUTBOUND_IN_WINDOW","所选窗口无出库"),
|
||||
Map.entry("NO_OUTBOUND_30_DAYS","近30天无出库"),
|
||||
Map.entry("INVENTORY_INVALID","库存异常"),
|
||||
Map.entry("INVENTORY_STALE","库存快照过期"),
|
||||
Map.entry("INVENTORY_UNKNOWN","库存未知"),
|
||||
Map.entry("UNASSESSABLE_SKUS","存在待评估SKU"),
|
||||
Map.entry("INVENTORY_UNAVAILABLE","库存资料不可用"),
|
||||
Map.entry("SALES_UNAVAILABLE","销量资料不可用"),
|
||||
Map.entry("PHYSICAL_INVENTORY_UNKNOWN","实物库存待核验"),
|
||||
Map.entry("AVAILABLE_INVENTORY_UNKNOWN","可售库存待核验"),
|
||||
Map.entry("SALES_QUANTITY_OR_UNIT_INVALID","出库数量或单位异常"),
|
||||
Map.entry("NO_ELIGIBLE_SKUS","暂无符合条件的SKU"),
|
||||
Map.entry("NO_OUTBOUND_30D","近30天无出库"),
|
||||
Map.entry("COVERAGE_GT_THRESHOLD","可售天数超过本次阈值"),
|
||||
Map.entry("FROZEN_STOCK","存在冻结库存"),
|
||||
Map.entry("DEFECTIVE_STOCK","存在次品实物库存"),
|
||||
Map.entry("UNASSESSABLE","数据不足／待观察"),
|
||||
Map.entry("THRESHOLD_NOT_SET","未设置查询阈值"),
|
||||
Map.entry("NO_PHYSICAL_INVENTORY","无实物库存"),
|
||||
Map.entry("METRIC_DEPENDENCY_UNKNOWN","该指标依赖资料未知"),
|
||||
Map.entry("SALES_WINDOW_UNAVAILABLE","同期完整销量不足"),
|
||||
Map.entry("SALES_WINDOW_INCOMPLETE","所选时段销量尚未采齐"),
|
||||
Map.entry("RISK_DEPENDENCY_UNKNOWN","部分SKU关注判断未知"),
|
||||
Map.entry("NO_OUTBOUND_IN_COLLECTED_HISTORY","已采集历史内未见出库"),
|
||||
Map.entry("SALES_NOT_COVERED","销量未覆盖"),
|
||||
Map.entry("SKU_HISTORY_UNKNOWN","SKU历史未知"),
|
||||
Map.entry("QUANTITY_UNIT_UNKNOWN","数量单位未知"),
|
||||
Map.entry("INVENTORY_NOT_PUBLISHED","库存尚未发布"),
|
||||
Map.entry("SALES_NOT_PUBLISHED","销量尚未发布"),
|
||||
Map.entry("OBSERVATION_INCOMPLETE","观察期不足"),
|
||||
Map.entry("SCOPE_CHANGED","配置范围已变化"),
|
||||
Map.entry("UPSTREAM_NOT_READY","账号共享上游未就绪"),
|
||||
Map.entry("TASK_NOT_RETRYABLE","任务当前不可恢复"),
|
||||
Map.entry("COLLECTION_MODE_NOT_BUSINESS","当前不是正式采集模式"),
|
||||
Map.entry("VALIDATION_NOT_RETRYABLE","验证会话不可恢复"),
|
||||
Map.entry("ACCOUNT_SHARED_TASK","账号共享任务由协调器恢复"),
|
||||
Map.entry("SOURCE_TIMEZONE_UNKNOWN","来源时区未确认"),
|
||||
Map.entry("SALES_DAY_INCOMPLETE","销量日期未完整"),
|
||||
Map.entry("SALES_NOT_COVERED_OR_SKU_HISTORY_UNKNOWN","销量未覆盖或SKU历史未知"),
|
||||
Map.entry("SCOPE_LEASE_BUSY","本仓任务正在执行"),
|
||||
Map.entry("COLLECTION_OFF","采集模式关闭"),
|
||||
Map.entry("COLLECTION_MODE_INVALID","采集模式配置无效"),
|
||||
Map.entry("BUSINESS_ENVIRONMENT_REJECTED","正式采集只允许生产环境"),
|
||||
Map.entry("EXECUTION_DISABLED","采集执行未启用"),
|
||||
Map.entry("WAREHOUSE_NOT_CONFIGURED","仓库未配置"),
|
||||
Map.entry("TIMEZONE_OR_UNIT_NOT_CONFIRMED","时间或件数口径配置不符合确认值"),
|
||||
Map.entry("ACCOUNT_PAUSED","账号采集已暂停"),
|
||||
Map.entry("ACCOUNT_COOLDOWN","账号处于冷却期"),
|
||||
Map.entry("EXCLUSIVE_GRANT_NOT_VALID","账号独占窗口授权无效"),
|
||||
Map.entry("DAILY_BUDGET_NOT_CONFIGURED","账号日额度未配置"),
|
||||
Map.entry("DAILY_BUDGET_EXHAUSTED","账号日额度已用完"),
|
||||
Map.entry("SALES_MISSING","尚无销量发布版本"),
|
||||
Map.entry("INVENTORY_MISSING","尚无库存发布版本"),
|
||||
Map.entry("SALES_BLOCKED","销量修订阻断"),
|
||||
Map.entry("SALES_STALE","销量数据过期"),
|
||||
Map.entry("REVISION_REVIEW_UNKNOWN","修订核对状态未知"),
|
||||
Map.entry("REVISION_REVIEW_LAGGING","修订核对滞后"),
|
||||
Map.entry("SALES_REBUILD_REQUIRED","销量有变动，待重新统计发布"),
|
||||
Map.entry("TODAY_INCOMPLETE","今日尚未结束，不能作为完整自然日"),
|
||||
Map.entry("SALES_SOURCE_TIMEZONE_UNKNOWN","销量来源时区未确认"),
|
||||
Map.entry("INDEPENDENT_ANCHOR_MISSING","缺少独立库存对账记录"),
|
||||
Map.entry("INDEPENDENT_ANCHOR_QUALITY_MISSING","独立库存品质记录不完整"),
|
||||
Map.entry("INDEPENDENT_ANCHOR_INVALID","独立库存记录无效"),
|
||||
Map.entry("INDEPENDENT_ANCHOR_COVERAGE_MISSING","库存对账区间流水未齐"),
|
||||
Map.entry("INDEPENDENT_ANCHOR_MISMATCH","流水与独立库存记录不符"),
|
||||
Map.entry("INDEPENDENT_ANCHOR_FLOW_UNKNOWN","库存对账流水待核验"),
|
||||
Map.entry("ANCHOR_TIME_AMBIGUOUS","采集库存时发生变动，待稳定库存记录核验"),
|
||||
Map.entry("ANCHOR_MISSING","缺少库存锚点"),
|
||||
Map.entry("FLOW_COVERAGE_GAP","库存流水覆盖不完整"),
|
||||
Map.entry("FLOW_TYPE_UNVERIFIED","流水类型尚未核验"),
|
||||
Map.entry("CHAIN_DISCONTINUITY","批次结存不连续"),
|
||||
Map.entry("CHAIN_ORDER_AMBIGUOUS","同秒流水顺序待核验"),
|
||||
Map.entry("FLOW_QUANTITY_OR_TIME_INVALID","流水数量或时间待核验"),
|
||||
Map.entry("FLOW_QUANTITY_CONFLICT","流水变动数量不一致"),
|
||||
Map.entry("NEGATIVE_CHAIN_STOCK","批次结存出现负数"),
|
||||
Map.entry("NEGATIVE_RECONSTRUCTED_STOCK","还原库存出现负数"),
|
||||
Map.entry("UNIT_UNKNOWN","库存数量单位待确认"),
|
||||
Map.entry("ANCHOR_DUPLICATE","库存锚点重复"),
|
||||
Map.entry("ANCHOR_QUANTITY_INVALID","库存锚点数量无效"),
|
||||
Map.entry("ANCHOR_INTERVAL_INVALID","库存观测时间无效"),
|
||||
Map.entry("ANCHOR_BEFORE_DAY_END","库存锚点早于日末"),
|
||||
Map.entry("FLOW_ID_INVALID","流水标识无效"),
|
||||
Map.entry("FLOW_ID_CONFLICT","流水标识存在冲突"),
|
||||
Map.entry("UNKNOWN_QUALITY","库存品质待确认"),
|
||||
Map.entry("CHAIN_IDENTITY_MISSING","流水库位或批次缺失"),
|
||||
Map.entry("INSUFFICIENT","合格日末库存记录不足"),
|
||||
Map.entry("ZERO_AVERAGE_STOCK","期间平均日末库存为0，无法计算周转"),
|
||||
Map.entry("INVENTORY_UNKNOWN_OR_STALE","当前库存未知、异常或已过期"),
|
||||
Map.entry("NOT_APPLICABLE","货主不计算整体可售天数"),
|
||||
Map.entry("SALES_OR_STOCK_UNASSESSABLE","部分商品的销量或库存不足以判断"));
|
||||
}
|
||||
+1
-1
@@ -7,7 +7,7 @@ public final class SelfopEgressDtos {
|
||||
boolean continuousEnabled,String sourceAccountFingerprint,boolean grantPresent,String grantFingerprint,
|
||||
long intervalMs,int permitMaxSeconds,boolean executionEnabled,int pendingMaxSeconds,
|
||||
boolean exclusiveHandoffVerified,boolean priorEgressClosed,boolean inflightDrained,boolean transferredBudgetVerified){}
|
||||
public enum Operation {WAREHOUSES,OUTBOUND_QUERY,OUTBOUND_LOCATE,OUTBOUND_DETAIL,PRODUCT_INVENTORY,CUSTOMERS,PRODUCTS}
|
||||
public enum Operation {WAREHOUSES,OUTBOUND_QUERY,OUTBOUND_LOCATE,OUTBOUND_DETAIL,PRODUCT_INVENTORY,CUSTOMERS,PRODUCTS,INVENTORY_FLOW}
|
||||
public record EgressContext(String sourceAccount,String executionPurpose,String rootTaskId,String sessionId,String attemptId,String exclusiveGrantId){}
|
||||
@com.fasterxml.jackson.annotation.JsonInclude(com.fasterxml.jackson.annotation.JsonInclude.Include.ALWAYS)
|
||||
public record AuthorizationDenial(String errorCode,boolean sampleDone,Instant waitUntil){}
|
||||
|
||||
+17
@@ -39,6 +39,22 @@ public class SelfopEgressService {
|
||||
SelfopBusinessBudget business=hasBusinessSession(root)?business(root):null;
|
||||
if(business!=null){verifyBusinessTask(task,root);String limit=business.limit(now);if(limit!=null){stopBusiness(root,business,limit,now);throw reject(limit);}}
|
||||
verify(task,run,root,account,now);
|
||||
boolean flowOperation=operation==Operation.INVENTORY_FLOW;
|
||||
boolean history=com.baiyue.lastleg.selfoperated.analytics.history.InventoryFlowSlice.TYPE.equals(task.getTaskType());
|
||||
if(history){
|
||||
if(!flowOperation||!config.isInventoryHistoryEnabled()||!SelfopCollectionPolicy.continuousBusinessRoot(task)
|
||||
||!SelfopCollectionPolicy.continuousBusiness(config)||pageSize!=1000)throw reject("EGRESS_HISTORY_INVALID");
|
||||
try {
|
||||
var slice=SelfopSupport.read(task.getQueryScopeJson(),com.baiyue.lastleg.selfoperated.analytics.history.InventoryFlowSlice.class);
|
||||
var checkpoint=SelfopSupport.read(run.getProgressSnapshotJson(),com.fasterxml.jackson.databind.JsonNode.class);
|
||||
int page=checkpoint.path("nextPage").asInt();
|
||||
if(!slice.warehouse().equals(warehouseCode)||!config.getWarehouses().containsKey(warehouseCode)
|
||||
||!slice.requestHash(page).equals(requestHash))throw reject("EGRESS_HISTORY_INVALID");
|
||||
}catch(EgressRejectedException e){throw e;}catch(RuntimeException invalid){throw reject("EGRESS_HISTORY_INVALID");}
|
||||
}else if(flowOperation!="INVENTORY_FLOW_PROBE".equals(task.getTaskType())
|
||||
||flowOperation&&(!"test".equals(config.getEnvironment())||!"BUSINESS".equals(task.getExecutionPurpose())
|
||||
||pageSize!=1000||!config.getWarehouses().containsKey(warehouseCode)
|
||||
||business==null||business.http!=0||!Objects.equals(task.getRequestHash(),requestHash)))throw reject("EGRESS_FLOW_PROBE_INVALID");
|
||||
boolean masterOperation=operation==Operation.CUSTOMERS||operation==Operation.PRODUCTS;
|
||||
if(masterOperation!=("MASTER_DATA".equals(task.getTaskType()))
|
||||
||masterOperation&&(!"BUSINESS".equals(task.getExecutionPurpose())||pageSize<1||pageSize>(operation==Operation.CUSTOMERS?1000:100)))throw reject("EGRESS_OPERATION_TASK_MISMATCH");
|
||||
@@ -74,6 +90,7 @@ public class SelfopEgressService {
|
||||
var account=account(c.sourceAccount());var budget=budget(account,now,c.executionPurpose());var pending=pendingForAuthorization(budget,c,request.operation());
|
||||
var root=root(parseId(c.rootTaskId()),c.executionPurpose(),c.sourceAccount());
|
||||
var task=mapper.lockTask(pending.taskId);var run=mapper.lockRun(pending.runId);
|
||||
if(com.baiyue.lastleg.selfoperated.analytics.history.InventoryFlowSlice.TYPE.equals(task==null?null:task.getTaskType())&&!config.isInventoryHistoryEnabled())throw reject("EGRESS_HISTORY_DISABLED");
|
||||
if(hasBusinessSession(root)){
|
||||
var b=business(root);verifyBusinessTask(task,root);
|
||||
// Explicit root stops remain independent of request accounting and short permit expiry.
|
||||
|
||||
+4
-2
@@ -19,6 +19,7 @@ public interface SalesRetentionMapper {
|
||||
AND r.superseded_at_utc IS NOT NULL AND r.superseded_at_utc <= #{cutoff}
|
||||
AND r.inventory_daily_sample_date IS NULL AND r.inventory_sample_rule_version IS NULL
|
||||
AND r.id != #{current} AND (#{previous} IS NULL OR r.id != #{previous})
|
||||
AND NOT EXISTS (SELECT 1 FROM ll_selfop_inventory_day_version h WHERE h.sales_run_id=r.id OR h.anchor_run_id=r.id)
|
||||
AND (EXISTS (SELECT 1 FROM ll_selfop_sku_daily_sales d WHERE d.sales_run_id=r.id)
|
||||
OR EXISTS (SELECT 1 FROM ll_selfop_warehouse_daily_sales w WHERE w.sales_run_id=r.id)
|
||||
OR EXISTS (SELECT 1 FROM ll_selfop_sku_profile p WHERE p.profile_run_id=r.id))
|
||||
@@ -32,10 +33,11 @@ public interface SalesRetentionMapper {
|
||||
List<SelfopSyncRun> eligible(@Param("scopeId") Long scopeId,@Param("current") Long current,
|
||||
@Param("previous") Long previous,@Param("cutoff") LocalDateTime cutoff);
|
||||
@Select("""
|
||||
SELECT COUNT(*) FROM ll_selfop_sync_run input JOIN ll_selfop_sync_task t ON t.id=input.task_id
|
||||
SELECT (SELECT COUNT(*) FROM ll_selfop_sync_run input JOIN ll_selfop_sync_task t ON t.id=input.task_id
|
||||
WHERE t.source_account=#{account} AND t.warehouse_code=#{warehouse}
|
||||
AND (t.status NOT IN ('SUCCEEDED','SAMPLE_DONE','CANCELLED') OR t.apply_state IN ('APPLYING','BLOCKED'))
|
||||
AND (input.base_published_run_id=#{id} OR input.reference_sales_run_id=#{id})
|
||||
AND (input.base_published_run_id=#{id} OR input.reference_sales_run_id=#{id}))
|
||||
+ (SELECT COUNT(*) FROM ll_selfop_inventory_day_version h WHERE h.sales_run_id=#{id} OR h.anchor_run_id=#{id})
|
||||
""")
|
||||
long activeReferences(@Param("account") String account,@Param("warehouse") String warehouse,@Param("id") Long id);
|
||||
@Delete("DELETE FROM ll_selfop_sku_daily_sales WHERE sales_run_id=#{id} LIMIT #{batchSize}")
|
||||
|
||||
+103
@@ -0,0 +1,103 @@
|
||||
package com.baiyue.lastleg.selfoperated.analytics.sync;
|
||||
|
||||
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
|
||||
import com.baomidou.mybatisplus.core.toolkit.IdWorker;
|
||||
import com.baiyue.lastleg.selfoperated.analytics.client.RestLingxingAnalyticsClient;
|
||||
import com.baiyue.lastleg.selfoperated.analytics.mapper.*;
|
||||
import com.baiyue.lastleg.selfoperated.analytics.model.*;
|
||||
import com.baiyue.lastleg.selfoperated.analytics.request.SelfopBusinessBudget;
|
||||
import com.fasterxml.jackson.databind.JsonNode;
|
||||
import org.springframework.stereotype.Service;
|
||||
import org.springframework.transaction.support.TransactionTemplate;
|
||||
import java.time.LocalDateTime;
|
||||
import java.util.*;
|
||||
import static com.baiyue.lastleg.selfoperated.analytics.model.SelfopSupport.*;
|
||||
|
||||
/** TEST-only, one audited request. No schedule, retry, publication or historical inventory mutation. */
|
||||
@Service
|
||||
public class InventoryFlowProbeService {
|
||||
private final SelfopAnalyticsProperties config;
|
||||
private final SelfopSyncTaskMapper tasks;
|
||||
private final SelfopSyncRunMapper runs;
|
||||
private final SelfopOutboundDiscoveryScopeMapper accounts;
|
||||
private final SelfopLeaseService leases;
|
||||
private final RestLingxingAnalyticsClient client;
|
||||
private final TransactionTemplate tx;
|
||||
public InventoryFlowProbeService(SelfopAnalyticsProperties config,SelfopSyncTaskMapper tasks,SelfopSyncRunMapper runs,
|
||||
SelfopOutboundDiscoveryScopeMapper accounts,SelfopLeaseService leases,RestLingxingAnalyticsClient client,TransactionTemplate tx) {
|
||||
this.config=config;this.tasks=tasks;this.runs=runs;this.accounts=accounts;this.leases=leases;this.client=client;this.tx=tx;
|
||||
}
|
||||
public record Request(String requestKey,String warehouseCode,String customerCode,String sku,LocalDateTime startTime,LocalDateTime endTime) {
|
||||
public Map<String,Object> providerRequest(){return Map.of("warehouseCode",warehouseCode,"customerCode",customerCode,"sku",sku,
|
||||
"startTime",java.time.format.DateTimeFormatter.ISO_LOCAL_DATE_TIME.format(startTime),
|
||||
"endTime",java.time.format.DateTimeFormatter.ISO_LOCAL_DATE_TIME.format(endTime));}
|
||||
}
|
||||
public record Result(String taskNo,boolean complete,JsonNode page) {}
|
||||
static void validate(Request q,LocalDateTime now) {
|
||||
require(q!=null,"SELFOP_FLOW_REQUEST_REQUIRED");identity(q.requestKey(),80);identity(q.warehouseCode(),64);
|
||||
identity(q.customerCode(),64);identity(q.sku(),128);
|
||||
require(q.startTime()!=null&&q.endTime()!=null&&q.startTime().isBefore(q.endTime())
|
||||
&&!q.endTime().isAfter(q.startTime().plusDays(31))&&!q.endTime().isAfter(now),"SELFOP_FLOW_WINDOW_INVALID");
|
||||
}
|
||||
public Result probe(Request q,String actor) {
|
||||
validate(q,utcNow().plusHours(8));
|
||||
require("test".equals(config.getEnvironment())&&"BUSINESS".equals(config.getCollectionMode())
|
||||
&&config.isExecutionEnabled()&&config.getWarehouses().containsKey(q.warehouseCode()),"SELFOP_FLOW_PROBE_DISABLED");
|
||||
String key="flow-probe:"+q.requestKey(),digest=hash(q.providerRequest());
|
||||
var account=accounts.selectOne(new QueryWrapper<SelfopOutboundDiscoveryScope>().eq("source_account",config.getSourceAccount()));
|
||||
require(account!=null,"SELFOP_SCOPE_MISSING");
|
||||
var lease=leases.acquireDiscovery(account.getId(),"flow-probe-"+UUID.randomUUID());
|
||||
try {
|
||||
var existing=tasks.selectOne(new QueryWrapper<SelfopSyncTask>().eq("source_account",config.getSourceAccount()).eq("request_key",key));
|
||||
if(existing!=null) {
|
||||
require(digest.equals(existing.getRequestHash()),"SELFOP_IDEMPOTENCY_CONFLICT");
|
||||
require("SAMPLE_DONE".equals(existing.getStatus())&&existing.getRoutingManifestJson()!=null,"SELFOP_FLOW_PREVIOUS_ATTEMPT_REQUIRES_REVIEW");
|
||||
return read(existing.getRoutingManifestJson(),Result.class);
|
||||
}
|
||||
var now=utcNow();var task=new SelfopSyncTask();var run=new SelfopSyncRun();
|
||||
task.setId(IdWorker.getId());task.setTaskNo("LXFLOW-"+UUID.randomUUID().toString().replace("-","").toUpperCase(Locale.ROOT));
|
||||
task.setSourceAccount(config.getSourceAccount());task.setExecutionPurpose("BUSINESS");task.setTaskRole("ACCOUNT_DISCOVERY");
|
||||
task.setDiscoveryScopeId(account.getId());task.setTaskType("INVENTORY_FLOW_PROBE");task.setStatus("RUNNING");
|
||||
task.setApplyState("NOT_APPLICABLE");task.setAttemptCount(1);task.setRequestKey(key);task.setRequestHash(digest);
|
||||
task.setScopeHash(digest);task.setQueryScopeJson(json(q.providerRequest()));task.setBusinessRootTaskId(task.getId());
|
||||
task.setBusinessBudgetJson(SelfopBusinessBudget.freeze(now));task.setRequestedBy(actor);task.setCreatedAt(now);task.setUpdatedAt(now);
|
||||
run.setId(IdWorker.getId());run.setTaskId(task.getId());run.setSourceAccount(config.getSourceAccount());run.setExecutionPurpose("BUSINESS");
|
||||
run.setRunRole("ACCOUNT_DISCOVERY");run.setAttemptNo(1);run.setScopeHash(digest);run.setScopeSnapshotJson(task.getQueryScopeJson());
|
||||
run.setFenceToken(lease.fence());run.setStatus("FETCHING");run.setLastPhase("FETCHING");run.setFetchStartedAtUtc(now);
|
||||
run.setCoverageStatus("UNKNOWN");run.setPageCount(0);run.setUniqueObjectCount(0L);run.setCreatedAt(now);run.setUpdatedAt(now);
|
||||
tx.executeWithoutResult(s->{leases.verify(lease);tasks.insert(task);runs.insert(run);});
|
||||
try {
|
||||
JsonNode page=client.inventoryFlow(SelfopRequestContext.forTask(task,run,config),q.warehouseCode(),q.customerCode(),q.sku(),q.startTime(),q.endTime());
|
||||
boolean complete=validatePage(page);
|
||||
var result=new Result(task.getTaskNo(),complete,page);
|
||||
tx.executeWithoutResult(s->{
|
||||
leases.verify(lease);var done=utcNow();
|
||||
task.setStatus("SAMPLE_DONE");task.setRoutingManifestJson(json(result));task.setUpdatedAt(done);
|
||||
run.setStatus("SAMPLE_DONE");run.setLastPhase("INVENTORY_FLOW_PROBE");run.setPageCount(1);
|
||||
run.setSourceTotalCount(page.path("total").asLong());run.setUniqueObjectCount((long)page.path("records").size());
|
||||
run.setCoverageStatus(complete?"COMPLETE":"PARTIAL");run.setFetchFinishedAtUtc(done);run.setFinishedAtUtc(done);run.setUpdatedAt(done);
|
||||
tasks.updateById(task);runs.updateById(run);
|
||||
});
|
||||
return result;
|
||||
} catch(RuntimeException failure) {
|
||||
String error=failure instanceof com.baiyue.lastleg.selfoperated.analytics.client.AnalyticsClientException c?c.code():
|
||||
failure instanceof com.baiyue.lastleg.selfoperated.analytics.request.EgressRejectedException e?e.code():"FLOW_PROBE_FAILED";
|
||||
tx.executeWithoutResult(s->{leases.verify(lease);task.setStatus("DEAD");task.setUpdatedAt(utcNow());
|
||||
run.setStatus("FAILED");run.setErrorCode(error);run.setErrorMessage("库存流水诊断失败；不自动重试");run.setFinishedAtUtc(utcNow());run.setUpdatedAt(utcNow());
|
||||
tasks.updateById(task);runs.updateById(run);});
|
||||
throw failure;
|
||||
}
|
||||
} finally {leases.release(lease);}
|
||||
}
|
||||
static boolean validatePage(JsonNode page) {
|
||||
require(page!=null&&page.path("records").isArray()&&page.path("current").asInt()==1&&page.path("size").asInt()==1000
|
||||
&&page.path("total").asLong(-1)>=0,"SELFOP_FLOW_PAGE_INVALID");
|
||||
long total=page.path("total").asLong();
|
||||
require(page.path("pages").asLong(-1)==(total==0?0:(total-1)/1000+1)
|
||||
&&page.path("records").size()==Math.min(1000,total),"SELFOP_FLOW_PAGE_INVALID");
|
||||
var ids=new HashSet<String>();
|
||||
for(var row:page.path("records"))require(row.path("id").isTextual()&&!row.path("id").asText().isBlank()
|
||||
&&ids.add(row.path("id").asText()),"SELFOP_FLOW_DUPLICATE_ID");
|
||||
return total<=1000;
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user