package jnpf.dmsBusinessOccupancy;
|
|
import org.mybatis.spring.SqlSessionTemplate;
|
import java.util.*;
|
import static jnpf.dmsBusinessOccupancy.BusinessOccupancyException.Reason.*;
|
|
/** Trusted business execution only; caller owns the transaction and completion evidence. */
|
public final class BusinessFileExecutionService {
|
private final BusinessOccupancyTransactions transactions;
|
private final BusinessFileOccupancyCoordinator coordinator;
|
private final BusinessFileEligibilityService eligibility;
|
private final SqlSessionTemplate sessions;
|
public BusinessFileExecutionService(SqlSessionTemplate sessions) {
|
this.sessions=sessions;
|
transactions=new BusinessOccupancyTransactions(sessions);
|
coordinator=new BusinessFileOccupancyCoordinator(sessions);
|
eligibility=new BusinessFileEligibilityService(sessions);
|
}
|
/** Locks the original numbers before document locks and verifies the frozen source versions. */
|
public List<BusinessFileOccupancy> require(String tenant,String chain,String application,String workflowTask,String operation,
|
Collection<String> fileIds) {
|
return transactions.execute(mapper->{
|
Set<String> files=new HashSet<>(fileIds);
|
if(files.isEmpty() || files.size()!=fileIds.size()) throw new BusinessOccupancyException(TARGET_CHANGED);
|
var all=mapper.chainOccupancies(tenant,chain);
|
var receipts=all.stream().filter(r->files.contains(r.getFileId())).toList();
|
if(receipts.size()!=files.size()) throw new BusinessOccupancyException(TARGET_CHANGED);
|
if(!coordinator.tryLockNumbers(tenant,receipts.stream().map(BusinessFileOccupancy::getFileNumber).toList()))
|
throw new BusinessOccupancyException(NUMBER_BUSY);
|
var current=mapper.fileTargets(tenant,new ArrayList<>(files));
|
if(current.size()!=files.size()) throw new BusinessOccupancyException(TARGET_CHANGED);
|
List<BusinessFileOccupancy> result=new ArrayList<>();
|
for(var old:receipts) {
|
var row=mapper.chain(tenant,old.getFileNumber(),chain);
|
if(row==null || row.getReleasedAt()!=null) throw new BusinessOccupancyException(CHAIN_ALREADY_RELEASED);
|
if(!Objects.equals(row.getApplicationId(),application) || !Objects.equals(row.getWorkflowTaskId(),workflowTask)
|
|| !Objects.equals(row.getOperation(),operation)) throw new BusinessOccupancyException(TARGET_CHANGED);
|
var target=current.stream().filter(t->Objects.equals(t.getFileId(),row.getFileId())).findFirst()
|
.orElseThrow(()->new BusinessOccupancyException(TARGET_CHANGED));
|
if(!Objects.equals(target.getFileNumber(),row.getFileNumber())
|
|| !Objects.equals(target.getBusinessVersionId(),row.getBusinessVersionId())
|
|| !Objects.equals(target.getCenterVersionId(),row.getCenterVersionId()))
|
throw new BusinessOccupancyException(TARGET_CHANGED);
|
result.add(row);
|
}
|
return List.copyOf(result);
|
});
|
}
|
/** Extension executes the whole application; subset execution is not a valid completion. */
|
public List<BusinessFileOccupancy> requireExtension(String tenant,String application,String task,
|
Collection<String> fileIds) {
|
return transactions.execute(mapper->{
|
var frozen=mapper.chainOccupancies(tenant,task).stream()
|
.filter(row->Objects.equals(application,row.getApplicationId())
|
&& Objects.equals(task,row.getWorkflowTaskId())
|
&& "EXTENSION".equals(row.getOperation())).toList();
|
if(frozen.isEmpty()) throw new BusinessOccupancyException(TARGET_CHANGED);
|
if(!coordinator.tryLockNumbers(tenant,frozen.stream().map(BusinessFileOccupancy::getFileNumber).toList()))
|
throw new BusinessOccupancyException(NUMBER_BUSY);
|
var requested=new HashSet<>(fileIds);
|
var locked=mapper.chainOccupancies(tenant,task).stream()
|
.filter(row->Objects.equals(application,row.getApplicationId())
|
&& Objects.equals(task,row.getWorkflowTaskId())
|
&& "EXTENSION".equals(row.getOperation())).toList();
|
if(requested.isEmpty() || requested.size()!=fileIds.size() || locked.size()!=requested.size()
|
|| !requested.equals(new HashSet<>(locked.stream().map(BusinessFileOccupancy::getFileId).toList()))
|
|| !new HashSet<>(frozen.stream().map(BusinessFileOccupancy::getId).toList())
|
.equals(new HashSet<>(locked.stream().map(BusinessFileOccupancy::getId).toList())))
|
throw new BusinessOccupancyException(TARGET_CHANGED);
|
return require(tenant,task,application,task,"EXTENSION",fileIds);
|
});
|
}
|
public List<BusinessFileOccupancy> requireRevision(String tenant,String auditId) {
|
return new BusinessRevisionSubmissionService(sessions).require(tenant,auditId);
|
}
|
public List<BusinessFileOccupancy> requireCreation(String tenant,String auditId) {
|
return transactions.execute(mapper->{
|
var before=mapper.creationNumbers(tenant,auditId);
|
var rows=requireCreation(tenant,auditId,before);
|
var after=mapper.creationNumbers(tenant,auditId);
|
if(before.size()!=after.size() || !new HashSet<>(before).equals(new HashSet<>(after)))
|
throw new BusinessOccupancyException(TARGET_CHANGED);
|
return rows;
|
});
|
}
|
/** Reserve an external approval's own number; it has no issued-number detail row. */
|
public List<BusinessFileOccupancy> requireExternalCreation(String tenant, String auditId,
|
String taskId, String fileNumber) {
|
return transactions.execute(mapper -> {
|
if (!coordinator.tryLockNumbers(tenant, List.of(fileNumber)))
|
throw new BusinessOccupancyException(NUMBER_BUSY);
|
BusinessFileOccupancy previous = mapper.chain(tenant, fileNumber, taskId);
|
if (previous == null && mapper.hasBusinessNumber(tenant, fileNumber))
|
throw new BusinessOccupancyException(TARGET_CHANGED);
|
BusinessFileOccupancy requested = new BusinessFileOccupancy();
|
requested.setTenantId(tenant); requested.setFileNumber(fileNumber);
|
requested.setOperation("CREATE"); requested.setChainId(taskId);
|
requested.setApplicationId(auditId); requested.setWorkflowTaskId(taskId);
|
requested.setStage("EXECUTING");
|
BusinessFileOccupancy receipt = coordinator.acquire(requested);
|
return List.of(receipt);
|
});
|
}
|
/** Every CREATE source item must be covered; called before activation and again before projection. */
|
public List<BusinessFileOccupancy> requireCreation(String tenant,String auditId,Collection<String> numbers) {
|
return transactions.execute(mapper->{
|
var requested=new HashSet<>(numbers);
|
if(requested.isEmpty() || requested.size()!=numbers.size()) throw new BusinessOccupancyException(TARGET_CHANGED);
|
if(!coordinator.tryLockNumbers(tenant,requested)) throw new BusinessOccupancyException(NUMBER_BUSY);
|
var rows=mapper.creationReceipts(tenant,auditId);
|
if(rows.size()!=requested.size()) throw new BusinessOccupancyException(TARGET_CHANGED);
|
for(var row:rows) {
|
if(row.getReleasedAt()!=null) throw new BusinessOccupancyException(CHAIN_ALREADY_RELEASED);
|
if(!requested.contains(row.getFileNumber())) throw new BusinessOccupancyException(TARGET_CHANGED);
|
}
|
return rows;
|
});
|
}
|
public void guardNumbers(String tenant,String chain,Collection<String> numbers) {
|
if(numbers.isEmpty()) return;
|
transactions.execute(mapper->{
|
if(!coordinator.tryLockNumbers(tenant,numbers)) throw new BusinessOccupancyException(NUMBER_BUSY);
|
for(String number:numbers) {
|
var row=mapper.active(tenant,number);
|
if(row!=null && !Objects.equals(chain,row.getChainId())) throw new BusinessOccupancyException(ALREADY_OCCUPIED);
|
}
|
return null;
|
});
|
}
|
/** Standalone center files retain their path; resource-backed files require the full audit batch. */
|
public void guardStandaloneActivation(String tenant,String centerVersionId) {
|
transactions.execute(mapper->{
|
String number=mapper.centerFileNumber(tenant,centerVersionId);
|
if(number!=null && !number.isBlank()) guardNumbers(tenant,null,List.of(number));
|
if(!Objects.equals(number,mapper.centerFileNumber(tenant,centerVersionId))
|
|| mapper.hasBusinessDocument(tenant,centerVersionId))
|
throw new BusinessOccupancyException(TARGET_CHANGED);
|
return null;
|
});
|
}
|
/** Generic initial upload must not claim a number already owned by a business resource/chain. */
|
public void guardStandaloneRegistration(String tenant,String fileNumber) {
|
if(fileNumber==null || fileNumber.isBlank()) return;
|
transactions.execute(mapper->{
|
guardNumbers(tenant,null,List.of(fileNumber));
|
if(mapper.hasBusinessNumber(tenant,fileNumber)) throw new BusinessOccupancyException(TARGET_CHANGED);
|
return null;
|
});
|
}
|
public void guardValidity(String tenant,String task,Collection<String> versions) {
|
transactions.execute(mapper->{
|
List<BusinessFileTarget> targets=new ArrayList<>();
|
for(String version:versions) {
|
var found=mapper.expiryTargets(tenant,version);
|
if(found.isEmpty() && !mapper.hasCurrentBusinessReference(tenant,version)) continue;
|
if(found.size()!=1) throw new BusinessOccupancyException(TARGET_CHANGED);
|
targets.add(found.get(0));
|
}
|
if(targets.isEmpty()) return null;
|
guardNumbers(tenant,task,targets.stream().map(BusinessFileTarget::getFileNumber).toList());
|
if(task!=null) {
|
var all=mapper.chainOccupancies(tenant,task);
|
for(var target:targets) {
|
var row=all.stream().filter(r->Objects.equals(r.getFileId(),target.getFileId())).findFirst()
|
.orElseThrow(()->new BusinessOccupancyException(TARGET_CHANGED));
|
require(tenant,task,row.getApplicationId(),task,"EXTENSION",List.of(target.getFileId()));
|
if(!Objects.equals(target.getCenterVersionId(),row.getCenterVersionId()))
|
throw new BusinessOccupancyException(TARGET_CHANGED);
|
}
|
} else {
|
var checks=eligibility.recheckForSubmission(targets.stream().map(t->
|
new BusinessFileEligibilityService.Query(tenant,t.getFileNumber(),t.getFileId(),t.getBusinessVersionId(),
|
BusinessFileEligibilityService.Operation.REVIEW_EXTENSION)).toList());
|
if(checks.stream().anyMatch(d->!d.allowed())) throw new BusinessOccupancyException(TARGET_CHANGED);
|
}
|
return null;
|
});
|
}
|
/** Cascading records must also respect number occupancy, even when not explicit application rows. */
|
public void guardVersions(String tenant,String chain,Collection<String> versions) {
|
transactions.execute(mapper->{
|
List<BusinessFileTarget> targets=new ArrayList<>();
|
for(String version:versions) {
|
var found=mapper.expiryTargets(tenant,version);
|
if(found.size()!=1) throw new BusinessOccupancyException(TARGET_CHANGED);
|
targets.add(found.get(0));
|
}
|
if(targets.isEmpty()) throw new BusinessOccupancyException(TARGET_CHANGED);
|
if(!coordinator.tryLockNumbers(tenant,targets.stream().map(BusinessFileTarget::getFileNumber).toList()))
|
throw new BusinessOccupancyException(NUMBER_BUSY);
|
for(var target:targets) {
|
if(!List.of(target).equals(mapper.expiryTargets(tenant,target.getCenterVersionId())))
|
throw new BusinessOccupancyException(TARGET_CHANGED);
|
var occupied=mapper.active(tenant,target.getFileNumber());
|
if(occupied!=null && !Objects.equals(chain,occupied.getChainId()))
|
throw new BusinessOccupancyException(ALREADY_OCCUPIED);
|
}
|
return null;
|
});
|
}
|
public List<BusinessFileOccupancy> terminationCandidates(String afterId,int limit) {
|
return transactions.reader().terminationCandidates(afterId,limit);
|
}
|
/** Re-read authoritative terminal evidence under number and workflow locks; no timeout release. */
|
public boolean releaseEnded(BusinessFileOccupancy candidate) {
|
return transactions.execute(mapper->{
|
if(!coordinator.tryLockNumbers(candidate.getTenantId(),List.of(candidate.getFileNumber()))) return false;
|
if(mapper.lockEndedTask(candidate)==null) return false;
|
return coordinator.release(candidate.getTenantId(),candidate.getFileNumber(),candidate.getChainId(),candidate.getId(),"ENDED_UNSUCCESSFUL");
|
});
|
}
|
/** Call only after all native detail/resource/version projections succeeded in this transaction. */
|
public void complete(List<BusinessFileOccupancy> receipts) {
|
for(var row:receipts) if(!coordinator.release(row.getTenantId(),row.getFileNumber(),row.getChainId(),row.getId(),"EXECUTED"))
|
throw new BusinessOccupancyException(TARGET_CHANGED);
|
}
|
}
|
