1 Commits

Author SHA1 Message Date
993c766d6b 260420_02_ENH: 로직 단순화 구현 완료 2026-04-20 18:54:50 +09:00
14 changed files with 1421 additions and 38 deletions

View File

@@ -51,4 +51,26 @@ public class PairingController {
} }
} }
} }
@PostMapping(value = "/run/new1", consumes = MediaType.MULTIPART_FORM_DATA_VALUE)
@Operation(
summary = "업로드된 파일로 위원과 센터를 매칭"
)
public ResponseEntity<byte[]> pairingMemberByCenterNew(
@RequestParam("file") MultipartFile file
) {
String fileName = file.getOriginalFilename() == null ? "pairing" : file.getOriginalFilename();
try {
byte[] bytes = pairingService.pairingMemberByCenterNew(file);
return ExcelResponseBuilder.buildExcelResponse(fileName + " 결과.xlsx", bytes);
} catch (BusinessException e) {
if (e.getStatus() != HttpStatus.BAD_REQUEST) {
throw e;
} else {
byte[] bytes = pairingExcelService.writeValidationError(e.getCode(), e.getMessage());
return ExcelResponseBuilder.buildExcelResponse(fileName + " 오류.xlsx", bytes);
}
}
}
} }

View File

@@ -0,0 +1,36 @@
package com.kri.p6.ncrc.pairing.dto.excel.output;
import com.kri.common.feature.excel.ExcelColumn;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
@Data
@NoArgsConstructor
@AllArgsConstructor
public class NewAdjacentRegionExcelDto {
@ExcelColumn(header = "파견 권역", order = 0, width = 12)
private String dispatchRegion;
@ExcelColumn(header = "인접지역 분류", order = 1, width = 18)
private String adjacentRegionClassification;
@ExcelColumn(header = "여성위원만", order = 2, width = 12)
private String womenOnly;
@ExcelColumn(header = "센터 수", order = 3, width = 10)
private String centerCount;
@ExcelColumn(header = "센터 id 목록", order = 4, width = 40)
private String centerIds;
@ExcelColumn(header = "진행 시작일", order = 5, width = 14)
private String availableStartDate;
@ExcelColumn(header = "진행 종료일", order = 6, width = 14)
private String availableEndDate;
@ExcelColumn(header = "진행 불가 일자", order = 7, width = 45)
private String unavailableDates;
}

View File

@@ -0,0 +1,33 @@
package com.kri.p6.ncrc.pairing.dto.excel.output;
import com.kri.common.feature.excel.ExcelColumn;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
@Data
@NoArgsConstructor
@AllArgsConstructor
public class NewCenterExcelDto {
@ExcelColumn(header = "센터 id", order = 0, width = 16)
private String id;
@ExcelColumn(header = "지자체 id", order = 1, width = 16)
private String municipalityId;
@ExcelColumn(header = "인접지역 분류", order = 2, width = 18)
private String adjacentRegionClassification;
@ExcelColumn(header = "여성위원만", order = 3, width = 12)
private String womenOnly;
@ExcelColumn(header = "센터+지자체 시작일", order = 4, width = 18)
private String availableStartDate;
@ExcelColumn(header = "센터+지자체 종료일", order = 5, width = 18)
private String availableEndDate;
@ExcelColumn(header = "센터+지자체 불가일", order = 6, width = 45)
private String unavailableDates;
}

View File

@@ -0,0 +1,30 @@
package com.kri.p6.ncrc.pairing.dto.excel.output;
import com.kri.common.feature.excel.ExcelColumn;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
@Data
@NoArgsConstructor
@AllArgsConstructor
public class NewFinalAssignmentExcelDto {
@ExcelColumn(header = "일자", order = 0, width = 14)
private String date;
@ExcelColumn(header = "페어번호", order = 1, width = 10)
private String pairNo;
@ExcelColumn(header = "현장위원 id", order = 2, width = 18)
private String fieldMemberId;
@ExcelColumn(header = "외부위원 id", order = 3, width = 18)
private String externalMemberId;
@ExcelColumn(header = "희망지역 매칭표 상의 순위", order = 4, width = 24)
private String preferenceMatchPriority;
@ExcelColumn(header = "인접지역 분류", order = 5, width = 18)
private String adjacentRegionClassification;
}

View File

@@ -0,0 +1,51 @@
package com.kri.p6.ncrc.pairing.dto.excel.output;
import com.kri.common.feature.excel.ExcelColumn;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
@Data
@NoArgsConstructor
@AllArgsConstructor
public class NewFinalAssignmentWithCenterExcelDto {
@ExcelColumn(header = "센터 id", order = 0, width = 18)
private String centerId;
@ExcelColumn(header = "지자체 id", order = 1, width = 18)
private String municipalityId;
@ExcelColumn(header = "인접지역 분류", order = 2, width = 18)
private String centerAdjacentRegionClassification;
@ExcelColumn(header = "여성위원만", order = 3, width = 12)
private String womenOnly;
@ExcelColumn(header = "센터+지자체 시작일", order = 4, width = 18)
private String availableStartDate;
@ExcelColumn(header = "센터+지자체 종료일", order = 5, width = 18)
private String availableEndDate;
@ExcelColumn(header = "센터+지자체 불가일", order = 6, width = 45)
private String unavailableDates;
@ExcelColumn(header = "일자", order = 7, width = 14)
private String date;
@ExcelColumn(header = "페어번호", order = 8, width = 10)
private String pairNo;
@ExcelColumn(header = "현장위원 id", order = 9, width = 18)
private String fieldMemberId;
@ExcelColumn(header = "외부위원 id", order = 10, width = 18)
private String externalMemberId;
@ExcelColumn(header = "희망지역 매칭표 상의 순위", order = 11, width = 24)
private String preferenceMatchPriority;
@ExcelColumn(header = "인접지역 분류", order = 12, width = 18)
private String assignedAdjacentRegionClassification;
}

View File

@@ -0,0 +1,75 @@
package com.kri.p6.ncrc.pairing.dto.excel.output;
import com.kri.common.feature.excel.ExcelColumn;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
@Data
@NoArgsConstructor
@AllArgsConstructor
public class NewPairResultExcelDto {
@ExcelColumn(header = "페어번호", order = 0, width = 10)
private String pairNo;
@ExcelColumn(header = "현장위원 id", order = 1, width = 18)
private String fieldMemberId;
@ExcelColumn(header = "현장위원 경력", order = 2, width = 12)
private String fieldExperience;
@ExcelColumn(header = "현장위원 성별", order = 3, width = 10)
private String fieldGender;
@ExcelColumn(header = "현장위원 활동지역", order = 4, width = 18)
private String fieldActivityRegion;
@ExcelColumn(header = "현장위원 거주지", order = 5, width = 14)
private String fieldResidenceCode;
@ExcelColumn(header = "현장위원 23년 센터", order = 6, width = 35)
private String fieldHistoryCenters;
@ExcelColumn(header = "외부위원 id", order = 7, width = 18)
private String externalMemberId;
@ExcelColumn(header = "외부위원 경력", order = 8, width = 12)
private String externalExperience;
@ExcelColumn(header = "외부위원 성별", order = 9, width = 10)
private String externalGender;
@ExcelColumn(header = "외부위원 활동지역", order = 10, width = 18)
private String externalActivityRegion;
@ExcelColumn(header = "외부위원 거주지", order = 11, width = 14)
private String externalResidenceCode;
@ExcelColumn(header = "외부위원 23년 센터", order = 12, width = 35)
private String externalHistoryCenters;
@ExcelColumn(header = "배정 가능 인접지역 수", order = 13, width = 20)
private String availableAdjacentRegionCount;
@ExcelColumn(header = "중복제거 가능 날짜 수", order = 14, width = 20)
private String availableAdjacentRegionDateCount;
@ExcelColumn(header = "총점", order = 15, width = 16)
private String score;
@ExcelColumn(header = "활동지역 겹침 수", order = 16, width = 16)
private String activityOverlapCount;
@ExcelColumn(header = "가능일자 겹침 수", order = 17, width = 16)
private String availableDateOverlapCount;
@ExcelColumn(header = "선호지역 겹침 수", order = 18, width = 16)
private String preferenceOverlapCount;
@ExcelColumn(header = "23년 센터 점수", order = 19, width = 16)
private String historyScore;
@ExcelColumn(header = "거주지 점수", order = 20, width = 14)
private String residenceScore;
}

View File

@@ -0,0 +1,27 @@
package com.kri.p6.ncrc.pairing.dto.excel.output;
import com.kri.common.feature.excel.ExcelColumn;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
@Data
@NoArgsConstructor
@AllArgsConstructor
public class NewPairScoreGuideExcelDto {
@ExcelColumn(header = "순서", order = 0, width = 8)
private String order;
@ExcelColumn(header = "항목", order = 1, width = 28)
private String name;
@ExcelColumn(header = "계산 방식", order = 2, width = 80)
private String formula;
@ExcelColumn(header = "점수 반영", order = 3, width = 35)
private String score;
@ExcelColumn(header = "설명", order = 4, width = 90)
private String description;
}

View File

