261016_01_ENH: 1차 마이그레이션 완료

This commit is contained in:
2026-10-16 12:21:37 +09:00
parent 7ca665397e
commit 26088f6fd0
188 changed files with 10522 additions and 573 deletions

View File

@@ -0,0 +1,222 @@
package com.kri.kart.server.service;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.kri.common.feature.json.JsonUtil;
import com.kri.common.feature.web.BusinessException;
import com.kri.common.feature.web.RequestUserContext;
import com.kri.kart.server.common.enums.ProjectType;
import com.kri.kart.server.dto.derived.DerivedCalculationDto;
import com.kri.kart.server.dto.derived.DerivedDefinitionDto;
import com.kri.kart.server.dto.derived.DerivedSaveRequestDto;
import com.kri.kart.server.dto.project.ProjectRefDto;
import com.kri.kart.server.persistence.repository.DerivedRepository;
import com.kri.kart.server.service.derived.DerivedComputationService;
import java.util.List;
import java.util.Objects;
import java.util.function.Supplier;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
import org.springframework.stereotype.Service;
import org.springframework.transaction.PlatformTransactionManager;
import org.springframework.transaction.support.TransactionTemplate;
@Service
@ConditionalOnProperty(prefix = "kri.kart.database", name = "enabled", havingValue = "true")
public class DerivedManagementService {
private final DerivedRepository derivedRepository;
private final QuestionService questionService;
private final DerivedComputationService derivedComputationService;
private final LogService logService;
private final ObjectMapper objectMapper;
private final PlatformTransactionManager konTransactionManager;
private final PlatformTransactionManager konkiwiTransactionManager;
public DerivedManagementService(
DerivedRepository derivedRepository,
QuestionService questionService,
DerivedComputationService derivedComputationService,
LogService logService,
ObjectMapper objectMapper,
@Qualifier("konTransactionManager") PlatformTransactionManager konTransactionManager,
@Qualifier("konkiwiTransactionManager")
PlatformTransactionManager konkiwiTransactionManager) {
this.derivedRepository = derivedRepository;
this.questionService = questionService;
this.derivedComputationService = derivedComputationService;
this.logService = logService;
this.objectMapper = objectMapper;
this.konTransactionManager = konTransactionManager;
this.konkiwiTransactionManager = konkiwiTransactionManager;
}
public String save(
ProjectRefDto project,
String originId,
DerivedSaveRequestDto request,
RequestUserContext ctx) {
validateId(request.getVariableId());
if (originId != null) {
validateId(originId);
}
var definition = derivedComputationService.definition(request);
return transaction(
project,
() -> {
requireProject(project);
var original = originId == null ? null : requireDefinition(project, originId);
if (derivedRepository.duplicate(project, definition.getQid(), originId)) {
throw BusinessException.conflict("DERIVED_ID_DUPLICATE", "이미 사용 중인 변수 ID입니다.");
}
if (derivedRepository.save(
project, definition, originId, ctx.getUserTeam(), ctx.getUserId())
!= 1) {
throw BusinessException.conflict("DERIVED_CHANGED", "파생변수 상태가 변경되었습니다.");
}
if (original != null && !original.getQid().equals(definition.getQid())) {
derivedRepository.clearData(project, original.getQid());
}
calculate(project, definition);
var content = objectMapper.createObjectNode();
content.set("NEW", objectMapper.valueToTree(definition));
if (original != null) {
content.set("ORIGIN", objectMapper.valueToTree(original));
}
logService.writeSiteLog(
project,
original == null ? "Insert Derived Variable" : "Update Derived Variable",
content,
ctx);
return definition.getQid();
});
}
public boolean delete(ProjectRefDto project, String qid, RequestUserContext ctx) {
validateId(qid);
return transaction(
project,
() -> {
requireProject(project);
var original = requireDefinition(project, qid);
var content =
objectMapper.createObjectNode().set("ORIGIN", objectMapper.valueToTree(original));
logService.writeSiteLog(project, "Delete Derived Variable", content, ctx);
derivedRepository.shiftOrder(project, original.getQid());
if (derivedRepository.delete(project, original.getQid()) != 1) {
throw BusinessException.conflict("DERIVED_CHANGED", "파생변수 상태가 변경되었습니다.");
}
derivedRepository.clearData(project, original.getQid());
return true;
});
}
public DerivedCalculationDto recalculate(
ProjectRefDto project, String qid, RequestUserContext ctx) {
if (qid != null) {
validateId(qid);
}
return transaction(
project,
() -> {
requireProject(project);
List<DerivedDefinitionDto> definitions =
qid == null
? derivedRepository.definitions(project)
: List.of(requireDefinition(project, qid));
int matched = 0;
for (var definition : definitions) {
matched += calculate(project, definition);
}
if (qid == null) {
logService.writeSiteLog(
project,
"Update All Derived Variable",
objectMapper.createObjectNode().put("COUNT", Integer.toString(definitions.size())),
ctx);
}
return new DerivedCalculationDto(definitions.size(), matched);
});
}
public DerivedCalculationDto recalculateRespondent(ProjectRefDto project, String idkey) {
if (idkey == null || idkey.isBlank() || idkey.length() > 512) {
throw BusinessException.badRequest("응답자 ID를 확인해 주세요.");
}
return transaction(
project,
() -> {
requireProject(project);
// Legacy creates an empty DERIVED_DATA row even if there is no eligible completed
// response.
derivedRepository.ensureRespondent(project, idkey);
var definitions = derivedRepository.definitions(project);
int matched = 0;
for (var definition : definitions) {
matched += calculate(project, definition, idkey);
}
return new DerivedCalculationDto(definitions.size(), matched);
});
}
private int calculate(ProjectRefDto project, DerivedDefinitionDto definition) {
return calculate(project, definition, null);
}
private int calculate(ProjectRefDto project, DerivedDefinitionDto definition, String idkey) {
validateId(definition.getQid());
if (idkey == null) {
derivedRepository.clearData(project, definition.getQid());
} else {
derivedRepository.clearRespondentData(project, definition.getQid(), idkey);
}
var data =
idkey == null
? derivedRepository.responses(project)
: derivedRepository.respondentResponses(project, idkey);
var results =
derivedComputationService.calculate(
definition, questionService.list(project, idkey == null ? 0 : 1001), data);
int matched = 0;
for (int i = 0; i < data.size(); i++) {
var group = results.get(i);
derivedRepository.saveData(
project,
definition.getQid(),
data.get(i).getIdkey(),
group.isEmpty() ? null : JsonUtil.toJson(objectMapper, group));
if (!group.isEmpty()) {
matched++;
}
}
return matched;
}
private void requireProject(ProjectRefDto project) {
if (derivedRepository.lockProject(project) == null) {
throw BusinessException.notFound("PROJECT_NOT_FOUND", "프로젝트를 찾을 수 없습니다.");
}
}
private DerivedDefinitionDto requireDefinition(ProjectRefDto project, String qid) {
var definition = derivedRepository.find(project, qid);
if (definition == null) {
throw BusinessException.notFound("DERIVED_NOT_FOUND", "파생변수를 찾을 수 없습니다.");
}
validateId(definition.getQid());
return definition;
}
private void validateId(String qid) {
if (qid == null || !qid.matches("[A-Za-z][A-Za-z0-9_]{0,127}")) {
throw BusinessException.badRequest("파생변수 ID 형식을 확인해 주세요.");
}
}
private <T> T transaction(ProjectRefDto project, Supplier<T> action) {
var transactionTemplate =
new TransactionTemplate(
project.getProjectType() == ProjectType.KON
? konTransactionManager
: konkiwiTransactionManager);
return Objects.requireNonNull(transactionTemplate.execute(status -> action.get()));
}
}