Compare commits
1 Commits
feature-sp
...
feature-04
| Author | SHA1 | Date | |
|---|---|---|---|
| 993c766d6b |
@@ -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);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -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;
|
||||
}
|
||||
@@ -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;
|
||||
}
|
||||
@@ -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;
|
||||
}
|
||||
@@ -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;
|
||||
}
|
||||
@@ -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;
|
||||
}
|
||||
@@ -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;
|
||||
}
|
||||
@@ -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;
|
||||
}
|
||||
26
src/main/java/com/kri/p6/ncrc/pairing/model/NewCenter.java
Normal file
26
src/main/java/com/kri/p6/ncrc/pairing/model/NewCenter.java
Normal 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;
|
||||
|
||||
}
|
||||
@@ -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;
|
||||
}
|
||||
@@ -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())
|
||||
);
|
||||
}
|
||||
|
||||
@@ -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;
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -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<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) {
|
||||
String cleaned = required(value, fieldName);
|
||||
|
||||
|
||||
@@ -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);
|
||||
}
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user