@@ -0,0 +1,21 @@
package com.kri.p6.ncrc.pairing.model;
import java.time.LocalDate;
import java.util.Set;
import lombok.Builder;
import lombok.EqualsAndHashCode;
import lombok.Getter;
@Getter
@Builder
@EqualsAndHashCode(of = {"dispatchRegion", "adjacentRegionClassification"})
public class NewAdjacentRegion {
private final String adjacentRegionClassification;
private final String dispatchRegion;
private final boolean womenOnly;
private final Set<String> centerIds;
private final Set<NewCenter> centers;
private final LocalDate availableStartDate;
private final LocalDate availableEndDate;
private final Set<LocalDate> unavailableDates;
}

View File

@@ -0,0 +1,26 @@
package com.kri.p6.ncrc.pairing.model;
import java.time.LocalDate;
import java.util.Set;
import lombok.Builder;
import lombok.EqualsAndHashCode;
import lombok.Getter;
@Getter
@Builder
@EqualsAndHashCode(of = "id")
public class NewCenter {
private final String id;
private final boolean womenOnly;
private final String adjacentRegionClassification;
private final LocalDate availableStartDate;
private final LocalDate availableEndDate;
private final Set<LocalDate> unavailableDates;
private final String municipalityId;
private final LocalDate municipalityAvailableStartDate;
private final LocalDate municipalityAvailableEndDate;
private final Set<LocalDate> municipalityUnavailableDates;
}

View File

@@ -0,0 +1,27 @@
package com.kri.p6.ncrc.pairing.model;
import com.kri.p6.ncrc.pairing.dto.excel.output.CandidateSummaryExcelDto;
import com.kri.p6.ncrc.pairing.dto.excel.output.NewAdjacentRegionExcelDto;
import com.kri.p6.ncrc.pairing.dto.excel.output.NewCenterExcelDto;
import com.kri.p6.ncrc.pairing.dto.excel.output.NewFinalAssignmentExcelDto;
import com.kri.p6.ncrc.pairing.dto.excel.output.NewFinalAssignmentWithCenterExcelDto;
import com.kri.p6.ncrc.pairing.dto.excel.output.NewPairScoreGuideExcelDto;
import com.kri.p6.ncrc.pairing.dto.excel.output.NewPairResultExcelDto;
import com.kri.p6.ncrc.pairing.dto.excel.output.RuleViolationExcelDto;
import java.util.List;
import lombok.Builder;
import lombok.Getter;
@Getter
@Builder
public class NewPairingResult {
private final List<NewPairResultExcelDto> pairs;
private final List<NewFinalAssignmentExcelDto> finalAssignments;
private final List<NewFinalAssignmentWithCenterExcelDto> finalAssignmentsWithCenters;
private final List<NewAdjacentRegionExcelDto> adjacentRegions;
private final List<NewCenterExcelDto> centers;
private final List<CandidateSummaryExcelDto> summaries;
private final List<NewPairScoreGuideExcelDto> scoreGuides;
private final List<RuleViolationExcelDto> ruleChecks;
}

View File

