From 993c766d6b8ed44eedae6391477b3f154fd75fd3 Mon Sep 17 00:00:00 2001 From: kric_jspark Date: Mon, 20 Apr 2026 18:54:50 +0900 Subject: [PATCH] =?UTF-8?q?260420=5F02=5FENH:=20=EB=A1=9C=EC=A7=81=20?= =?UTF-8?q?=EB=8B=A8=EC=88=9C=ED=99=94=20=EA=B5=AC=ED=98=84=20=EC=99=84?= =?UTF-8?q?=EB=A3=8C?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../pairing/controller/PairingController.java | 22 + .../output/NewAdjacentRegionExcelDto.java | 36 + .../dto/excel/output/NewCenterExcelDto.java | 33 + .../output/NewFinalAssignmentExcelDto.java | 30 + .../NewFinalAssignmentWithCenterExcelDto.java | 51 + .../excel/output/NewPairResultExcelDto.java | 75 ++ .../output/NewPairScoreGuideExcelDto.java | 27 + .../ncrc/pairing/model/NewAdjacentRegion.java | 21 + .../kri/p6/ncrc/pairing/model/NewCenter.java | 26 + .../ncrc/pairing/model/NewPairingResult.java | 27 + .../pairing/service/PairingExcelService.java | 93 +- .../pairing/service/PairingNewService.java | 989 ++++++++++++++++++ .../service/PairingNormalizeService.java | 18 +- .../ncrc/pairing/service/PairingService.java | 11 + 14 files changed, 1421 insertions(+), 38 deletions(-) create mode 100644 src/main/java/com/kri/p6/ncrc/pairing/dto/excel/output/NewAdjacentRegionExcelDto.java create mode 100644 src/main/java/com/kri/p6/ncrc/pairing/dto/excel/output/NewCenterExcelDto.java create mode 100644 src/main/java/com/kri/p6/ncrc/pairing/dto/excel/output/NewFinalAssignmentExcelDto.java create mode 100644 src/main/java/com/kri/p6/ncrc/pairing/dto/excel/output/NewFinalAssignmentWithCenterExcelDto.java create mode 100644 src/main/java/com/kri/p6/ncrc/pairing/dto/excel/output/NewPairResultExcelDto.java create mode 100644 src/main/java/com/kri/p6/ncrc/pairing/dto/excel/output/NewPairScoreGuideExcelDto.java create mode 100644 src/main/java/com/kri/p6/ncrc/pairing/model/NewAdjacentRegion.java create mode 100644 src/main/java/com/kri/p6/ncrc/pairing/model/NewCenter.java create mode 100644 src/main/java/com/kri/p6/ncrc/pairing/model/NewPairingResult.java create mode 100644 src/main/java/com/kri/p6/ncrc/pairing/service/PairingNewService.java diff --git a/src/main/java/com/kri/p6/ncrc/pairing/controller/PairingController.java b/src/main/java/com/kri/p6/ncrc/pairing/controller/PairingController.java index f815848..fefa1f8 100644 --- a/src/main/java/com/kri/p6/ncrc/pairing/controller/PairingController.java +++ b/src/main/java/com/kri/p6/ncrc/pairing/controller/PairingController.java @@ -51,4 +51,26 @@ public class PairingController { } } } + + @PostMapping(value = "/run/new1", consumes = MediaType.MULTIPART_FORM_DATA_VALUE) + @Operation( + summary = "업로드된 파일로 위원과 센터를 매칭" + ) + public ResponseEntity 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); + } + } + } } diff --git a/src/main/java/com/kri/p6/ncrc/pairing/dto/excel/output/NewAdjacentRegionExcelDto.java b/src/main/java/com/kri/p6/ncrc/pairing/dto/excel/output/NewAdjacentRegionExcelDto.java new file mode 100644 index 0000000..d41a764 --- /dev/null +++ b/src/main/java/com/kri/p6/ncrc/pairing/dto/excel/output/NewAdjacentRegionExcelDto.java @@ -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; +} diff --git a/src/main/java/com/kri/p6/ncrc/pairing/dto/excel/output/NewCenterExcelDto.java b/src/main/java/com/kri/p6/ncrc/pairing/dto/excel/output/NewCenterExcelDto.java new file mode 100644 index 0000000..d402552 --- /dev/null +++ b/src/main/java/com/kri/p6/ncrc/pairing/dto/excel/output/NewCenterExcelDto.java @@ -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; +} diff --git a/src/main/java/com/kri/p6/ncrc/pairing/dto/excel/output/NewFinalAssignmentExcelDto.java b/src/main/java/com/kri/p6/ncrc/pairing/dto/excel/output/NewFinalAssignmentExcelDto.java new file mode 100644 index 0000000..4190754 --- /dev/null +++ b/src/main/java/com/kri/p6/ncrc/pairing/dto/excel/output/NewFinalAssignmentExcelDto.java @@ -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; +} diff --git a/src/main/java/com/kri/p6/ncrc/pairing/dto/excel/output/NewFinalAssignmentWithCenterExcelDto.java b/src/main/java/com/kri/p6/ncrc/pairing/dto/excel/output/NewFinalAssignmentWithCenterExcelDto.java new file mode 100644 index 0000000..c9e134c --- /dev/null +++ b/src/main/java/com/kri/p6/ncrc/pairing/dto/excel/output/NewFinalAssignmentWithCenterExcelDto.java @@ -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; +} diff --git a/src/main/java/com/kri/p6/ncrc/pairing/dto/excel/output/NewPairResultExcelDto.java b/src/main/java/com/kri/p6/ncrc/pairing/dto/excel/output/NewPairResultExcelDto.java new file mode 100644 index 0000000..5cd4c13 --- /dev/null +++ b/src/main/java/com/kri/p6/ncrc/pairing/dto/excel/output/NewPairResultExcelDto.java @@ -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; +} diff --git a/src/main/java/com/kri/p6/ncrc/pairing/dto/excel/output/NewPairScoreGuideExcelDto.java b/src/main/java/com/kri/p6/ncrc/pairing/dto/excel/output/NewPairScoreGuideExcelDto.java new file mode 100644 index 0000000..c127bb3 --- /dev/null +++ b/src/main/java/com/kri/p6/ncrc/pairing/dto/excel/output/NewPairScoreGuideExcelDto.java @@ -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; +} diff --git a/src/main/java/com/kri/p6/ncrc/pairing/model/NewAdjacentRegion.java b/src/main/java/com/kri/p6/ncrc/pairing/model/NewAdjacentRegion.java new file mode 100644 index 0000000..124b838 --- /dev/null +++ b/src/main/java/com/kri/p6/ncrc/pairing/model/NewAdjacentRegion.java @@ -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 centerIds; + private final Set centers; + private final LocalDate availableStartDate; + private final LocalDate availableEndDate; + private final Set unavailableDates; +} diff --git a/src/main/java/com/kri/p6/ncrc/pairing/model/NewCenter.java b/src/main/java/com/kri/p6/ncrc/pairing/model/NewCenter.java new file mode 100644 index 0000000..f32437a --- /dev/null +++ b/src/main/java/com/kri/p6/ncrc/pairing/model/NewCenter.java @@ -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 unavailableDates; + + private final String municipalityId; + private final LocalDate municipalityAvailableStartDate; + private final LocalDate municipalityAvailableEndDate; + private final Set municipalityUnavailableDates; + +} diff --git a/src/main/java/com/kri/p6/ncrc/pairing/model/NewPairingResult.java b/src/main/java/com/kri/p6/ncrc/pairing/model/NewPairingResult.java new file mode 100644 index 0000000..b19d95c --- /dev/null +++ b/src/main/java/com/kri/p6/ncrc/pairing/model/NewPairingResult.java @@ -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 pairs; + private final List finalAssignments; + private final List finalAssignmentsWithCenters; + private final List adjacentRegions; + private final List centers; + private final List summaries; + private final List scoreGuides; + private final List ruleChecks; +} diff --git a/src/main/java/com/kri/p6/ncrc/pairing/service/PairingExcelService.java b/src/main/java/com/kri/p6/ncrc/pairing/service/PairingExcelService.java index a467b7a..929e319 100644 --- a/src/main/java/com/kri/p6/ncrc/pairing/service/PairingExcelService.java +++ b/src/main/java/com/kri/p6/ncrc/pairing/service/PairingExcelService.java @@ -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.AssignmentResultExcelDto; 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.RuleViolationExcelDto; 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.ValidationErrorExcelDto; +import com.kri.p6.ncrc.pairing.model.NewPairingResult; import com.kri.p6.ncrc.pairing.model.PairingResult; import java.io.ByteArrayOutputStream; 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) { PairingResult result = PairingResult.builder() .assignments(List.of()) @@ -149,55 +185,42 @@ public class PairingExcelService { PairingProperties.Candidate candidate = pairingProperties.getCandidate(); PairingProperties.Solver solver = pairingProperties.getSolver(); return List.of( - setting("pairing.excel.header-row-index", - "엑셀 헤더로 사용할 행 인덱스", + setting("pairing.excel.header-row-index", "엑셀 헤더로 사용하는 행 인덱스", excel.getHeaderRowIndex()), - setting("pairing.code.region-code-length", - "지역코드 정규화 길이", code.getRegionCodeLength()), - setting("pairing.code.residence-code-length", - "거주지코드 정규화 길이", + setting("pairing.code.region-code-length", "지역코드 정규화 길이", + code.getRegionCodeLength()), + setting("pairing.code.residence-code-length", "거주지코드 정규화 길이", code.getResidenceCodeLength()), - setting("pairing.code.residence-match-prefix-length", - "거주지 일치 판단에 사용하는 앞자리 길이", + setting("pairing.code.residence-match-prefix-length", "거주지 일치 판단에 사용하는 앞자리 길이", code.getResidenceMatchPrefixLength()), - setting("pairing.code.any-region-code", - "희망지역 anywhere로 처리하는 코드", + setting("pairing.code.any-region-code", "희망지역 anywhere로 처리하는 코드", code.getAnyRegionCode()), - setting("pairing.rule.max-centers-per-pair-per-day", - "같은 페어가 하루에 방문할 수 있는 최대 센터 수", + setting("pairing.rule.max-centers-per-pair-per-day", "같은 페어가 하루에 방문할 수 있는 최대 센터 수", rule.getMaxCentersPerPairPerDay()), - setting("pairing.rule.max-counterparts-per-member", - "위원 1명당 허용되는 상대 위원 최대 수", + setting("pairing.rule.max-counterparts-per-member", "위원 1명당 허용하는 상대 위원 최대 수", rule.getMaxCounterpartsPerMember()), setting("pairing.rule.max-member-visit-average-ratio-percent", "위원별 방문 수 상한을 평균 대비 몇 %까지 허용할지", rule.getMaxMemberVisitAverageRatioPercent()), - setting("pairing.preference.anywhere-rank", - "선호지역 anywhere를 의미하는 순위", + setting("pairing.preference.anywhere-rank", "희망지역 anywhere를 의미하는 순위", preference.getAnywhereRank()), - setting("pairing.preference.ignored-rank", - "선호지역 고려하지 않음을 의미하는 순위", + setting("pairing.preference.ignored-rank", "희망지역 고려하지 않음을 의미하는 순위", preference.getIgnoredRank()), setting("pairing.preference.active-wildcard-fallback-enabled", "희망지역 고려하지 않음을 wildcard로 적극 사용할지", preference.isActiveWildcardFallbackEnabled()), - setting("pairing.preference.wildcard-fallback-score-bonus", - "wildcard 후보에 추가할 점수", + setting("pairing.preference.wildcard-fallback-score-bonus", "wildcard 후보에 추가하는 점수", preference.getWildcardFallbackScoreBonus()), - setting("pairing.objective.assignment-weight", - "센터 하나를 더 배정하는 것에 부여하는 기본 점수", + setting("pairing.objective.assignment-weight", "센터 하나를 배정하는 것에 부여하는 기본 점수", objective.getAssignmentWeight()), - setting("pairing.objective.preference-base-weight", - "희망지역 매칭 품질에 부여하는 기본 점수", + setting("pairing.objective.preference-base-weight", "희망지역 매칭 1건마다 부여하는 기본 점수", objective.getPreferenceBaseWeight()), - setting("pairing.objective.preference-rank-penalty", - "희망순위가 낮아질 때 감점하는 점수", + setting("pairing.objective.preference-rank-penalty", "희망 순위가 낮아질 때 감점하는 점수", objective.getPreferenceRankPenalty()), - setting("pairing.objective.residence-match-weight", - "거주지 유사도 점수에 곱하는 가중치", + setting("pairing.objective.residence-match-weight", "거주지 유사도 점수에 곱하는 가중치", objective.getResidenceMatchWeight()), setting("pairing.objective.member-balance-weight", - "방문 수가 많은 위원을 더 선택하지 않도록 감점하는 가중치", + "방문 수가 많은 위원이 계속 선택되지 않도록 감점하는 가중치", objective.getMemberBalanceWeight()), setting("pairing.candidate.max-pair-candidates-per-member", "위원별 페어 후보 축소 상한, 0이면 무제한", @@ -205,20 +228,16 @@ public class PairingExcelService { setting("pairing.candidate.max-dispatch-regions-per-pair", "페어별 파견 권역 후보 축소 상한, 0이면 무제한", candidate.getMaxDispatchRegionsPerPair()), - setting("pairing.candidate.max-assignments-per-center", - "센터별 배정 후보 축소 상한", + setting("pairing.candidate.max-assignments-per-center", "센터별 배정 후보 축소 상한", candidate.getMaxAssignmentsPerCenter()), - setting("pairing.candidate.max-assignments-per-member", - "위원별 배정 후보 축소 상한", + setting("pairing.candidate.max-assignments-per-member", "위원별 배정 후보 축소 상한", candidate.getMaxAssignmentsPerMember()), setting("pairing.candidate.max-dates-per-assignment-candidate", "하나의 페어-센터 조합에서 확장할 날짜 후보 상한", candidate.getMaxDatesPerAssignmentCandidate()), - setting("pairing.solver.max-time-seconds", - "CP-SAT 사용 시 허용할 최대 탐색 시간", + setting("pairing.solver.max-time-seconds", "CP-SAT 사용 시 허용할 최대 탐색 시간", solver.getMaxTimeSeconds()), - setting("pairing.solver.num-search-workers", - "CP-SAT 사용 시 사용할 worker 수", + setting("pairing.solver.num-search-workers", "CP-SAT 사용 시 사용할 worker 수", solver.getNumSearchWorkers()) ); } diff --git a/src/main/java/com/kri/p6/ncrc/pairing/service/PairingNewService.java b/src/main/java/com/kri/p6/ncrc/pairing/service/PairingNewService.java new file mode 100644 index 0000000..c5d7df2 --- /dev/null +++ b/src/main/java/com/kri/p6/ncrc/pairing/service/PairingNewService.java @@ -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 newCenters = createNewCenters(data); + List newAdjacentRegions = createNewAdjacentRegions(data, newCenters); + List 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 createNewCenters(PairingData data) { + Map 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 municipalityMap) { + Municipality municipality = municipalityMap.get(center.getMunicipalityId()); + if (municipality == null) { + throw BusinessException.badRequest("PAIRING_BROKEN_MUNICIPALITY_REFERENCE", + "센터가 존재하지 않는 지자체를 참조합니다. centerId=" + center.getId() + + ", municipalityId=" + center.getMunicipalityId()); + } + + Set 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 createNewAdjacentRegions(PairingData data, + List newCenters) { + Map> dispatchRegionsByAdjacentClassification = data.getCenterAdjacentRegions() + .stream() + .collect(Collectors.groupingBy(CenterAdjacentRegion::getAdjacentRegionClassification, + Collectors.mapping(CenterAdjacentRegion::getDispatchRegion, + Collectors.toCollection(LinkedHashSet::new)))); + Map> centersByAdjacentClassification = newCenters.stream() + .collect(Collectors.groupingBy(NewCenter::getAdjacentRegionClassification, + LinkedHashMap::new, Collectors.toList())); + + List result = new ArrayList<>(); + centersByAdjacentClassification.forEach((adjacentClassification, centers) -> { + Set 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 centers, Set commonUnavailableDates) { + LocalDate start = centers.stream().map(NewCenter::getAvailableStartDate).max(LocalDate::compareTo) + .orElseThrow(); + LocalDate end = centers.stream().map(NewCenter::getAvailableEndDate).min(LocalDate::compareTo) + .orElseThrow(); + Set unavailableDates = centers.stream() + .flatMap(center -> center.getUnavailableDates().stream()) + .collect(Collectors.toCollection(LinkedHashSet::new)); + unavailableDates.addAll(commonUnavailableDates); + Set centerSet = centers.stream() + .collect(Collectors.toCollection(LinkedHashSet::new)); + Set 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 matchMembers(PairingData data, + List newAdjacentRegions) { + List fieldMembers = data.getMembers().stream() + .filter(member -> member.getRole() == MemberRole.FIELD) + .sorted(Comparator.comparing(Member::getId)) + .toList(); + List 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 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 matches = matcher.match(fieldMembers.size()); + if (matches.size() != fieldMembers.size()) { + throw BusinessException.badRequest("PAIRING_NEW_MEMBER_MATCH_FAILED", + "신규+신규 금지 조건을 만족하는 1:1 위원 매칭을 만들 수 없습니다."); + } + + Map 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 createPairCandidates(List fieldMembers, + List externalMembers, PairingData data, List newAdjacentRegions) { + List 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 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 sortSelectedPairsByAvailability(List pairs, + List 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 newAdjacentRegions, PairingData data) { + int regionCount = 0; + Set 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 dates = availableDatesForRegion(fieldMember, externalMember, region); + if (!dates.isEmpty()) { + regionCount++; + availableDates.addAll(dates); + } + } + return new AvailableRegionStats(regionCount, availableDates.size()); + } + + private Set 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 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 centerIds) { + return centerIds.stream().anyMatch(centerId -> fieldMember.getHistoryCenterIds().contains(centerId) + || externalMember.getHistoryCenterIds().contains(centerId)); + } + + private boolean isPreferenceAllowed(Member fieldMember, Member externalMember, + String dispatchRegion, List rules) { + return findPreferenceMatchPriority(fieldMember, externalMember, dispatchRegion, rules) != null; + } + + private Integer findPreferenceMatchPriority(Member fieldMember, Member externalMember, + String dispatchRegion, List 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 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 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 fieldHistory = fieldMember.getHistoryCenterIds(); + Set 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 toPairRows(List pairs) { + List 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 pairs, + List newAdjacentRegions, PairingData data) { + Map pairNoMap = new LinkedHashMap<>(); + for (int i = 0; i < pairs.size(); i++) { + pairNoMap.put(pairs.get(i), String.valueOf(i + 1)); + } + + Set assignedAdjacentClassifications = new LinkedHashSet<>(); + Map> usedDatesByPair = new LinkedHashMap<>(); + pairs.forEach(pair -> usedDatesByPair.put(pair, new LinkedHashSet<>())); + + List rows = new ArrayList<>(); + List centerRows = new ArrayList<>(); + List 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 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 newAdjacentRegions, PairingData data, + Set assignedAdjacentClassifications, Set 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 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 toAdjacentRows(List 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 toCenterRows(List 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 createSummaries(PairingData data, + List selectedPairs, List newCenters, + List 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 createRuleChecks(PairingData data, + List selectedPairs, NewAssignmentResult assignmentResult) { + Set fieldIds = selectedPairs.stream().map(pair -> pair.fieldMember().getId()) + .collect(Collectors.toCollection(LinkedHashSet::new)); + Set 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 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 createAssignmentRuleChecks( + NewAssignmentResult assignmentResult) { + List audits = assignmentResult.audits(); + List checks = new ArrayList<>(); + + List duplicatePairDate = duplicateKeys(audits.stream() + .map(audit -> audit.pairNo() + "|" + audit.choice().date()) + .toList()); + checks.add(new RuleViolationExcelDto("페어별 하루 하나의 인접지역", + passFail(duplicatePairDate.isEmpty()), + duplicatePairDate.isEmpty() ? "위반 없음" : "중복=" + limitDetail(duplicatePairDate))); + + List duplicateAdjacentClassifications = duplicateKeys(audits.stream() + .map(audit -> audit.choice().region().getAdjacentRegionClassification()) + .toList()); + checks.add(new RuleViolationExcelDto("인접지역 분류 중복 배정 금지", + passFail(duplicateAdjacentClassifications.isEmpty()), + duplicateAdjacentClassifications.isEmpty() ? "위반 없음" + : "중복=" + limitDetail(duplicateAdjacentClassifications))); + + List unavailableDateViolations = audits.stream() + .filter(audit -> !isAssignmentDateAllowed(audit)) + .map(this::assignmentDetail) + .toList(); + checks.add(new RuleViolationExcelDto("가능 날짜/불가일 준수", + passFail(unavailableDateViolations.isEmpty()), + unavailableDateViolations.isEmpty() ? "위반 없음" + : "위반=" + limitDetail(unavailableDateViolations))); + + List 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 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 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 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 duplicateKeys(List keys) { + Set seen = new HashSet<>(); + Set 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 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 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 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 preferenceSet(Member member) { + return member.getPreferenceRegions().stream() + .filter(value -> value != null && !value.isBlank()) + .collect(Collectors.toCollection(LinkedHashSet::new)); + } + + private int overlapCount(Set left, Set right) { + Set 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 values) { + return values.stream().sorted().collect(Collectors.joining(",")); + } + + private String joinDates(Set 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 assignments, + List assignmentsWithCenters, + List audits) { + } + + private static class MinCostMatcher { + + private final int source; + private final int sink; + private final int leftSize; + private final int rightSize; + private final List> 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 match(int targetFlow) { + int flow = 0; + while (flow < targetFlow && augment()) { + flow++; + } + Map 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 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; + } + } +} diff --git a/src/main/java/com/kri/p6/ncrc/pairing/service/PairingNormalizeService.java b/src/main/java/com/kri/p6/ncrc/pairing/service/PairingNormalizeService.java index 2f687ae..0bed16b 100644 --- a/src/main/java/com/kri/p6/ncrc/pairing/service/PairingNormalizeService.java +++ b/src/main/java/com/kri/p6/ncrc/pairing/service/PairingNormalizeService.java @@ -52,6 +52,8 @@ public class PairingNormalizeService { .toList()).commonUnavailableDates(Set.of()).build(); } + + private Member toMember(MemberExcelDto row) { return Member.builder().id(required(row.getId(), "위원 id")) .gender(parseGender(row.getGender())) @@ -61,7 +63,7 @@ public class PairingNormalizeService { .availableEndDate(parseDate(row.getAvailableEndDate(), "위원 진행 종료일")) .unavailableDates(parseDateSet(row.getUnavailableDates(), "위원 진행 불가 일자")) .activityRegion(normalizeCsvCodes(row.getActivityRegion(), regionCodeLength(), "위원 활동지역")) - .historyCenterIds(parseCsv(row.getHistoryCenters())).residenceCode( + .historyCenterIds(parseHistoryCenterIds(row.getHistoryCenters())).residenceCode( normalizeOptionalCode(row.getResidenceCode(), residenceCodeLength(), "위원 거주지")) .preferenceRegions(normalizePreferenceRegions(row)).build(); } @@ -208,6 +210,20 @@ public class PairingNormalizeService { .collect(Collectors.toCollection(LinkedHashSet::new))); } + private Set 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) { String cleaned = required(value, fieldName); diff --git a/src/main/java/com/kri/p6/ncrc/pairing/service/PairingService.java b/src/main/java/com/kri/p6/ncrc/pairing/service/PairingService.java index 32f9ec4..ab0c072 100644 --- a/src/main/java/com/kri/p6/ncrc/pairing/service/PairingService.java +++ b/src/main/java/com/kri/p6/ncrc/pairing/service/PairingService.java @@ -1,6 +1,7 @@ package com.kri.p6.ncrc.pairing.service; 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.PairingResult; import lombok.RequiredArgsConstructor; @@ -16,6 +17,7 @@ public class PairingService { private final PairingHolidayService pairingHolidayService; private final PairingValidationService pairingValidationService; private final PairingScheduleService pairingScheduleService; + private final PairingNewService pairingNewService; public byte[] pairingMemberByCenter(MultipartFile file) { PairingWorkbookData workbookData = pairingExcelService.read(file); @@ -25,4 +27,13 @@ public class PairingService { PairingResult result = pairingScheduleService.schedule(pairingData); 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); + } }