build(GoalEntity fresh);
}
/**
* Refetch + rebuild + CAS loop. The builder is invoked on each attempt
* against a freshly loaded entity so the {@code WHERE version=?} clause
* always matches the current row version. Returns the post-update entity
* (or the unchanged fresh entity when the builder signals a no-op).
*
* This replaces the earlier single-shot wrapper capture which could
* not recover from the very first CAS miss — once {@code oldVersion}
* went stale, all subsequent retries with the same wrapper were
* doomed. Refetching per attempt is the correct shape for optimistic
* locking: read, build delta against the read, CAS on the read's
* version.
*/
private GoalEntity retryOptimistic(Long id, String op, UpdateBuilder builder) {
for (int i = 0; i < OPTIMISTIC_LOCK_MAX_RETRIES; i++) {
GoalEntity fresh = goalMapper.selectById(id);
if (fresh == null) {
throw new MateClawException("err.goal.not_found", 404,
"Goal not found: " + id);
}
LambdaUpdateWrapper w = builder.build(fresh);
if (w == null) {
// Builder declined to issue a write (idempotent skip). Treat
// as success — callers like markCompleted hit this when the
// goal already moved to a terminal state via another path.
return fresh;
}
int rows = goalMapper.update(null, w);
if (rows > 0) {
return goalMapper.selectById(id);
}
log.debug("[GoalService] Optimistic lock miss on {} (attempt {}/{})",
op, i + 1, OPTIMISTIC_LOCK_MAX_RETRIES);
}
throw new MateClawException("err.goal.optimistic_lock_conflict", 409,
"Concurrent modification on " + op + " after "
+ OPTIMISTIC_LOCK_MAX_RETRIES + " retries");
}
private GoalEntity flipStatus(Long id, GoalStatus from, GoalStatus to,
String eventType, String auditAction, String username) {
GoalEntity g = retryOptimistic(id, to.getValue(), fresh -> {
if (fresh.getStatus() != from) {
throw new MateClawException("err.goal.bad_transition", 409,
"Cannot transition " + fresh.getStatus().getValue() + " -> " + to.getValue());
}
if (to == GoalStatus.ACTIVE && Boolean.TRUE.equals(fresh.getPersistentExecution())
&& isBudgetExhausted(fresh)) {
throw new MateClawException("err.goal.budget_exhausted", 409,
"Increase the exhausted budget before resuming: " + exhaustionReason(fresh));
}
LambdaUpdateWrapper w = baseLockedUpdate(fresh)
.set(GoalEntity::getStatus, to);
bumpVersionAndTime(w);
return w;
});
writeEvent(id, eventType, null, Map.of("by", username,
"from", from.getValue(), "to", to.getValue()));
recordAudit(auditAction, g, Map.of("by", username));
return g;
}
private void writeEvent(Long goalId, String type, Long messageId, Map detail) {
GoalEventEntity ev = new GoalEventEntity();
ev.setGoalId(goalId);
ev.setEventType(type);
ev.setMessageId(messageId);
ev.setDetailJson(safeJson(detail));
ev.setCreateTime(LocalDateTime.now());
eventMapper.insert(ev);
}
private void recordAudit(String action, GoalEntity g, Map detail) {
try {
auditEventService.record(action, "goal",
String.valueOf(g.getId()), g.getTitle(),
safeJson(detail), g.getWorkspaceId());
} catch (Exception ex) {
log.warn("[GoalService] audit record failed: {}", ex.getMessage());
}
}
private String safeJson(Map m) {
try {
return objectMapper.writeValueAsString(m);
} catch (JsonProcessingException e) {
return "{}";
}
}
/** Returns the time elapsed since the last followup, or null if never. */
public Duration timeSinceLastFollowup(GoalEntity g) {
if (g.getLastFollowupAt() == null) return null;
return Duration.between(g.getLastFollowupAt(), LocalDateTime.now());
}
}