@@ -30,11 +30,18 @@ import com.kri.p6.ncrc.pairing.dto.excel.output.ABPairExcelDto;
import com.kri.p6.ncrc.pairing.dto.excel.output.AppliedSettingExcelDto; import com.kri.p6.ncrc.pairing.dto.excel.output.AppliedSettingExcelDto;
import com.kri.p6.ncrc.pairing.dto.excel.output.AssignmentResultExcelDto; import com.kri.p6.ncrc.pairing.dto.excel.output.AssignmentResultExcelDto;
import com.kri.p6.ncrc.pairing.dto.excel.output.CandidateSummaryExcelDto; import com.kri.p6.ncrc.pairing.dto.excel.output.CandidateSummaryExcelDto;
import com.kri.p6.ncrc.pairing.dto.excel.output.NewAdjacentRegionExcelDto;
import com.kri.p6.ncrc.pairing.dto.excel.output.NewCenterExcelDto;
import com.kri.p6.ncrc.pairing.dto.excel.output.NewFinalAssignmentExcelDto;
import com.kri.p6.ncrc.pairing.dto.excel.output.NewFinalAssignmentWithCenterExcelDto;
import com.kri.p6.ncrc.pairing.dto.excel.output.NewPairResultExcelDto;
import com.kri.p6.ncrc.pairing.dto.excel.output.NewPairScoreGuideExcelDto;
import com.kri.p6.ncrc.pairing.dto.excel.output.PairingSummaryExcelDto; import com.kri.p6.ncrc.pairing.dto.excel.output.PairingSummaryExcelDto;
import com.kri.p6.ncrc.pairing.dto.excel.output.RuleViolationExcelDto; import com.kri.p6.ncrc.pairing.dto.excel.output.RuleViolationExcelDto;
import com.kri.p6.ncrc.pairing.dto.excel.output.UnassignedCenterExcelDto; import com.kri.p6.ncrc.pairing.dto.excel.output.UnassignedCenterExcelDto;
import com.kri.p6.ncrc.pairing.dto.excel.output.UnusedMemberExcelDto; import com.kri.p6.ncrc.pairing.dto.excel.output.UnusedMemberExcelDto;
import com.kri.p6.ncrc.pairing.dto.excel.output.ValidationErrorExcelDto; import com.kri.p6.ncrc.pairing.dto.excel.output.ValidationErrorExcelDto;
import com.kri.p6.ncrc.pairing.model.NewPairingResult;
import com.kri.p6.ncrc.pairing.model.PairingResult; import com.kri.p6.ncrc.pairing.model.PairingResult;
import java.io.ByteArrayOutputStream; import java.io.ByteArrayOutputStream;
import java.io.IOException; import java.io.IOException;
@@ -110,6 +117,35 @@ public class PairingExcelService {
} }
} }
public byte[] writeNew(NewPairingResult result) {
try (Workbook workbook = ExcelMapper.writeToWorkbook(result.getPairs(),
NewPairResultExcelDto.class, "페어결과");
ByteArrayOutputStream outputStream = new ByteArrayOutputStream()) {
ExcelMapper.appendSheetToWorkbook(workbook, result.getFinalAssignments(),
NewFinalAssignmentExcelDto.class, "최종 배정", headerRowIndex());
ExcelMapper.appendSheetToWorkbook(workbook, result.getFinalAssignmentsWithCenters(),
NewFinalAssignmentWithCenterExcelDto.class, "최종 배정 with 센터", headerRowIndex());
ExcelMapper.appendSheetToWorkbook(workbook, result.getAdjacentRegions(),
NewAdjacentRegionExcelDto.class, "인접지역목록", headerRowIndex());
ExcelMapper.appendSheetToWorkbook(workbook, result.getCenters(),
NewCenterExcelDto.class, "센터목록", headerRowIndex());
ExcelMapper.appendSheetToWorkbook(workbook, result.getSummaries(),
CandidateSummaryExcelDto.class, "페어후보요약", headerRowIndex());
ExcelMapper.appendSheetToWorkbook(workbook, result.getScoreGuides(),
NewPairScoreGuideExcelDto.class, "페어점수계산", headerRowIndex());
ExcelMapper.appendSheetToWorkbook(workbook, result.getRuleChecks(),
RuleViolationExcelDto.class, "규칙검사", headerRowIndex());
workbook.write(outputStream);
return outputStream.toByteArray();
} catch (IOException e) {
throw BusinessException.badRequest("PAIRING_EXCEL_WRITE_FAILED",
"결과 엑셀 파일을 생성하는 중 오류가 발생했습니다: " + e.getMessage());
}
}
public byte[] writeValidationError(String code, String message) { public byte[] writeValidationError(String code, String message) {
PairingResult result = PairingResult.builder() PairingResult result = PairingResult.builder()
.assignments(List.of()) .assignments(List.of())
@@ -149,55 +185,42 @@ public class PairingExcelService {
PairingProperties.Candidate candidate = pairingProperties.getCandidate(); PairingProperties.Candidate candidate = pairingProperties.getCandidate();
PairingProperties.Solver solver = pairingProperties.getSolver(); PairingProperties.Solver solver = pairingProperties.getSolver();
return List.of( return List.of(
setting("pairing.excel.header-row-index", setting("pairing.excel.header-row-index", "엑셀 헤더로 사용하는 행 인덱스",
"엑셀 헤더로 사용할 행 인덱스",
excel.getHeaderRowIndex()), excel.getHeaderRowIndex()),
setting("pairing.code.region-code-length", setting("pairing.code.region-code-length", "지역코드 정규화 길이",
"지역코드 정규화 길이", code.getRegionCodeLength()), code.getRegionCodeLength()),
setting("pairing.code.residence-code-length", setting("pairing.code.residence-code-length", "거주지코드 정규화 길이",
"거주지코드 정규화 길이",
code.getResidenceCodeLength()), code.getResidenceCodeLength()),
setting("pairing.code.residence-match-prefix-length", setting("pairing.code.residence-match-prefix-length", "거주지 일치 판단에 사용하는 앞자리 길이",
"거주지 일치 판단에 사용하는 앞자리 길이",
code.getResidenceMatchPrefixLength()), code.getResidenceMatchPrefixLength()),
setting("pairing.code.any-region-code", setting("pairing.code.any-region-code", "희망지역 anywhere로 처리하는 코드",
"희망지역 anywhere로 처리하는 코드",
code.getAnyRegionCode()), code.getAnyRegionCode()),
setting("pairing.rule.max-centers-per-pair-per-day", setting("pairing.rule.max-centers-per-pair-per-day", "같은 페어가 하루에 방문할 수 있는 최대 센터 수",
"같은 페어가 하루에 방문할 수 있는 최대 센터 수",
rule.getMaxCentersPerPairPerDay()), rule.getMaxCentersPerPairPerDay()),
setting("pairing.rule.max-counterparts-per-member", setting("pairing.rule.max-counterparts-per-member", "위원 1명당 허용하는 상대 위원 최대 수",
"위원 1명당 허용되는 상대 위원 최대 수",
rule.getMaxCounterpartsPerMember()), rule.getMaxCounterpartsPerMember()),
setting("pairing.rule.max-member-visit-average-ratio-percent", setting("pairing.rule.max-member-visit-average-ratio-percent",
"위원별 방문 수 상한을 평균 대비 몇 %까지 허용할지", "위원별 방문 수 상한을 평균 대비 몇 %까지 허용할지",
rule.getMaxMemberVisitAverageRatioPercent()), rule.getMaxMemberVisitAverageRatioPercent()),
setting("pairing.preference.anywhere-rank", setting("pairing.preference.anywhere-rank", "희망지역 anywhere를 의미하는 순위",
"선호지역 anywhere를 의미하는 순위",
preference.getAnywhereRank()), preference.getAnywhereRank()),
setting("pairing.preference.ignored-rank", setting("pairing.preference.ignored-rank", "희망지역 고려하지 않음을 의미하는 순위",
"선호지역 고려하지 않음을 의미하는 순위",
preference.getIgnoredRank()), preference.getIgnoredRank()),
setting("pairing.preference.active-wildcard-fallback-enabled", setting("pairing.preference.active-wildcard-fallback-enabled",
"희망지역 고려하지 않음을 wildcard로 적극 사용할지", "희망지역 고려하지 않음을 wildcard로 적극 사용할지",
preference.isActiveWildcardFallbackEnabled()), preference.isActiveWildcardFallbackEnabled()),
setting("pairing.preference.wildcard-fallback-score-bonus", setting("pairing.preference.wildcard-fallback-score-bonus", "wildcard 후보에 추가하는 점수",
"wildcard 후보에 추가할 점수",
preference.getWildcardFallbackScoreBonus()), preference.getWildcardFallbackScoreBonus()),
setting("pairing.objective.assignment-weight", setting("pairing.objective.assignment-weight", "센터 하나를 배정하는 것에 부여하는 기본 점수",
"센터 하나를 더 배정하는 것에 부여하는 기본 점수",
objective.getAssignmentWeight()), objective.getAssignmentWeight()),
setting("pairing.objective.preference-base-weight", setting("pairing.objective.preference-base-weight", "희망지역 매칭 1건마다 부여하는 기본 점수",
"희망지역 매칭 품질에 부여하는 기본 점수",
objective.getPreferenceBaseWeight()), objective.getPreferenceBaseWeight()),
setting("pairing.objective.preference-rank-penalty", setting("pairing.objective.preference-rank-penalty", "희망 순위가 낮아질 때 감점하는 점수",
"희망순위가 낮아질 때 감점하는 점수",
objective.getPreferenceRankPenalty()), objective.getPreferenceRankPenalty()),
setting("pairing.objective.residence-match-weight", setting("pairing.objective.residence-match-weight", "거주지 유사도 점수에 곱하는 가중치",
"거주지 유사도 점수에 곱하는 가중치",
objective.getResidenceMatchWeight()), objective.getResidenceMatchWeight()),
setting("pairing.objective.member-balance-weight", setting("pairing.objective.member-balance-weight",
"방문 수가 많은 위원을 더 선택하지 않도록 감점하는 가중치", "방문 수가 많은 위원이 계속 선택되지 않도록 감점하는 가중치",
objective.getMemberBalanceWeight()), objective.getMemberBalanceWeight()),
setting("pairing.candidate.max-pair-candidates-per-member", setting("pairing.candidate.max-pair-candidates-per-member",
"위원별 페어 후보 축소 상한, 0이면 무제한", "위원별 페어 후보 축소 상한, 0이면 무제한",
@@ -205,20 +228,16 @@ public class PairingExcelService {
setting("pairing.candidate.max-dispatch-regions-per-pair", setting("pairing.candidate.max-dispatch-regions-per-pair",
"페어별 파견 권역 후보 축소 상한, 0이면 무제한", "페어별 파견 권역 후보 축소 상한, 0이면 무제한",
candidate.getMaxDispatchRegionsPerPair()), candidate.getMaxDispatchRegionsPerPair()),
setting("pairing.candidate.max-assignments-per-center", setting("pairing.candidate.max-assignments-per-center", "센터별 배정 후보 축소 상한",
"센터별 배정 후보 축소 상한",
candidate.getMaxAssignmentsPerCenter()), candidate.getMaxAssignmentsPerCenter()),
setting("pairing.candidate.max-assignments-per-member", setting("pairing.candidate.max-assignments-per-member", "위원별 배정 후보 축소 상한",
"위원별 배정 후보 축소 상한",
candidate.getMaxAssignmentsPerMember()), candidate.getMaxAssignmentsPerMember()),
setting("pairing.candidate.max-dates-per-assignment-candidate", setting("pairing.candidate.max-dates-per-assignment-candidate",
"하나의 페어-센터 조합에서 확장할 날짜 후보 상한", "하나의 페어-센터 조합에서 확장할 날짜 후보 상한",
candidate.getMaxDatesPerAssignmentCandidate()), candidate.getMaxDatesPerAssignmentCandidate()),
setting("pairing.solver.max-time-seconds", setting("pairing.solver.max-time-seconds", "CP-SAT 사용 시 허용할 최대 탐색 시간",
"CP-SAT 사용 시 허용할 최대 탐색 시간",
solver.getMaxTimeSeconds()), solver.getMaxTimeSeconds()),
setting("pairing.solver.num-search-workers", setting("pairing.solver.num-search-workers", "CP-SAT 사용 시 사용할 worker 수",
"CP-SAT 사용 시 사용할 worker 수",
solver.getNumSearchWorkers()) solver.getNumSearchWorkers())
); );
} }

View File

@@ -0,0 +1,989 @@
package com.kri.p6.ncrc.pairing.service;
import com.kri.common.feature.web.BusinessException;
import com.kri.p6.ncrc.pairing.config.PairingProperties;
import com.kri.p6.ncrc.pairing.common.enums.ExperienceType;
import com.kri.p6.ncrc.pairing.common.enums.Gender;
import com.kri.p6.ncrc.pairing.common.enums.MemberRole;
import com.kri.p6.ncrc.pairing.dto.excel.output.CandidateSummaryExcelDto;
import com.kri.p6.ncrc.pairing.dto.excel.output.NewAdjacentRegionExcelDto;
import com.kri.p6.ncrc.pairing.dto.excel.output.NewCenterExcelDto;
import com.kri.p6.ncrc.pairing.dto.excel.output.NewFinalAssignmentExcelDto;
import com.kri.p6.ncrc.pairing.dto.excel.output.NewFinalAssignmentWithCenterExcelDto;
import com.kri.p6.ncrc.pairing.dto.excel.output.NewPairScoreGuideExcelDto;
import com.kri.p6.ncrc.pairing.dto.excel.output.NewPairResultExcelDto;
import com.kri.p6.ncrc.pairing.dto.excel.output.RuleViolationExcelDto;
import com.kri.p6.ncrc.pairing.model.Center;
import com.kri.p6.ncrc.pairing.model.CenterAdjacentRegion;
import com.kri.p6.ncrc.pairing.model.Member;
import com.kri.p6.ncrc.pairing.model.Municipality;
import com.kri.p6.ncrc.pairing.model.NewAdjacentRegion;
import com.kri.p6.ncrc.pairing.model.NewCenter;
import com.kri.p6.ncrc.pairing.model.NewPairingResult;
import com.kri.p6.ncrc.pairing.model.PairingData;
import com.kri.p6.ncrc.pairing.model.PreferenceMatchRule;
import java.time.LocalDate;
import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedHashMap;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.Queue;
import java.util.Set;
import java.util.function.Function;
import java.util.stream.Collectors;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Service;
@Service
@RequiredArgsConstructor
public class PairingNewService {
private static final long ACTIVITY_WEIGHT = 1_000_000_000_000L;
private static final long DATE_WEIGHT = 1_000_000_000L;
private static final long PREFERENCE_WEIGHT = 1_000_000L;
private static final long HISTORY_WEIGHT = 1_000L;
private static final boolean USE_AVAILABLE_ADJACENT_REGION_IN_PAIR_SCORE = false;
private static final long AVAILABLE_ADJACENT_REGION_WEIGHT = 1_000_000_000_000_000L;
private final PairingProperties pairingProperties;
public NewPairingResult pair(PairingData data) {
List<NewCenter> newCenters = createNewCenters(data);
List<NewAdjacentRegion> newAdjacentRegions = createNewAdjacentRegions(data, newCenters);
List<ScoredPair> selectedPairs = sortSelectedPairsByAvailability(
matchMembers(data, newAdjacentRegions), newAdjacentRegions, data);
NewAssignmentResult assignmentResult = assignAdjacentRegions(selectedPairs, newAdjacentRegions,
data);
return NewPairingResult.builder()
.pairs(toPairRows(selectedPairs))
.finalAssignments(assignmentResult.assignments())
.finalAssignmentsWithCenters(assignmentResult.assignmentsWithCenters())
.adjacentRegions(toAdjacentRows(newAdjacentRegions))
.centers(toCenterRows(newCenters))
.summaries(createSummaries(data, selectedPairs, newCenters, newAdjacentRegions))
.scoreGuides(createScoreGuides())
.ruleChecks(createRuleChecks(data, selectedPairs, assignmentResult))
.build();
}
private List<NewCenter> createNewCenters(PairingData data) {
Map<String, Municipality> municipalityMap = data.getMunicipalities().stream()
.collect(Collectors.toMap(Municipality::getId, Function.identity(), (left, right) -> left));
return data.getCenters().stream()
.map(center -> toNewCenter(center, municipalityMap))
.sorted(Comparator.comparing(NewCenter::getId))
.toList();
}
private NewCenter toNewCenter(Center center, Map<String, Municipality> municipalityMap) {
Municipality municipality = municipalityMap.get(center.getMunicipalityId());
if (municipality == null) {
throw BusinessException.badRequest("PAIRING_BROKEN_MUNICIPALITY_REFERENCE",
"센터가 존재하지 않는 지자체를 참조합니다. centerId=" + center.getId()
+ ", municipalityId=" + center.getMunicipalityId());
}
Set<LocalDate> unavailableDates = new LinkedHashSet<>();
unavailableDates.addAll(center.getUnavailableDates());
unavailableDates.addAll(municipality.getUnavailableDates());
return NewCenter.builder()
.id(center.getId())
.womenOnly(center.isWomenOnly())
.adjacentRegionClassification(center.getAdjacentRegionClassification())
.availableStartDate(max(center.getAvailableStartDate(),
municipality.getAvailableStartDate()))
.availableEndDate(min(center.getAvailableEndDate(), municipality.getAvailableEndDate()))
.unavailableDates(unavailableDates)
.municipalityId(center.getMunicipalityId())
.municipalityAvailableStartDate(municipality.getAvailableStartDate())
.municipalityAvailableEndDate(municipality.getAvailableEndDate())
.municipalityUnavailableDates(municipality.getUnavailableDates())
.build();
}
private List<NewAdjacentRegion> createNewAdjacentRegions(PairingData data,
List<NewCenter> newCenters) {
Map<String, Set<String>> dispatchRegionsByAdjacentClassification = data.getCenterAdjacentRegions()
.stream()
.collect(Collectors.groupingBy(CenterAdjacentRegion::getAdjacentRegionClassification,
Collectors.mapping(CenterAdjacentRegion::getDispatchRegion,
Collectors.toCollection(LinkedHashSet::new))));
Map<String, List<NewCenter>> centersByAdjacentClassification = newCenters.stream()
.collect(Collectors.groupingBy(NewCenter::getAdjacentRegionClassification,
LinkedHashMap::new, Collectors.toList()));
List<NewAdjacentRegion> result = new ArrayList<>();
centersByAdjacentClassification.forEach((adjacentClassification, centers) -> {
Set<String> dispatchRegions = dispatchRegionsByAdjacentClassification
.getOrDefault(adjacentClassification, Set.of());
for (String dispatchRegion : dispatchRegions) {
result.add(toNewAdjacentRegion(dispatchRegion, adjacentClassification, centers,
data.getCommonUnavailableDates()));
}
});
result.sort(Comparator.comparing(NewAdjacentRegion::getDispatchRegion)
.thenComparing(NewAdjacentRegion::getAdjacentRegionClassification));
return result;
}
private NewAdjacentRegion toNewAdjacentRegion(String dispatchRegion,
String adjacentClassification, List<NewCenter> centers, Set<LocalDate> commonUnavailableDates) {
LocalDate start = centers.stream().map(NewCenter::getAvailableStartDate).max(LocalDate::compareTo)
.orElseThrow();
LocalDate end = centers.stream().map(NewCenter::getAvailableEndDate).min(LocalDate::compareTo)
.orElseThrow();
Set<LocalDate> unavailableDates = centers.stream()
.flatMap(center -> center.getUnavailableDates().stream())
.collect(Collectors.toCollection(LinkedHashSet::new));
unavailableDates.addAll(commonUnavailableDates);
Set<NewCenter> centerSet = centers.stream()
.collect(Collectors.toCollection(LinkedHashSet::new));
Set<String> centerIds = centerSet.stream().map(NewCenter::getId)
.collect(Collectors.toCollection(LinkedHashSet::new));
return NewAdjacentRegion.builder()
.dispatchRegion(dispatchRegion)
.adjacentRegionClassification(adjacentClassification)
.womenOnly(centerSet.stream().anyMatch(NewCenter::isWomenOnly))
.centers(centerSet)
.centerIds(centerIds)
.availableStartDate(start)
.availableEndDate(end)
.unavailableDates(unavailableDates)
.build();
}
private List<ScoredPair> matchMembers(PairingData data,
List<NewAdjacentRegion> newAdjacentRegions) {
List<Member> fieldMembers = data.getMembers().stream()
.filter(member -> member.getRole() == MemberRole.FIELD)
.sorted(Comparator.comparing(Member::getId))
.toList();
List<Member> externalMembers = data.getMembers().stream()
.filter(member -> member.getRole() == MemberRole.EXTERNAL)
.sorted(Comparator.comparing(Member::getId))
.toList();
if (fieldMembers.size() != externalMembers.size()) {
throw BusinessException.badRequest("PAIRING_MEMBER_COUNT_MISMATCH",
"현장위원 수와 외부위원 수가 다릅니다. field=" + fieldMembers.size()
+ ", external=" + externalMembers.size());
}
List<ScoredPair> candidates = createPairCandidates(fieldMembers, externalMembers,
data, newAdjacentRegions);
MinCostMatcher matcher = new MinCostMatcher(fieldMembers.size(), externalMembers.size());
long maxScore = candidates.stream().mapToLong(ScoredPair::score).max().orElse(0L);
for (ScoredPair candidate : candidates) {
matcher.addEdge(candidate.fieldIndex(), candidate.externalIndex(), maxScore - candidate.score());
}
Map<Integer, Integer> matches = matcher.match(fieldMembers.size());
if (matches.size() != fieldMembers.size()) {
throw BusinessException.badRequest("PAIRING_NEW_MEMBER_MATCH_FAILED",
"신규+신규 금지 조건을 만족하는 1:1 위원 매칭을 만들 수 없습니다.");
}
Map<String, ScoredPair> candidateMap = candidates.stream()
.collect(Collectors.toMap(candidate -> candidate.fieldIndex() + "|" + candidate.externalIndex(),
Function.identity(), (left, right) -> left));
return matches.entrySet().stream()
.map(entry -> candidateMap.get(entry.getKey() + "|" + entry.getValue()))
.filter(Objects::nonNull)
.sorted(Comparator.comparing(pair -> pair.fieldMember().getId()))
.toList();
}
private List<ScoredPair> createPairCandidates(List<Member> fieldMembers,
List<Member> externalMembers, PairingData data, List<NewAdjacentRegion> newAdjacentRegions) {
List<ScoredPair> candidates = new ArrayList<>();
for (int fieldIndex = 0; fieldIndex < fieldMembers.size(); fieldIndex++) {
Member fieldMember = fieldMembers.get(fieldIndex);
for (int externalIndex = 0; externalIndex < externalMembers.size(); externalIndex++) {
Member externalMember = externalMembers.get(externalIndex);
if (fieldMember.getExperienceType() == ExperienceType.NEW
&& externalMember.getExperienceType() == ExperienceType.NEW) {
continue;
}
candidates.add(scorePair(fieldIndex, externalIndex, fieldMember, externalMember,
data, newAdjacentRegions));
}
}
return candidates;
}
private ScoredPair scorePair(int fieldIndex, int externalIndex, Member fieldMember,
Member externalMember, PairingData data, List<NewAdjacentRegion> newAdjacentRegions) {
int activityOverlap = overlapCount(csvSet(fieldMember.getActivityRegion()),
csvSet(externalMember.getActivityRegion()));
int dateOverlap = availableDateOverlapCount(fieldMember, externalMember,
data.getCommonUnavailableDates());
int preferenceOverlap = overlapCount(preferenceSet(fieldMember), preferenceSet(externalMember));
int historyScore = historyScore(fieldMember, externalMember);
int residenceScore = residenceScore(fieldMember, externalMember);
AvailableRegionStats availability = USE_AVAILABLE_ADJACENT_REGION_IN_PAIR_SCORE
? availableRegionStats(fieldMember, externalMember, newAdjacentRegions, data)
: AvailableRegionStats.empty();
long score = activityOverlap * ACTIVITY_WEIGHT
+ dateOverlap * DATE_WEIGHT
+ preferenceOverlap * PREFERENCE_WEIGHT
+ historyScore * HISTORY_WEIGHT
+ residenceScore
+ availability.regionCount() * AVAILABLE_ADJACENT_REGION_WEIGHT;
return new ScoredPair(fieldIndex, externalIndex, fieldMember, externalMember, score,
activityOverlap, dateOverlap, preferenceOverlap, historyScore, residenceScore,
availability.regionCount(), availability.dateCount());
}
private List<ScoredPair> sortSelectedPairsByAvailability(List<ScoredPair> pairs,
List<NewAdjacentRegion> newAdjacentRegions, PairingData data) {
return pairs.stream()
.map(pair -> pair.withAvailability(availableRegionStats(pair.fieldMember(),
pair.externalMember(), newAdjacentRegions, data)))
.sorted(Comparator.comparingInt(ScoredPair::availableAdjacentRegionCount)
.thenComparingInt(ScoredPair::availableAdjacentRegionDateCount)
.thenComparing(Comparator.comparingLong(ScoredPair::score).reversed())
.thenComparing(pair -> pair.fieldMember().getId())
.thenComparing(pair -> pair.externalMember().getId()))
.toList();
}
private AvailableRegionStats availableRegionStats(Member fieldMember, Member externalMember,
List<NewAdjacentRegion> newAdjacentRegions, PairingData data) {
int regionCount = 0;
Set<LocalDate> availableDates = new LinkedHashSet<>();
for (NewAdjacentRegion region : newAdjacentRegions) {
if (region.isWomenOnly() && (fieldMember.getGender() != Gender.FEMALE
|| externalMember.getGender() != Gender.FEMALE)) {
continue;
}
if (hasActivityRegion(fieldMember, region.getDispatchRegion())
|| hasActivityRegion(externalMember, region.getDispatchRegion())) {
continue;
}
if (hasHistoryConflict(fieldMember, externalMember, region.getCenterIds())) {
continue;
}
if (!isPreferenceAllowed(fieldMember, externalMember, region.getDispatchRegion(),
data.getPreferenceMatchRules())) {
continue;
}
Set<LocalDate> dates = availableDatesForRegion(fieldMember, externalMember, region);
if (!dates.isEmpty()) {
regionCount++;
availableDates.addAll(dates);
}
}
return new AvailableRegionStats(regionCount, availableDates.size());
}
private Set<LocalDate> availableDatesForRegion(Member fieldMember, Member externalMember,
NewAdjacentRegion region) {
LocalDate start = max(max(fieldMember.getAvailableStartDate(),
externalMember.getAvailableStartDate()), region.getAvailableStartDate());
LocalDate end = min(min(fieldMember.getAvailableEndDate(), externalMember.getAvailableEndDate()),
region.getAvailableEndDate());
Set<LocalDate> dates = new LinkedHashSet<>();
if (start.isAfter(end)) {
return dates;
}
for (LocalDate date = start; !date.isAfter(end); date = date.plusDays(1L)) {
if (!fieldMember.getUnavailableDates().contains(date)
&& !externalMember.getUnavailableDates().contains(date)
&& !region.getUnavailableDates().contains(date)) {
dates.add(date);
}
}
return dates;
}
private boolean hasHistoryConflict(Member fieldMember, Member externalMember,
Set<String> centerIds) {
return centerIds.stream().anyMatch(centerId -> fieldMember.getHistoryCenterIds().contains(centerId)
|| externalMember.getHistoryCenterIds().contains(centerId));
}
private boolean isPreferenceAllowed(Member fieldMember, Member externalMember,
String dispatchRegion, List<PreferenceMatchRule> rules) {
return findPreferenceMatchPriority(fieldMember, externalMember, dispatchRegion, rules) != null;
}
private Integer findPreferenceMatchPriority(Member fieldMember, Member externalMember,
String dispatchRegion, List<PreferenceMatchRule> rules) {
int fieldRank = findPreferenceRank(fieldMember, dispatchRegion);
int externalRank = findPreferenceRank(externalMember, dispatchRegion);
return rules.stream()
.filter(rule -> matchesPreferenceRank(rule.getFieldMemberPreferenceRank(), fieldRank))
.filter(rule -> matchesPreferenceRank(rule.getExternalMemberPreferenceRank(),
externalRank))
.map(PreferenceMatchRule::getPriority)
.min(Integer::compareTo)
.orElse(null);
}
private int findPreferenceRank(Member member, String dispatchRegion) {
List<String> preferences = member.getPreferenceRegions();
for (int i = 0; i < preferences.size(); i++) {
String preference = preferences.get(i);
if (dispatchRegion.equals(preference)) {
return i + 1;
}
if (anyRegionCode().equals(preference)) {
return anywherePreferenceRank();
}
}
return -1;
}
private boolean matchesPreferenceRank(int ruleRank, int memberRank) {
return ruleRank == ignoredPreferenceRank() || ruleRank == memberRank;
}
private int availableDateOverlapCount(Member fieldMember, Member externalMember,
Set<LocalDate> commonUnavailableDates) {
LocalDate start = max(fieldMember.getAvailableStartDate(), externalMember.getAvailableStartDate());
LocalDate end = min(fieldMember.getAvailableEndDate(), externalMember.getAvailableEndDate());
int count = 0;
if (start.isAfter(end)) {
return 0;
}
for (LocalDate date = start; !date.isAfter(end); date = date.plusDays(1L)) {
if (!fieldMember.getUnavailableDates().contains(date)
&& !externalMember.getUnavailableDates().contains(date)
&& !commonUnavailableDates.contains(date)) {
count++;
}
}
return count;
}
private int historyScore(Member fieldMember, Member externalMember) {
Set<String> fieldHistory = fieldMember.getHistoryCenterIds();
Set<String> externalHistory = externalMember.getHistoryCenterIds();
if (fieldHistory.isEmpty() && externalHistory.isEmpty()) {
return 300;
}
if (!fieldHistory.isEmpty() && !externalHistory.isEmpty()) {
int overlap = overlapCount(fieldHistory, externalHistory);
return overlap > 0 ? 200 + overlap : 0;
}
return 100;
}
private int residenceScore(Member fieldMember, Member externalMember) {
String fieldResidence = fieldMember.getResidenceCode();
String externalResidence = externalMember.getResidenceCode();
if (fieldResidence == null || externalResidence == null
|| fieldResidence.isBlank() || externalResidence.isBlank()) {
return 0;
}
if (hasSamePrefix(fieldResidence, externalResidence, 3)) {
return 3;
}
return hasSamePrefix(fieldResidence, externalResidence, 2) ? 2 : 0;
}
private boolean hasSamePrefix(String left, String right, int length) {
return left.length() >= length && right.length() >= length
&& left.substring(0, length).equals(right.substring(0, length));
}
private List<NewPairResultExcelDto> toPairRows(List<ScoredPair> pairs) {
List<NewPairResultExcelDto> rows = new ArrayList<>();
for (int i = 0; i < pairs.size(); i++) {
ScoredPair pair = pairs.get(i);
Member field = pair.fieldMember();
Member external = pair.externalMember();
rows.add(new NewPairResultExcelDto(String.valueOf(i + 1), field.getId(),
formatExperience(field.getExperienceType()), formatGender(field.getGender()),
field.getActivityRegion(), field.getResidenceCode(),
join(field.getHistoryCenterIds()), external.getId(),
formatExperience(external.getExperienceType()), formatGender(external.getGender()),
external.getActivityRegion(), external.getResidenceCode(),
join(external.getHistoryCenterIds()),
String.valueOf(pair.availableAdjacentRegionCount()),
String.valueOf(pair.availableAdjacentRegionDateCount()), String.valueOf(pair.score()),
String.valueOf(pair.activityOverlapCount()),
String.valueOf(pair.availableDateOverlapCount()),
String.valueOf(pair.preferenceOverlapCount()), String.valueOf(pair.historyScore()),
String.valueOf(pair.residenceScore())));
}
return rows;
}
private NewAssignmentResult assignAdjacentRegions(List<ScoredPair> pairs,
List<NewAdjacentRegion> newAdjacentRegions, PairingData data) {
Map<ScoredPair, String> pairNoMap = new LinkedHashMap<>();
for (int i = 0; i < pairs.size(); i++) {
pairNoMap.put(pairs.get(i), String.valueOf(i + 1));
}
Set<String> assignedAdjacentClassifications = new LinkedHashSet<>();
Map<ScoredPair, Set<LocalDate>> usedDatesByPair = new LinkedHashMap<>();
pairs.forEach(pair -> usedDatesByPair.put(pair, new LinkedHashSet<>()));
List<NewFinalAssignmentExcelDto> rows = new ArrayList<>();
List<NewFinalAssignmentWithCenterExcelDto> centerRows = new ArrayList<>();
List<AssignmentAudit> audits = new ArrayList<>();
boolean assignedInPass = true;
while (assignedInPass) {
assignedInPass = false;
for (ScoredPair pair : pairs) {
AssignmentChoice choice = findBestAssignmentChoice(pair, newAdjacentRegions, data,
assignedAdjacentClassifications, usedDatesByPair.get(pair));
if (choice == null) {
continue;
}
// 한 페어가 같은 날 두 인접지역을 방문하지 않도록 배정 직후 날짜를 잠급니다.
assignedAdjacentClassifications.add(choice.region().getAdjacentRegionClassification());
usedDatesByPair.get(pair).add(choice.date());
String pairNo = pairNoMap.get(pair);
rows.add(new NewFinalAssignmentExcelDto(formatDate(choice.date()), pairNo,
pair.fieldMember().getId(), pair.externalMember().getId(),
String.valueOf(choice.preferencePriority()),
choice.region().getAdjacentRegionClassification()));
centerRows.addAll(toAssignmentWithCenterRows(choice, pair, pairNo));
audits.add(new AssignmentAudit(pairNo, pair, choice));
assignedInPass = true;
}
}
return new NewAssignmentResult(rows, centerRows, audits);
}
private List<NewFinalAssignmentWithCenterExcelDto> toAssignmentWithCenterRows(
AssignmentChoice choice, ScoredPair pair, String pairNo) {
return choice.region().getCenters().stream()
.sorted(Comparator.comparing(NewCenter::getId))
.map(center -> new NewFinalAssignmentWithCenterExcelDto(center.getId(),
center.getMunicipalityId(), center.getAdjacentRegionClassification(),
center.isWomenOnly() ? "1" : "0", formatDate(center.getAvailableStartDate()),
formatDate(center.getAvailableEndDate()), joinDates(center.getUnavailableDates()),
formatDate(choice.date()), pairNo, pair.fieldMember().getId(),
pair.externalMember().getId(), String.valueOf(choice.preferencePriority()),
choice.region().getAdjacentRegionClassification()))
.toList();
}
private AssignmentChoice findBestAssignmentChoice(ScoredPair pair,
List<NewAdjacentRegion> newAdjacentRegions, PairingData data,
Set<String> assignedAdjacentClassifications, Set<LocalDate> usedDates) {
AssignmentChoice bestChoice = null;
for (NewAdjacentRegion region : newAdjacentRegions) {
if (assignedAdjacentClassifications.contains(region.getAdjacentRegionClassification())) {
continue;
}
if (region.isWomenOnly() && (pair.fieldMember().getGender() != Gender.FEMALE
|| pair.externalMember().getGender() != Gender.FEMALE)) {
continue;
}
if (hasActivityRegion(pair.fieldMember(), region.getDispatchRegion())
|| hasActivityRegion(pair.externalMember(), region.getDispatchRegion())) {
continue;
}
if (hasHistoryConflict(pair.fieldMember(), pair.externalMember(), region.getCenterIds())) {
continue;
}
Integer preferencePriority = findPreferenceMatchPriority(pair.fieldMember(),
pair.externalMember(), region.getDispatchRegion(), data.getPreferenceMatchRules());
if (preferencePriority == null) {
continue;
}
LocalDate date = firstAvailableDateForRegion(pair.fieldMember(), pair.externalMember(),
region, usedDates);
if (date == null) {
continue;
}
AssignmentChoice choice = new AssignmentChoice(region, date, preferencePriority);
if (isBetterAssignmentChoice(choice, bestChoice)) {
bestChoice = choice;
}
}
return bestChoice;
}
private boolean isBetterAssignmentChoice(AssignmentChoice current, AssignmentChoice best) {
if (best == null) {
return true;
}
return Comparator.comparingInt(AssignmentChoice::preferencePriority)
.thenComparing(AssignmentChoice::date)
.thenComparing(choice -> choice.region().getAdjacentRegionClassification())
.thenComparing(choice -> choice.region().getDispatchRegion())
.compare(current, best) < 0;
}
private LocalDate firstAvailableDateForRegion(Member fieldMember, Member externalMember,
NewAdjacentRegion region, Set<LocalDate> usedDates) {
LocalDate start = max(max(fieldMember.getAvailableStartDate(),
externalMember.getAvailableStartDate()), region.getAvailableStartDate());
LocalDate end = min(min(fieldMember.getAvailableEndDate(), externalMember.getAvailableEndDate()),
region.getAvailableEndDate());
if (start.isAfter(end)) {
return null;
}
for (LocalDate date = start; !date.isAfter(end); date = date.plusDays(1L)) {
if (!usedDates.contains(date)
&& !fieldMember.getUnavailableDates().contains(date)
&& !externalMember.getUnavailableDates().contains(date)
&& !region.getUnavailableDates().contains(date)) {
return date;
}
}
return null;
}
private List<NewAdjacentRegionExcelDto> toAdjacentRows(List<NewAdjacentRegion> regions) {
return regions.stream()
.map(region -> new NewAdjacentRegionExcelDto(region.getDispatchRegion(),
region.getAdjacentRegionClassification(), region.isWomenOnly() ? "1" : "0",
String.valueOf(region.getCenters().size()), join(region.getCenterIds()),
formatDate(region.getAvailableStartDate()), formatDate(region.getAvailableEndDate()),
joinDates(region.getUnavailableDates())))
.toList();
}
private List<NewCenterExcelDto> toCenterRows(List<NewCenter> centers) {
return centers.stream()
.map(center -> new NewCenterExcelDto(center.getId(), center.getMunicipalityId(),
center.getAdjacentRegionClassification(), center.isWomenOnly() ? "1" : "0",
formatDate(center.getAvailableStartDate()), formatDate(center.getAvailableEndDate()),
joinDates(center.getUnavailableDates())))
.toList();
}
private List<CandidateSummaryExcelDto> createSummaries(PairingData data,
List<ScoredPair> selectedPairs, List<NewCenter> newCenters,
List<NewAdjacentRegion> newAdjacentRegions) {
long fieldCount = data.getMembers().stream()
.filter(member -> member.getRole() == MemberRole.FIELD)
.count();
long externalCount = data.getMembers().stream()
.filter(member -> member.getRole() == MemberRole.EXTERNAL)
.count();
return List.of(
new CandidateSummaryExcelDto("현장위원 수", String.valueOf(fieldCount), "입력 현장위원 수"),
new CandidateSummaryExcelDto("외부위원 수", String.valueOf(externalCount), "입력 외부위원 수"),
new CandidateSummaryExcelDto("생성 페어 수", String.valueOf(selectedPairs.size()),
"현장 1명 + 외부 1명으로 확정된 1:1 페어 수"),
new CandidateSummaryExcelDto("신규센터 수", String.valueOf(newCenters.size()),
"센터와 지자체 일정을 합친 센터 수"),
new CandidateSummaryExcelDto("신규인접지역 수", String.valueOf(newAdjacentRegions.size()),
"파견 권역 + 인접지역 분류 기준 방문 묶음 수"),
new CandidateSummaryExcelDto("공통 불가일 수", String.valueOf(data.getCommonUnavailableDates().size()),
"토/일/공휴일 등 공통 제외 일자 수"));
}
private List<RuleViolationExcelDto> createRuleChecks(PairingData data,
List<ScoredPair> selectedPairs, NewAssignmentResult assignmentResult) {
Set<String> fieldIds = selectedPairs.stream().map(pair -> pair.fieldMember().getId())
.collect(Collectors.toCollection(LinkedHashSet::new));
Set<String> externalIds = selectedPairs.stream().map(pair -> pair.externalMember().getId())
.collect(Collectors.toCollection(LinkedHashSet::new));
long inputFieldCount = data.getMembers().stream()
.filter(member -> member.getRole() == MemberRole.FIELD)
.count();
long inputExternalCount = data.getMembers().stream()
.filter(member -> member.getRole() == MemberRole.EXTERNAL)
.count();
boolean hasNewNewPair = selectedPairs.stream()
.anyMatch(pair -> pair.fieldMember().getExperienceType() == ExperienceType.NEW
&& pair.externalMember().getExperienceType() == ExperienceType.NEW);
List<RuleViolationExcelDto> checks = new ArrayList<>();
checks.add(new RuleViolationExcelDto("현장위원 전체 사용",
passFail(fieldIds.size() == inputFieldCount),
"입력=" + inputFieldCount + ", 사용=" + fieldIds.size()));
checks.add(new RuleViolationExcelDto("외부위원 전체 사용",
passFail(externalIds.size() == inputExternalCount),
"입력=" + inputExternalCount + ", 사용=" + externalIds.size()));
checks.add(new RuleViolationExcelDto("1:1 페어 수",
passFail(selectedPairs.size() == inputFieldCount && inputFieldCount == inputExternalCount),
"페어=" + selectedPairs.size()));
checks.add(new RuleViolationExcelDto("신규+신규 페어 금지",
passFail(!hasNewNewPair),
hasNewNewPair ? "신규+신규 페어가 존재합니다." : "위반 없음"));
checks.addAll(createAssignmentRuleChecks(assignmentResult));
return checks;
}
private List<RuleViolationExcelDto> createAssignmentRuleChecks(
NewAssignmentResult assignmentResult) {
List<AssignmentAudit> audits = assignmentResult.audits();
List<RuleViolationExcelDto> checks = new ArrayList<>();
List<String> duplicatePairDate = duplicateKeys(audits.stream()
.map(audit -> audit.pairNo() + "|" + audit.choice().date())
.toList());
checks.add(new RuleViolationExcelDto("페어별 하루 하나의 인접지역",
passFail(duplicatePairDate.isEmpty()),
duplicatePairDate.isEmpty() ? "위반 없음" : "중복=" + limitDetail(duplicatePairDate)));
List<String> duplicateAdjacentClassifications = duplicateKeys(audits.stream()
.map(audit -> audit.choice().region().getAdjacentRegionClassification())
.toList());
checks.add(new RuleViolationExcelDto("인접지역 분류 중복 배정 금지",
passFail(duplicateAdjacentClassifications.isEmpty()),
duplicateAdjacentClassifications.isEmpty() ? "위반 없음"
: "중복=" + limitDetail(duplicateAdjacentClassifications)));
List<String> unavailableDateViolations = audits.stream()
.filter(audit -> !isAssignmentDateAllowed(audit))
.map(this::assignmentDetail)
.toList();
checks.add(new RuleViolationExcelDto("가능 날짜/불가일 준수",
passFail(unavailableDateViolations.isEmpty()),
unavailableDateViolations.isEmpty() ? "위반 없음"
: "위반=" + limitDetail(unavailableDateViolations)));
List<String> conflictRegionViolations = audits.stream()
.filter(audit -> hasActivityRegion(audit.pair().fieldMember(),
audit.choice().region().getDispatchRegion())
|| hasActivityRegion(audit.pair().externalMember(),
audit.choice().region().getDispatchRegion()))
.map(this::assignmentDetail)
.toList();
checks.add(new RuleViolationExcelDto("상피제 준수",
passFail(conflictRegionViolations.isEmpty()),
conflictRegionViolations.isEmpty() ? "위반 없음"
: "위반=" + limitDetail(conflictRegionViolations)));
List<String> womenOnlyViolations = audits.stream()
.filter(audit -> audit.choice().region().isWomenOnly()
&& (audit.pair().fieldMember().getGender() != Gender.FEMALE
|| audit.pair().externalMember().getGender() != Gender.FEMALE))
.map(this::assignmentDetail)
.toList();
checks.add(new RuleViolationExcelDto("여성위원만 조건 준수",
passFail(womenOnlyViolations.isEmpty()),
womenOnlyViolations.isEmpty() ? "위반 없음"
: "위반=" + limitDetail(womenOnlyViolations)));
List<String> historyViolations = audits.stream()
.filter(audit -> hasHistoryConflict(audit.pair().fieldMember(),
audit.pair().externalMember(), audit.choice().region().getCenterIds()))
.map(this::assignmentDetail)
.toList();
checks.add(new RuleViolationExcelDto("2023년 진행 센터 재배정 제외",
passFail(historyViolations.isEmpty()),
historyViolations.isEmpty() ? "위반 없음" : "위반=" + limitDetail(historyViolations)));
List<String> preferenceRuleViolations = audits.stream()
.filter(audit -> audit.choice().preferencePriority() <= 0)
.map(this::assignmentDetail)
.toList();
checks.add(new RuleViolationExcelDto("희망지역 매칭표 조합 준수",
passFail(preferenceRuleViolations.isEmpty()),
preferenceRuleViolations.isEmpty() ? "위반 없음"
: "위반=" + limitDetail(preferenceRuleViolations)));
return checks;
}
private boolean isAssignmentDateAllowed(AssignmentAudit audit) {
LocalDate date = audit.choice().date();
NewAdjacentRegion region = audit.choice().region();
Member fieldMember = audit.pair().fieldMember();
Member externalMember = audit.pair().externalMember();
return !date.isBefore(fieldMember.getAvailableStartDate())
&& !date.isAfter(fieldMember.getAvailableEndDate())
&& !date.isBefore(externalMember.getAvailableStartDate())
&& !date.isAfter(externalMember.getAvailableEndDate())
&& !date.isBefore(region.getAvailableStartDate())
&& !date.isAfter(region.getAvailableEndDate())
&& !fieldMember.getUnavailableDates().contains(date)
&& !externalMember.getUnavailableDates().contains(date)
&& !region.getUnavailableDates().contains(date);
}
private List<String> duplicateKeys(List<String> keys) {
Set<String> seen = new HashSet<>();
Set<String> duplicated = new LinkedHashSet<>();
for (String key : keys) {
if (!seen.add(key)) {
duplicated.add(key);
}
}
return new ArrayList<>(duplicated);
}
private String assignmentDetail(AssignmentAudit audit) {
return "페어=" + audit.pairNo()
+ ", 일자=" + audit.choice().date()
+ ", 파견권역=" + audit.choice().region().getDispatchRegion()
+ ", 인접지역분류=" + audit.choice().region().getAdjacentRegionClassification();
}
private String limitDetail(List<String> details) {
int limit = Math.min(details.size(), 10);
String value = details.subList(0, limit).stream().collect(Collectors.joining(" / "));
if (details.size() > limit) {
value += " / 외 " + (details.size() - limit) + "건";
}
return value;
}
private String passFail(boolean passed) {
return passed ? "PASS" : "FAIL";
}
private List<NewPairScoreGuideExcelDto> createScoreGuides() {
return List.of(
new NewPairScoreGuideExcelDto("0", "신규+신규 금지",
"현장위원과 외부위원이 모두 신규이면 후보에서 제외",
"HARD RULE",
"이 조건을 만족하지 못하는 조합은 점수 계산 전에 제거됩니다."),
new NewPairScoreGuideExcelDto("1", "활동지역 겹침 수",
"현장위원 활동지역 코드와 외부위원 활동지역 코드의 교집합 개수",
"겹침 수 * 1,000,000,000,000",
"현재 1순위 soft rule입니다. 값이 클수록 두 위원이 같은 활동지역 경험을 공유합니다."),
new NewPairScoreGuideExcelDto("2", "가능일자 겹침 수",
"두 위원의 공통 가능 기간 중 위원별 불가일과 공통 불가일을 제외하고 함께 가능한 날짜 수",
"겹침 수 * 1,000,000,000",
"같이 움직일 수 있는 날짜가 많은 페어를 우선합니다."),
new NewPairScoreGuideExcelDto("3", "선호지역 겹침 수",
"두 위원의 선호지역 코드 교집합 개수",
"겹침 수 * 1,000,000",
"희망지역이 많이 겹치는 페어를 우선합니다."),
new NewPairScoreGuideExcelDto("4", "23년 진행 센터 점수",
"둘 다 비어 있음=300, 둘 다 있고 겹침 있음=200+겹침 수, 한쪽만 있음=100, 둘 다 있고 겹침 없음=0",
"점수 * 1,000",
"두 위원의 기방문 센터 제외 풀을 줄여 이후 방문 가능한 센터 묶음을 넓히기 위한 점수입니다."),
new NewPairScoreGuideExcelDto("5", "거주지 유사도",
"거주지 코드 앞 3자리 동일=3, 앞 2자리 동일=2, 그 외=0",
"점수 그대로 더함",
"동점에 가까운 후보 사이에서 거주지가 비슷한 페어를 우선합니다."),
new NewPairScoreGuideExcelDto("6", "배정 가능 인접지역 수",
"선택된 페어가 여성전용, 상피제, 23년 진행 센터, 선호지역, 날짜 조건을 만족하며 방문할 수 있는 인접지역 수",
"현재 결과 정렬에만 사용",
"배정 가능한 인접지역이 적은 페어가 먼저 센터를 선택할 수 있도록 결과 순서를 앞쪽으로 정렬합니다. 점수 직접 반영은 비활성 상태입니다."),
new NewPairScoreGuideExcelDto("7", "총점",
"활동지역점수 + 가능일자점수 + 선호지역점수 + 23년센터점수 + 거주지점수",
"값이 큰 조합 우선",
"전체 현장위원과 외부위원이 정확히 1:1로 매칭되도록 총점 합이 큰 조합을 선택합니다.")
);
}
private Set<String> csvSet(String value) {
if (value == null || value.isBlank()) {
return Set.of();
}
return java.util.Arrays.stream(value.split(","))
.map(String::trim)
.filter(token -> !token.isBlank())
.collect(Collectors.toCollection(LinkedHashSet::new));
}
private boolean hasActivityRegion(Member member, String dispatchRegion) {
return csvSet(member.getActivityRegion()).contains(dispatchRegion);
}
private Set<String> preferenceSet(Member member) {
return member.getPreferenceRegions().stream()
.filter(value -> value != null && !value.isBlank())
.collect(Collectors.toCollection(LinkedHashSet::new));
}
private int overlapCount(Set<String> left, Set<String> right) {
Set<String> copied = new HashSet<>(left);
copied.retainAll(right);
return copied.size();
}
private String formatExperience(ExperienceType experienceType) {
return experienceType == ExperienceType.EXPERIENCED ? "경력" : "신규";
}
private String formatGender(Gender gender) {
return gender == Gender.FEMALE ? "여성" : "남성";
}
private String formatDate(LocalDate date) {
return date == null ? "" : date.toString();
}
private String join(Set<String> values) {
return values.stream().sorted().collect(Collectors.joining(","));
}
private String joinDates(Set<LocalDate> dates) {
return dates.stream().sorted().map(LocalDate::toString).collect(Collectors.joining(","));
}
private String anyRegionCode() {
return pairingProperties.getCode().getAnyRegionCode();
}
private int anywherePreferenceRank() {
return pairingProperties.getPreference().getAnywhereRank();
}
private int ignoredPreferenceRank() {
return pairingProperties.getPreference().getIgnoredRank();
}
private LocalDate max(LocalDate left, LocalDate right) {
return left.isAfter(right) ? left : right;
}
private LocalDate min(LocalDate left, LocalDate right) {
return left.isBefore(right) ? left : right;
}
private record ScoredPair(int fieldIndex, int externalIndex, Member fieldMember,
Member externalMember, long score, int activityOverlapCount,
int availableDateOverlapCount, int preferenceOverlapCount,
int historyScore, int residenceScore,
int availableAdjacentRegionCount,
int availableAdjacentRegionDateCount) {
private ScoredPair withAvailability(AvailableRegionStats availability) {
return new ScoredPair(fieldIndex, externalIndex, fieldMember, externalMember, score,
activityOverlapCount, availableDateOverlapCount, preferenceOverlapCount, historyScore,
residenceScore, availability.regionCount(), availability.dateCount());
}
}
private record AvailableRegionStats(int regionCount, int dateCount) {
private static AvailableRegionStats empty() {
return new AvailableRegionStats(0, 0);
}
}
private record AssignmentChoice(NewAdjacentRegion region, LocalDate date,
int preferencePriority) {
}
private record AssignmentAudit(String pairNo, ScoredPair pair, AssignmentChoice choice) {
}
private record NewAssignmentResult(List<NewFinalAssignmentExcelDto> assignments,
List<NewFinalAssignmentWithCenterExcelDto> assignmentsWithCenters,
List<AssignmentAudit> audits) {
}
private static class MinCostMatcher {
private final int source;
private final int sink;
private final int leftSize;
private final int rightSize;
private final List<List<Edge>> graph;
private MinCostMatcher(int leftSize, int rightSize) {
this.leftSize = leftSize;
this.rightSize = rightSize;
source = leftSize + rightSize;
sink = source + 1;
graph = new ArrayList<>();
for (int i = 0; i <= sink; i++) {
graph.add(new ArrayList<>());
}
for (int i = 0; i < leftSize; i++) {
addFlowEdge(source, i, 1, 0L);
}
for (int i = 0; i < rightSize; i++) {
addFlowEdge(leftSize + i, sink, 1, 0L);
}
}
private void addEdge(int leftIndex, int rightIndex, long cost) {
int rightNode = leftSize + rightIndex;
addFlowEdge(leftIndex, rightNode, 1, cost);
}
private Map<Integer, Integer> match(int targetFlow) {
int flow = 0;
while (flow < targetFlow && augment()) {
flow++;
}
Map<Integer, Integer> matches = new LinkedHashMap<>();
int rightOffset = leftSize;
for (int left = 0; left < leftSize; left++) {
for (Edge edge : graph.get(left)) {
if (edge.to >= rightOffset && edge.to < rightOffset + rightSize
&& edge.capacity == 0) {
matches.put(left, edge.to - rightOffset);
}
}
}
return matches;
}
private boolean augment() {
long[] distance = new long[graph.size()];
Edge[] previousEdge = new Edge[graph.size()];
int[] previousNode = new int[graph.size()];
java.util.Arrays.fill(distance, Long.MAX_VALUE / 4);
boolean[] inQueue = new boolean[graph.size()];
Queue<Integer> queue = new ArrayDeque<>();
distance[source] = 0L;
queue.add(source);
inQueue[source] = true;
while (!queue.isEmpty()) {
int node = queue.poll();
inQueue[node] = false;
for (Edge edge : graph.get(node)) {
if (edge.capacity <= 0 || distance[edge.to] <= distance[node] + edge.cost) {
continue;
}
distance[edge.to] = distance[node] + edge.cost;
previousNode[edge.to] = node;
previousEdge[edge.to] = edge;
if (!inQueue[edge.to]) {
queue.add(edge.to);
inQueue[edge.to] = true;
}
}
}
if (previousEdge[sink] == null) {
return false;
}
for (int node = sink; node != source; node = previousNode[node]) {
Edge edge = previousEdge[node];
edge.capacity--;
graph.get(edge.to).get(edge.reverseIndex).capacity++;
}
return true;
}
private void addFlowEdge(int from, int to, int capacity, long cost) {
Edge forward = new Edge(to, graph.get(to).size(), capacity, cost);
Edge reverse = new Edge(from, graph.get(from).size(), 0, -cost);
graph.get(from).add(forward);
graph.get(to).add(reverse);
}
}
private static class Edge {
private final int to;
private final int reverseIndex;
private int capacity;
private final long cost;
private Edge(int to, int reverseIndex, int capacity, long cost) {
this.to = to;
this.reverseIndex = reverseIndex;
this.capacity = capacity;
this.cost = cost;
}
}
}

View File

@@ -52,6 +52,8 @@ public class PairingNormalizeService {
.toList()).commonUnavailableDates(Set.of()).build(); .toList()).commonUnavailableDates(Set.of()).build();
} }
private Member toMember(MemberExcelDto row) { private Member toMember(MemberExcelDto row) {
return Member.builder().id(required(row.getId(), "위원 id")) return Member.builder().id(required(row.getId(), "위원 id"))
.gender(parseGender(row.getGender())) .gender(parseGender(row.getGender()))
@@ -61,7 +63,7 @@ public class PairingNormalizeService {
.availableEndDate(parseDate(row.getAvailableEndDate(), "위원 진행 종료일")) .availableEndDate(parseDate(row.getAvailableEndDate(), "위원 진행 종료일"))
.unavailableDates(parseDateSet(row.getUnavailableDates(), "위원 진행 불가 일자")) .unavailableDates(parseDateSet(row.getUnavailableDates(), "위원 진행 불가 일자"))
.activityRegion(normalizeCsvCodes(row.getActivityRegion(), regionCodeLength(), "위원 활동지역")) .activityRegion(normalizeCsvCodes(row.getActivityRegion(), regionCodeLength(), "위원 활동지역"))
.historyCenterIds(parseCsv(row.getHistoryCenters())).residenceCode( .historyCenterIds(parseHistoryCenterIds(row.getHistoryCenters())).residenceCode(
normalizeOptionalCode(row.getResidenceCode(), residenceCodeLength(), "위원 거주지")) normalizeOptionalCode(row.getResidenceCode(), residenceCodeLength(), "위원 거주지"))
.preferenceRegions(normalizePreferenceRegions(row)).build(); .preferenceRegions(normalizePreferenceRegions(row)).build();
} }
@@ -208,6 +210,20 @@ public class PairingNormalizeService {
.collect(Collectors.toCollection(LinkedHashSet::new))); .collect(Collectors.toCollection(LinkedHashSet::new)));
} }
private Set<String> parseHistoryCenterIds(String value) {
return parseCsv(value).stream()
.map(this::normalizeExcelIdText)
.collect(Collectors.toCollection(LinkedHashSet::new));
}
private String normalizeExcelIdText(String value) {
String cleaned = clean(value);
if (cleaned.matches("\\d+\\.0+")) {
return cleaned.substring(0, cleaned.indexOf('.'));
}
return cleaned;
}
private int parseInt(String value, String fieldName) { private int parseInt(String value, String fieldName) {
String cleaned = required(value, fieldName); String cleaned = required(value, fieldName);

View File

@@ -1,6 +1,7 @@
package com.kri.p6.ncrc.pairing.service; package com.kri.p6.ncrc.pairing.service;
import com.kri.p6.ncrc.pairing.dto.excel.input.PairingWorkbookData; import com.kri.p6.ncrc.pairing.dto.excel.input.PairingWorkbookData;
import com.kri.p6.ncrc.pairing.model.NewPairingResult;
import com.kri.p6.ncrc.pairing.model.PairingData; import com.kri.p6.ncrc.pairing.model.PairingData;
import com.kri.p6.ncrc.pairing.model.PairingResult; import com.kri.p6.ncrc.pairing.model.PairingResult;
import lombok.RequiredArgsConstructor; import lombok.RequiredArgsConstructor;
@@ -16,6 +17,7 @@ public class PairingService {
private final PairingHolidayService pairingHolidayService; private final PairingHolidayService pairingHolidayService;
private final PairingValidationService pairingValidationService; private final PairingValidationService pairingValidationService;
private final PairingScheduleService pairingScheduleService; private final PairingScheduleService pairingScheduleService;
private final PairingNewService pairingNewService;
public byte[] pairingMemberByCenter(MultipartFile file) { public byte[] pairingMemberByCenter(MultipartFile file) {
PairingWorkbookData workbookData = pairingExcelService.read(file); PairingWorkbookData workbookData = pairingExcelService.read(file);
@@ -25,4 +27,13 @@ public class PairingService {
PairingResult result = pairingScheduleService.schedule(pairingData); PairingResult result = pairingScheduleService.schedule(pairingData);
return pairingExcelService.write(result); return pairingExcelService.write(result);
} }
public byte[] pairingMemberByCenterNew(MultipartFile file) {
PairingWorkbookData workbookData = pairingExcelService.read(file);
PairingData pairingData = pairingNormalizeService.normalize(workbookData);
pairingData = pairingHolidayService.applyHolidayUnavailableDates(pairingData);
pairingValidationService.validate(pairingData);
NewPairingResult result = pairingNewService.pair(pairingData);
return pairingExcelService.writeNew(result);
}
} }