6 Commits

43 changed files with 451 additions and 4285 deletions

459
README.md
View File

@@ -1,201 +1,374 @@
# ncrc-pairing
엑셀 파일을 입력받아 위원 조편성 및 센터 방문 일정을 생성하는 Spring Boot API입니다.
엑셀 파일을 입력받아 위원 1:1 페어를 만들고, 인접지역분류 단위의 방문 배정표를 생성하는 Spring Boot API입니다.
현재 배정 엔진은 Greedy 중심으로 동작합니다. 모든 위원을 먼저 조편성하고, 이후 가능한 많은 센터를 일정표에 배정합니다. OR-Tools CP-SAT 코드는 유지되어 있지만 전체 배정의 중심 경로는 `PairingScheduleService`입니다.
## 개요
## 실행 흐름
처리는 크게 2단계입니다.
1. 현장위원 100명과 외부위원 100명을 1:1 페어로 매칭
2. 생성된 페어를 사용해 인접지역분류 단위로 최종 배정
배정 결과는 엑셀로 반환합니다.
## 실행 환경
- Java 17
- Spring Boot 3.5.x
- Gradle
기본 포트:
```yaml
server:
port: 6111
```
## API
엔드포인트:
```text
POST /api/v1/pairing/run/new
Content-Type: multipart/form-data
file=<xlsx 파일>
```
정상 처리 시 결과 엑셀을 반환합니다.
검증 실패 시에도 공통 `BusinessException` 내용을 담은 오류 엑셀을 반환합니다.
## 전체 처리 흐름
현재 실제 구동 순서는 아래와 같습니다.
1. `PairingController`
- `/api/v1/pairing/run`으로 엑셀 파일을 업로드받습니다.
- 결과 엑셀 파일을 반환합니다.
2. `PairingService#pairingMemberByCenterNew`
3. `PairingExcelService#read`
4. `PairingNormalizeService#normalize`
5. `PairingHolidayService#applyHolidayUnavailableDates`
6. `PairingValidationService#validate`
7. `PairingNewService#pair`
8. `PairingExcelService#writeNew`
2. `PairingService`
- 전체 유스케이스를 순서대로 호출합니다.
- `엑셀 읽기 -> 정규화 -> 공휴일/주말 반영 -> 검증 -> 후보 생성 -> 조편성/스케줄링 -> 결과 엑셀 생성`
## 입력 엑셀 시트
3. `PairingExcelService`
- 입력 엑셀 시트를 DTO로 읽습니다.
- 결과 시트는 배정결과, 미배정센터, 미사용위원, 처리요약, AB페어목록, 후보요약, 검증오류, 규칙위반검사를 포함합니다.
현재 필수 시트는 5개입니다.
4. `PairingNormalizeService`
- 엑셀 문자열을 내부 모델로 변환합니다.
- 날짜, CSV, 성별, 경력, 현장/외부 구분, 지역코드, 희망지역을 정리합니다.
1. `위원정보`
2. `지자체 정보`
3. `센터정보`
4. `센터 인접지역표`
5. `희망지역 매칭표`
5. `PairingHolidayService`
- `DatagoHolidayCache`를 통해 공휴일을 조회합니다.
- 토/일은 `DatagoHolidayCache#getWeekend`에서 생성해 공통 불가능일로 합칩니다.
- 공휴일 API 조회 실패 시 구동되면 안 된다는 정책에 따라 실패 응답을 냅니다.
더 이상 사용하지 않는 시트:
6. `PairingValidationService`
- 필수 데이터, 날짜 범위, 지자체 참조, 희망지역 매칭표를 검증합니다.
- 검증 실패는 `BusinessException.badRequest(code, message)`를 사용합니다.
- `위원 지역코드표`
7. `PairingCandidateService`
- 가능한 조, 파견권역, 센터/날짜 후보를 생성합니다.
- 상피제, 여성전용센터, 기방문센터, 날짜 불가, 공휴일/주말 등 명확한 Hard Rule을 후보 단계에서 제거합니다.
현재 코드에서는 읽지 않습니다.
8. `PairingMemberPairService`
- 모든 위원이 최소 1개 조에 포함되도록 조편성을 먼저 수행합니다.
- 센터/날짜 후보가 많은 조를 우선 선택하고, 위원당 상대 파트너 수 상한을 지킵니다.
## 핵심 모델
9. `PairingScheduleService`
- 확정된 조를 기준으로 센터 일정을 Greedy 방식으로 배정합니다.
- 이후 repair pass를 통해 미배정 센터 감소와 방문 수 균형을 보정합니다.
### Member
10. `PairingSolverService`
- 결과 DTO 생성과 규칙 위반 검사를 담당합니다.
- CP-SAT 기반 선택 로직도 유지하고 있으나 현재 주 경로는 Greedy 스케줄링입니다.
위원 기본 정보입니다.
## 현재 Hard Rule
- 성별
- 경력
- 역할(현장 / 외부)
- 가능 시작일 / 종료일
- 불가일
- 활동지역
- 2023년 진행 센터 이력
- 거주지
- 선호지역 1~4
| 규칙 | 구현 위치 |
| --- | --- |
| 모든 위원은 최소 1개 조에 포함 | `PairingMemberPairService`, `PairingSolverService#checkAllMembersUsed` |
| 현장위원 + 외부위원 조 구성 | `PairingCandidateService#createPairCandidates` |
| 위원 활동 가능 기간 겹침 | `PairingCandidateService#hasDateOverlap` |
| 상피제 | `PairingCandidateService#isConflictRegion` |
| 여성전용센터는 여성 2명 조만 허용 | `PairingCandidateService#findCenterHardRuleReasons` |
| 기방문센터 제외 | `PairingCandidateService#findCenterHardRuleReasons` |
| 위원/지자체/센터 불가능일 제외 | `PairingCandidateService#findAssignableDates`, `isAvailableOn` |
| 공휴일/토/일 제외 | `PairingHolidayService`, `DatagoHolidayCache`, `PairingCandidateService#commonUnavailableDates` |
| 센터 1개는 최대 1번 배정 | `PairingScheduleService#isFeasible`, `PairingSolverService#addCenterAssignedAtMostOnce` |
| 한 위원은 같은 날짜에 다른 조와 중복 활동 불가 | `PairingScheduleService#isFeasible`, `GreedyState#isMemberBusyWithOtherPair` |
| 같은 조는 하루 최대 N개 센터 방문 | `application.yaml`, `PairingScheduleService#isFeasible` |
| 같은 조/같은 날짜에는 하나의 인접지역 분류만 방문 | `PairingScheduleService#isFeasible`, `GreedyState#isAllowedAdjacentClassification` |
| 위원당 상대 파트너 수 최대 N명 | `application.yaml`, `PairingMemberPairService`, `PairingScheduleService#isFeasible` |
| 위원별 최대 방문 수 상한 | `application.yaml`, `PairingScheduleService#maxMemberVisitCount` |
### NewCenter
## 현재 Soft Rule 우선순위
센터와 지자체 정보를 합쳐 만든 센터 단위 모델입니다.
1. 배정 센터 수 최대화
2. 위원별 방문 수 균형
3. 희망지역 매칭표 우선순위
4. 희망지역 99 wildcard fallback
- `availableStartDate`: 센터 시작일과 지자체 시작일 중 더 늦은 값
- `availableEndDate`: 센터 종료일과 지자체 종료일 중 더 이른 값
- `unavailableDates`: 센터 불가일 + 지자체 불가일
### NewAdjacentRegion
실제 배정의 기본 단위입니다.
- 기준: `dispatchRegion + adjacentRegionClassification`
- 포함 센터: 같은 `adjacentRegionClassification`을 가진 센터 묶음
- `womenOnly`: 포함 센터 중 하나라도 여성전용이면 `true`
- `availableStartDate`: 포함 센터들의 시작일 중 가장 늦은 값
- `availableEndDate`: 포함 센터들의 종료일 중 가장 이른 값
- `unavailableDates`: 포함 센터들의 불가일 합집합 + 공통 제외일(토/일/공휴일)
주의:
- `센터 인접지역표`의 `dispatchRegion` 셀에는 `12,15,16`처럼 여러 코드가 들어올 수 있습니다.
- 현재는 정규화 단계에서 이 값을 행확장합니다.
- 예: `dispatchRegion=12,15,16`, `adjacentRegionClassification=A001`
- `(12, A001)`
- `(15, A001)`
- `(16, A001)`
## 페어 생성 규칙
페어 생성은 `PairingNewService`에서 처리합니다.
### 하드룰
1. 현장위원 수와 외부위원 수는 같아야 함
2. 모든 현장위원과 모든 외부위원이 정확히 1:1로 사용되어야 함
3. `신규 + 신규` 페어는 금지
### 페어 점수 기준
현재 페어 점수는 아래 항목으로 계산합니다.
1. 활동지역 겹침 수
2. 공통 가능일 수
3. 선호지역 겹침 수
4. 2023년 진행 센터 이력 점수
5. 거주지 유사도
6. 같은 조/같은 날짜/같은 인접지역 분류 재사용
6. 배정 가능한 인접지역 수
관련 설정:
현재 코드 기준:
```java
private static final boolean USE_AVAILABLE_ADJACENT_REGION_IN_PAIR_SCORE = true;
```
즉, `배정 가능한 인접지역 수가 많은 페어`가 페어 생성 단계의 점수에도 반영됩니다.
추가로 생성된 페어는 아래 기준으로 다시 정렬됩니다.
1. 배정 가능 인접지역 수 오름차순
2. 중복제거 가능 날짜 수 오름차순
3. 페어 점수 내림차순
4. 현장위원 id
5. 외부위원 id
이 정렬 순서는 이후 최종 배정 순서에도 영향을 줍니다.
## 최종 배정 규칙
최종 배정은 `PairingNewService#assignAdjacentRegions`에서 처리합니다.
기본 개념은 단순 그리디입니다.
1. 정렬된 페어를 앞에서부터 순회
2. 각 페어가 갈 수 있는 인접지역분류 후보를 찾음
3. `희망지역 매칭표` 순위가 가장 높은 후보부터 선택
4. 배정 직후 그 페어의 해당 날짜를 사용 처리
5. 이미 배정된 인접지역분류는 다시 배정하지 않음
6. 더 이상 배정할 수 없을 때까지 반복
### 최종 배정 하드룰
현재 코드에서 적용되는 하드룰은 아래와 같습니다.
1. 같은 페어는 같은 날짜에 하나의 인접지역분류만 방문 가능
2. 같은 인접지역분류는 한 번만 배정 가능
3. 위원 가능일 / 지자체 가능일 / 센터 가능일 범위를 만족해야 함
4. 위원 불가일 / 센터 불가일 / 지자체 불가일 / 토요일 / 일요일 / 공휴일은 제외
5. 상피제 적용
- 현장위원 또는 외부위원의 활동지역에 해당 `dispatchRegion`이 있으면 배정 불가
6. 여성전용 인접지역은 여성 + 여성 페어만 가능
7. 2023년 진행 센터 이력이 포함된 인접지역은 배정 불가
8. 희망지역 매칭표 조합에 맞는 경우만 후보 인정
## 규칙검사 시트
결과 엑셀의 `규칙검사` 시트에는 현재 아래 항목을 검사합니다.
1. 현장위원 전체 사용
2. 외부위원 전체 사용
3. 1:1 페어 수
4. 신규+신규 페어 금지
5. 페어별 하루 하나의 인접지역
6. 인접지역 분류 중복 배정 금지
7. 가능 날짜/불가일 준수
8. 상피제 준수
9. 여성위원만 조건 준수
10. 2023년 진행 센터 재배정 제외
11. 희망지역 매칭표 조합 준수
위반 시 `FAIL`과 상세 내역을 기록합니다.
## 결과 엑셀 시트
현재 결과 시트 순서는 아래와 같습니다.
1. `페어결과`
2. `최종 배정`
3. `최종 배정 with 센터`
4. `인접지역목록`
5. `센터목록`
6. `페어후보요약`
7. `페어점수계산`
8. `규칙검사`
### 1. 페어결과
생성된 1:1 페어 목록입니다.
포함 정보:
- 페어번호
- 현장위원 / 외부위원 id
- 성별 / 경력 / 활동지역 / 거주지
- 2023년 진행 센터
- 배정 가능 인접지역 수
- 중복제거 가능 날짜 수
- 총점 및 각 점수 항목
### 2. 최종 배정
인접지역분류 단위 배정 결과입니다.
포함 정보:
- 일자
- 페어번호
- 현장위원 id
- 외부위원 id
- 희망지역 매칭표 상의 순위
- 인접지역 분류
### 3. 최종 배정 with 센터
최종 배정을 센터 단위로 펼친 시트입니다.
포함 정보:
- 센터 id
- 지자체 id
- 인접지역 분류
- 여성위원만
- 센터+지자체 시작일
- 센터+지자체 종료일
- 센터+지자체 불가일
- 일자
- 페어번호
- 현장위원 id
- 외부위원 id
- 희망지역 매칭표 상의 순위
- 인접지역 분류
## 설정값
현재 사용 중인 설정은 아래뿐입니다.
```yaml
pairing:
rule:
max-centers-per-pair-per-day: 3
max-counterparts-per-member: 3
max-member-visit-average-ratio-percent: 130
excel:
header-row-index: 1
code:
region-code-length: 2
residence-code-length: 5
any-region-code: "00"
preference:
anywhere-rank: 0
ignored-rank: 99
active-wildcard-fallback-enabled: true
wildcard-fallback-score-bonus: 25_000
objective:
assignment-weight: 1_000_000
member-balance-weight: 20_000
preference-base-weight: 30_000
preference-rank-penalty: 1_000
residence-match-weight: 10_000
candidate:
max-pair-candidates-per-member: 0
max-dispatch-regions-per-pair: 0
max-assignments-per-center: 1_000
max-assignments-per-member: 3_000
max-dates-per-assignment-candidate: 80
```
## Greedy 스케줄링 구조
설명:
핵심 파일: `PairingScheduleService`
- `header-row-index`
- 엑셀 헤더 행 번호
- `region-code-length`
- 활동지역 / 선호지역 / 파견권역 코드 정규화 길이
- `residence-code-length`
- 거주지 코드 정규화 길이
- `any-region-code`
- 선호지역의 `어디든 가능` 코드
- `anywhere-rank`
- `00`이 희망지역 매칭표에서 의미하는 순위
- `ignored-rank`
- 선호지역을 고려하지 않음을 의미하는 wildcard 순위
1. `pairingCandidateService.generate`
- 가능한 후보를 생성합니다.
## 공휴일 / 주말 처리
2. `pairingMemberPairService.select`
- 모든 위원을 먼저 조편성합니다.
`PairingHolidayService`에서 공통 제외일을 만듭니다.
3. `assignRemainingCenters`
- 후보가 적은 센터부터 선택합니다.
- 해당 센터에 가능한 후보 중 점수가 가장 높은 후보를 배정합니다.
데이터 소스:
4. `repairUnassignedCenters`
- 미배정 센터를 넣기 위해 기존 충돌 배정을 최대 2개까지 제거하고 다시 채웁니다.
- `DatagoHolidayCache`
- `DatagoExtentionApiClient`
5. `repairLowVisitMembers`
- 방문 수가 적은 위원이 남은 센터에 들어갈 수 있는지 우선 탐색합니다.
포함 범위:
6. `repairByDonorSwap`
- 방문 수가 많은 위원의 배정을 저방문 위원이 포함된 후보로 넘길 수 있는지 봅니다.
- 공휴일
- 토요일
- 일요일
7. `repairWildcardFallbackCenters`
- 99 wildcard 후보를 남은 센터에 우선 적용해 봅니다.
이 값들은 `PairingData.commonUnavailableDates`로 들어가고, 이후 `NewAdjacentRegion.unavailableDates`에 합쳐집니다.
## OR-Tools CP-SAT 설명
## 주요 클래스
사용 라이브러리:
### Controller
```gradle
implementation("com.google.ortools:ortools-java:9.15.6755")
```
- [PairingController.java](D:/___Project/260414_아동권리보장원/DEV/ncrc-pairing/src/main/java/com/kri/p6/ncrc/pairing/controller/PairingController.java)
CP-SAT는 "조건을 모두 지키면서 가장 점수가 높은 조합을 찾는 도구"입니다.
### Service
예를 들어 `A조가 2026-05-01에 100번 센터를 방문한다`라는 후보가 있으면, CP-SAT 안에서는 이 후보가 0/1 변수 하나가 됩니다.
- [PairingService.java](D:/___Project/260414_아동권리보장원/DEV/ncrc-pairing/src/main/java/com/kri/p6/ncrc/pairing/service/PairingService.java)
- [PairingExcelService.java](D:/___Project/260414_아동권리보장원/DEV/ncrc-pairing/src/main/java/com/kri/p6/ncrc/pairing/service/PairingExcelService.java)
- [PairingNormalizeService.java](D:/___Project/260414_아동권리보장원/DEV/ncrc-pairing/src/main/java/com/kri/p6/ncrc/pairing/service/PairingNormalizeService.java)
- [PairingHolidayService.java](D:/___Project/260414_아동권리보장원/DEV/ncrc-pairing/src/main/java/com/kri/p6/ncrc/pairing/service/PairingHolidayService.java)
- [PairingValidationService.java](D:/___Project/260414_아동권리보장원/DEV/ncrc-pairing/src/main/java/com/kri/p6/ncrc/pairing/service/PairingValidationService.java)
- [PairingNewService.java](D:/___Project/260414_아동권리보장원/DEV/ncrc-pairing/src/main/java/com/kri/p6/ncrc/pairing/service/PairingNewService.java)
```text
1 = 이 후보를 선택한다
0 = 이 후보를 선택하지 않는다
```
### Config
현재 프로젝트에서는 전체 후보가 매우 커질 수 있어 CP-SAT만으로는 시간이 오래 걸릴 수 있습니다. 그래서 주 배정은 Greedy가 담당하고, CP-SAT 코드는 향후 부분 최적화나 비교 실험을 위해 유지합니다.
- [PairingProperties.java](D:/___Project/260414_아동권리보장원/DEV/ncrc-pairing/src/main/java/com/kri/p6/ncrc/pairing/config/PairingProperties.java)
- [application.yaml](D:/___Project/260414_아동권리보장원/DEV/ncrc-pairing/src/main/resources/application.yaml)
CP-SAT 관련 수정 위치:
| 변경 내용 | 수정 위치 |
| --- | --- |
| 후보 0/1 변수 | `PairingSolverService#createAssignmentVars` |
| 센터 중복 금지 | `PairingSolverService#addCenterAssignedAtMostOnce` |
| 하루 방문 센터 수 | `PairingSolverService#addPairDailyCapacity` |
| 같은 날짜 위원 중복 금지 | `PairingSolverService#addMemberDailyOnePair` |
| 인접지역 분류 제한 | `PairingSolverService#addPairDailyOneAdjacentClassification` |
| 상대 파트너 수 제한 | `PairingSolverService#addCumulativeBuddyLimit` |
| 점수 조정 | `PairingSolverService#createObjective` |
## 규칙 변경 시 수정 위치
| 업무 변경 | 수정 위치 |
| --- | --- |
| 엑셀 시트명 변경 | `PairingConstant` |
| 엑셀 컬럼명 변경 | `dto.excel.input`, `dto.excel.output`의 `@ExcelColumn` |
| 입력 정규화 변경 | `PairingNormalizeService` |
| 공휴일/주말 정책 변경 | `PairingHolidayService`, `DatagoHolidayCache` |
| 상피제 변경 | `PairingCandidateService#isConflictRegion`, `hasActivityRegion` |
| 여성전용센터 정책 변경 | `PairingCandidateService#findCenterHardRuleReasons` |
| 기방문센터 제외 정책 변경 | `PairingCandidateService#findCenterHardRuleReasons` |
| 희망지역 00/99 해석 변경 | `PairingCandidateService#findPreferenceRank`, `findPreferenceMatchRule`, `matchesPreferenceRank` |
| wildcard 적극 사용 롤백 | `application.yaml`의 `active-wildcard-fallback-enabled: false` |
| 위원당 상대 파트너 수 변경 | `application.yaml`의 `max-counterparts-per-member` |
| 하루 센터 방문 수 변경 | `application.yaml`의 `max-centers-per-pair-per-day` |
| 위원 최대 방문 상한 변경 | `application.yaml`의 `max-member-visit-average-ratio-percent` |
| 배정 점수 튜닝 | `application.yaml`의 `objective.*` |
| repair 전략 변경 | `PairingScheduleService`의 `repair...` 메서드 |
## 테스트
## 빌드 / 테스트
컴파일:
```powershell
.\gradlew.bat compileJava
.\gradlew.bat compileJava compileTestJava
```
전체 테스트:
테스트:
```powershell
.\gradlew.bat test
```
샘플 엑셀 기반 테스트:
현재 테스트는 최소 Spring Boot 컨텍스트 테스트만 남아 있습니다.
```powershell
.\gradlew.bat test --tests com.kri.p6.ncrc.pairing.service.PairingServiceTest
```
## 유지보수 포인트
결과 파일은 테스트 실행 시 `build/pairing-result*.xlsx`로 생성됩니다.
### 1. 새 시트가 추가될 때
- 입력 시트라면 `PairingExcelService#read`
- 정규화가 필요하면 `PairingNormalizeService`
- 검증이 필요하면 `PairingValidationService`
### 2. 최종 배정 규칙이 바뀔 때
- 대부분 [PairingNewService.java](D:/___Project/260414_아동권리보장원/DEV/ncrc-pairing/src/main/java/com/kri/p6/ncrc/pairing/service/PairingNewService.java) 수정
- 페어 생성 규칙 변경
- `matchMembers`
- `createPairCandidates`
- `scorePair`
- 최종 배정 규칙 변경
- `assignAdjacentRegions`
- `findBestAssignmentChoice`
- `firstAvailableDateForRegion`
### 3. 규칙검사 기준이 바뀔 때
- `createRuleChecks`
- `createAssignmentRuleChecks`
### 4. dispatchRegion 복수 입력 형식이 바뀔 때
- 현재는 `PairingNormalizeService#toCenterAdjacentRegions`에서 행확장
- 이 형식이 바뀌면 여기부터 수정하는 것이 맞습니다
## 비고
- 현재 결과는 “최대한 단순한 방향의 그리디 배정”을 목표로 합니다.

View File

@@ -50,19 +50,14 @@ dependencies {
implementation 'org.springframework.boot:spring-boot-starter-web'
implementation 'org.springframework.boot:spring-boot-starter-security'
implementation 'org.springframework.boot:spring-boot-starter-validation'
implementation "org.springdoc:springdoc-openapi-starter-webmvc-ui:2.8.11"
//ortools-java CP-SAT Solver를 사용하기 위함
implementation "com.google.ortools:ortools-java:9.15.6755"
compileOnly 'org.projectlombok:lombok'
annotationProcessor 'org.projectlombok:lombok'
developmentOnly 'org.springframework.boot:spring-boot-devtools'
testImplementation 'org.springframework.boot:spring-boot-starter-test'
testImplementation 'org.springframework.security:spring-security-test'
testRuntimeOnly 'org.junit.platform:junit-platform-launcher'
}

View File

@@ -1,8 +1,5 @@
package com.kri.p6.ncrc.pairing;
import lombok.Generated;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.context.properties.ConfigurationPropertiesScan;
@@ -11,9 +8,6 @@ import org.springframework.boot.context.properties.ConfigurationPropertiesScan;
@ConfigurationPropertiesScan
public class NcrcPairingApplication {
@Generated
private static final Logger log = LoggerFactory.getLogger(NcrcPairingApplication.class);
public static void main(String[] args) {
SpringApplication.run(NcrcPairingApplication.class, args);
}

View File

@@ -5,21 +5,9 @@ public final class PairingConstant {
public static final String SHEET_MEMBER = "위원정보";
public static final String SHEET_MUNICIPALITY = "지자체 정보";
public static final String SHEET_CENTER = "센터정보";
public static final String SHEET_MEMBER_REGION_CODE = "위원 지역 코드표";
public static final String SHEET_CENTER_ADJACENT_REGION = "센터 인접지역표";
public static final String SHEET_PREFERENCE_MATCH = "희망지역 매칭표";
public static final String RESULT_SHEET_ASSIGNMENT = "배정결과";
public static final String RESULT_SHEET_UNASSIGNED_CENTER = "미배정센터";
public static final String RESULT_SHEET_UNUSED_MEMBER = "미사용위원";
public static final String RESULT_SHEET_SUMMARY = "처리요약";
public static final String RESULT_SHEET_AB_PAIR = "AB페어목록";
public static final String RESULT_SHEET_CANDIDATE_SUMMARY = "후보요약";
public static final String RESULT_SHEET_VALIDATION_ERROR = "검증오류";
public static final String RESULT_SHEET_RULE_CHECK = "규칙위반검사";
public static final String RESULT_SHEET_APPLIED_SETTING = "적용설정";
private PairingConstant() {
}
}

View File

@@ -1,14 +0,0 @@
package com.kri.p6.ncrc.pairing.config;
import com.google.ortools.Loader;
import jakarta.annotation.PostConstruct;
import org.springframework.context.annotation.Configuration;
@Configuration
public class OrToolsConfig {
@PostConstruct
public void init() {
Loader.loadNativeLibraries();
}
}

View File

@@ -11,11 +11,7 @@ public class PairingProperties {
private Excel excel = new Excel();
private Code code = new Code();
private Rule rule = new Rule();
private Preference preference = new Preference();
private Objective objective = new Objective();
private Candidate candidate = new Candidate();
private Solver solver = new Solver();
@Getter
@Setter
@@ -28,51 +24,13 @@ public class PairingProperties {
public static class Code {
private int regionCodeLength = 2;
private int residenceCodeLength = 5;
private int residenceMatchPrefixLength = 3;
private String anyRegionCode = "00";
}
@Getter
@Setter
public static class Rule {
private int maxCentersPerPairPerDay = 3;
private int maxCounterpartsPerMember = 3;
private int maxMemberVisitAverageRatioPercent = 130;
}
@Getter
@Setter
public static class Preference {
private int anywhereRank = 0;
private int ignoredRank = 99;
private boolean activeWildcardFallbackEnabled = false;
private long wildcardFallbackScoreBonus = 25_000L;
}
@Getter
@Setter
public static class Objective {
private long assignmentWeight = 1_000_000L;
private long preferenceBaseWeight = 30_000L;
private long preferenceRankPenalty = 1_000L;
private long residenceMatchWeight = 10_000L;
private long memberBalanceWeight = 20_000L;
}
@Getter
@Setter
public static class Candidate {
private int maxPairCandidatesPerMember = 0;
private int maxDispatchRegionsPerPair = 0;
private int maxAssignmentsPerCenter = 1_000;
private int maxAssignmentsPerMember = 3_000;
private int maxDatesPerAssignmentCandidate = 80;
}
@Getter
@Setter
public static class Solver {
private double maxTimeSeconds = 30.0;
private int numSearchWorkers = Math.max(1, Runtime.getRuntime().availableProcessors() - 1);
}
}

View File

@@ -1,36 +0,0 @@
package com.kri.p6.ncrc.pairing.controller;
import com.kri.common.feature.web.BusinessException;
import com.kri.p6.ncrc.pairing.common.cache.DatagoHolidayCache;
import com.kri.p6.ncrc.pairing.common.external.datago.HolidayDto;
import io.swagger.v3.oas.annotations.Operation;
import io.swagger.v3.oas.annotations.tags.Tag;
import java.util.List;
import java.util.Set;
import lombok.RequiredArgsConstructor;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
@RestController
@RequestMapping("/api/v1/admin-cache")
@RequiredArgsConstructor
@Tag(name = "Admin Cache", description = "캐시 관리 API")
public class CacheAdminController {
private final DatagoHolidayCache datagoHolidayCache;
@Operation(summary = "국공휴일 캐시 조회")
@GetMapping("/holiday/{year}")
public List<HolidayDto> getHolidays(
@PathVariable String year
) {
if (year.length() != 4) {
throw BusinessException.badRequest("INVALID_YEAR_FORMAT", "년도 형식이 올바르지 않습니다.");
}
Set<String> years = Set.of(year);
return datagoHolidayCache.getHolidays(years);
}
}

View File

@@ -5,7 +5,6 @@ import com.kri.p6.ncrc.pairing.common.util.ExcelResponseBuilder;
import com.kri.p6.ncrc.pairing.service.PairingExcelService;
import com.kri.p6.ncrc.pairing.service.PairingService;
import io.swagger.v3.oas.annotations.Operation;
import io.swagger.v3.oas.annotations.Parameter;
import io.swagger.v3.oas.annotations.tags.Tag;
import lombok.RequiredArgsConstructor;
import org.springframework.http.HttpStatus;
@@ -14,63 +13,39 @@ import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RequestPart;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.multipart.MultipartFile;
@RestController
@RequestMapping({"/api/v1/pairing"})
@RequestMapping("/api/v1/pairing")
@RequiredArgsConstructor
@Tag(
name = "Pairing",
description = "위원/센터 매칭 API"
)
@Tag(name = "Pairing", description = "위원/센터 배정 API")
public class PairingController {
private final PairingService pairingService;
private final PairingExcelService pairingExcelService;
@PostMapping(value = "/run", consumes = MediaType.MULTIPART_FORM_DATA_VALUE)
@Operation(
summary = "업로드된 파일로 위원과 센터를 매칭"
)
public ResponseEntity<byte[]> pairingMemberByCenter(
@RequestParam("file") MultipartFile file
) {
String fileName = file.getOriginalFilename() == null ? "pairing" : file.getOriginalFilename();
try {
byte[] bytes = pairingService.pairingMemberByCenter(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);
}
}
}
@PostMapping(value = "/run/new1", consumes = MediaType.MULTIPART_FORM_DATA_VALUE)
@Operation(
summary = "업로드된 파일로 위원과 센터를 매칭"
)
@PostMapping(value = "/run/new", consumes = MediaType.MULTIPART_FORM_DATA_VALUE)
@Operation(summary = "업로드된 엑셀 파일로 위원과 센터를 배정")
public ResponseEntity<byte[]> pairingMemberByCenterNew(
@RequestParam("file") MultipartFile file
) {
String fileName = file.getOriginalFilename() == null ? "pairing" : file.getOriginalFilename();
if (fileName != null && fileName.endsWith(".xlsx")) {
fileName = fileName.substring(0, fileName.length() - 5);
}
try {
byte[] bytes = pairingService.pairingMemberByCenterNew(file);
return ExcelResponseBuilder.buildExcelResponse(fileName + " 결과.xlsx", bytes);
} catch (BusinessException e) {
if (e.getStatus() != HttpStatus.BAD_REQUEST) {
throw e;
} else {
}
byte[] bytes = pairingExcelService.writeValidationError(e.getCode(), e.getMessage());
return ExcelResponseBuilder.buildExcelResponse(fileName + " 오류.xlsx", bytes);
}
}
}
}

View File

@@ -1,28 +0,0 @@
package com.kri.p6.ncrc.pairing.dto.excel.input;
import com.kri.common.feature.excel.ExcelColumn;
import lombok.Data;
import lombok.NoArgsConstructor;
@Data
@NoArgsConstructor
public class MemberRegionCodeExcelDto {
@ExcelColumn(header = "시도", order = 0, width = 15)
private String sido;
@ExcelColumn(header = "시군구", order = 1, width = 15)
private String sigungu;
@ExcelColumn(header = "권역코드", order = 2, width = 12)
private String regionCode;
@ExcelColumn(header = "세부권역코드(중간 1자리)", order = 3, width = 25)
private String detailRegionCode;
@ExcelColumn(header = "세부지역코드(마지막2자리)", order = 4, width = 25)
private String detailAreaCode;
@ExcelColumn(header = "지역 코드", order = 5, width = 12)
private String fullRegionCode;
}

View File

@@ -11,7 +11,6 @@ public class PairingWorkbookData {
private final List<MemberExcelDto> members;
private final List<MunicipalityExcelDto> municipalities;
private final List<CenterExcelDto> centers;
private final List<MemberRegionCodeExcelDto> memberRegionCodes;
private final List<CenterAdjacentRegionExcelDto> centerAdjacentRegions;
private final List<PreferenceMatchExcelDto> preferenceMatchRules;
}

View File

@@ -1,39 +0,0 @@
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 ABPairExcelDto {
@ExcelColumn(header = "AB 그룹", order = 0, width = 12)
private String groupId;
@ExcelColumn(header = "A 현장위원 id", order = 1, width = 18)
private String aFieldMemberId;
@ExcelColumn(header = "A 외부위원 id", order = 2, width = 18)
private String aExternalMemberId;
@ExcelColumn(header = "B 현장위원 id", order = 3, width = 18)
private String bFieldMemberId;
@ExcelColumn(header = "B 외부위원 id", order = 4, width = 18)
private String bExternalMemberId;
@ExcelColumn(header = "공유 파견 권역", order = 5, width = 15)
private String sharedDispatchRegion;
@ExcelColumn(header = "A 배정일", order = 6, width = 25)
private String aAssignmentDates;
@ExcelColumn(header = "B 배정일", order = 7, width = 25)
private String bAssignmentDates;
@ExcelColumn(header = "날짜 겹침 여부", order = 8, width = 15)
private String dateOverlapped;
}

View File

@@ -1,21 +0,0 @@
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 AppliedSettingExcelDto {
@ExcelColumn(header = "설정명", order = 0, width = 38)
private String name;
@ExcelColumn(header = "설정에 대한 설명", order = 1, width = 70)
private String description;
@ExcelColumn(header = "값", order = 2, width = 24)
private String value;
}

View File

@@ -1,78 +0,0 @@
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 AssignmentResultExcelDto {
@ExcelColumn(header = "일자", order = 0, width = 15)
private String date;
@ExcelColumn(header = "현장위원 id", order = 1, width = 15)
private String fieldMemberId;
@ExcelColumn(header = "현장위원 성별", order = 2, width = 12)
private String fieldMemberGender;
@ExcelColumn(header = "현장위원 경력", order = 3, width = 12)
private String fieldMemberExperience;
@ExcelColumn(header = "현장위원 거주지", order = 4, width = 15)
private String fieldMemberResidenceCode;
@ExcelColumn(header = "현장위원 활동지역", order = 5, width = 15)
private String fieldMemberActivityRegion;
@ExcelColumn(header = "현장위원 희망지역 순위", order = 6, width = 18)
private String fieldMemberPreferenceRank;
@ExcelColumn(header = "외부위원 id", order = 7, width = 15)
private String externalMemberId;
@ExcelColumn(header = "외부위원 성별", order = 8, width = 12)
private String externalMemberGender;
@ExcelColumn(header = "외부위원 경력", order = 9, width = 12)
private String externalMemberExperience;
@ExcelColumn(header = "외부위원 거주지", order = 10, width = 15)
private String externalMemberResidenceCode;
@ExcelColumn(header = "외부위원 활동지역", order = 11, width = 15)
private String externalMemberActivityRegion;
@ExcelColumn(header = "외부위원 희망지역 순위", order = 12, width = 18)
private String externalMemberPreferenceRank;
@ExcelColumn(header = "센터 id", order = 13, width = 15)
private String centerId;
@ExcelColumn(header = "지자체 id", order = 14, width = 15)
private String municipalityId;
@ExcelColumn(header = "여성 위원만", order = 15, width = 12)
private String centerWomenOnly;
@ExcelColumn(header = "파견 권역", order = 16, width = 12)
private String dispatchRegion;
@ExcelColumn(header = "인접지역 분류", order = 17, width = 15)
private String adjacentRegionClassification;
@ExcelColumn(header = "희망지역 매칭 순위", order = 18, width = 18)
private String preferencePriority;
@ExcelColumn(header = "AB 그룹", order = 19, width = 12)
private String abGroup;
@ExcelColumn(header = "대체 현장위원 id", order = 20, width = 18)
private String backupFieldMemberId;
@ExcelColumn(header = "대체 외부위원 id", order = 21, width = 18)
private String backupExternalMemberId;
}

View File

@@ -1,18 +0,0 @@
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 PairingSummaryExcelDto {
@ExcelColumn(header = "항목", order = 0, width = 25)
private String name;
@ExcelColumn(header = "값", order = 1, width = 20)
private String value;
}

View File

@@ -1,21 +0,0 @@
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 UnassignedCenterExcelDto {
@ExcelColumn(header = "센터 id", order = 0, width = 15)
private String centerId;
@ExcelColumn(header = "지자체 id", order = 1, width = 15)
private String municipalityId;
@ExcelColumn(header = "사유", order = 2, width = 40)
private String reason;
}

View File

@@ -1,21 +0,0 @@
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 UnusedMemberExcelDto {
@ExcelColumn(header = "위원 id", order = 0, width = 15)
private String memberId;
@ExcelColumn(header = "현장/외부 구분", order = 1, width = 15)
private String role;
@ExcelColumn(header = "사유", order = 2, width = 40)
private String reason;
}

View File

@@ -1,16 +0,0 @@
package com.kri.p6.ncrc.pairing.model;
import lombok.Builder;
import lombok.Getter;
@Getter
@Builder
public class ABPairMatch {
private final String groupId;
private final String fieldMemberId;
private final String externalMemberId;
private final String counterpartFieldMemberId;
private final String counterpartExternalMemberId;
}

View File

@@ -1,23 +0,0 @@
package com.kri.p6.ncrc.pairing.model;
import java.time.LocalDate;
import lombok.Builder;
import lombok.Getter;
@Getter
@Builder
public class AssignmentCandidate {
private final String fieldMemberId;
private final String externalMemberId;
private final String centerId;
private final String municipalityId;
private final LocalDate date;
private final String dispatchRegion;
private final String adjacentRegionClassification;
private final int preferencePriority;
private final int fieldMemberPreferenceRank;
private final int externalMemberPreferenceRank;
private final int residenceMatchScore;
}

View File

@@ -1,17 +0,0 @@
package com.kri.p6.ncrc.pairing.model;
import lombok.Builder;
import lombok.Getter;
@Getter
@Builder
public class DispatchRegionCandidate {
private final String fieldMemberId;
private final String externalMemberId;
private final String dispatchRegion;
private final int preferencePriority;
private final int fieldMemberPreferenceRank;
private final int externalMemberPreferenceRank;
}

View File

@@ -1,17 +0,0 @@
package com.kri.p6.ncrc.pairing.model;
import lombok.Builder;
import lombok.Getter;
@Getter
@Builder
public class MemberRegionCode {
private final String sido;
private final String sigungu;
private final String regionCode;
private final String detailRegionCode;
private final String detailAreaCode;
private final String fullRegionCode;
}

View File

@@ -1,14 +0,0 @@
package com.kri.p6.ncrc.pairing.model;
import lombok.Builder;
import lombok.Getter;
@Getter
@Builder
public class PairCandidate {
private final String fieldMemberId;
private final String externalMemberId;
private final int residenceMatchScore;
}

View File

@@ -1,18 +0,0 @@
package com.kri.p6.ncrc.pairing.model;
import java.util.List;
import java.util.Map;
import java.util.Set;
import lombok.Builder;
import lombok.Getter;
@Getter
@Builder
public class PairingCandidates {
private final List<PairCandidate> pairCandidates;
private final List<DispatchRegionCandidate> dispatchRegionCandidates;
private final List<AssignmentCandidate> assignmentCandidates;
private final Map<String, Set<String>> unassignedCenterReasons;
}

View File

@@ -13,7 +13,6 @@ public class PairingData {
private final List<Member> members;
private final List<Municipality> municipalities;
private final List<Center> centers;
private final List<MemberRegionCode> memberRegionCodes;
private final List<CenterAdjacentRegion> centerAdjacentRegions;
private final List<PreferenceMatchRule> preferenceMatchRules;
private final Set<LocalDate> commonUnavailableDates;

View File

@@ -1,30 +0,0 @@
package com.kri.p6.ncrc.pairing.model;
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.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 java.util.List;
import lombok.Builder;
import lombok.Getter;
@Getter
@Builder
public class PairingResult {
private final List<AssignmentResultExcelDto> assignments;
private final List<UnassignedCenterExcelDto> unassignedCenters;
private final List<UnusedMemberExcelDto> unusedMembers;
private final List<PairingSummaryExcelDto> summaries;
private final List<ABPairExcelDto> abPairs;
private final List<CandidateSummaryExcelDto> candidateSummaries;
private final List<AppliedSettingExcelDto> appliedSettings;
private final List<ValidationErrorExcelDto> validationErrors;
private final List<RuleViolationExcelDto> ruleViolations;
}

View File

@@ -1,801 +0,0 @@
package com.kri.p6.ncrc.pairing.service;
import com.kri.p6.ncrc.pairing.common.enums.Gender;
import com.kri.p6.ncrc.pairing.common.enums.MemberRole;
import com.kri.p6.ncrc.pairing.config.PairingProperties;
import com.kri.p6.ncrc.pairing.model.AssignmentCandidate;
import com.kri.p6.ncrc.pairing.model.Center;
import com.kri.p6.ncrc.pairing.model.CenterAdjacentRegion;
import com.kri.p6.ncrc.pairing.model.DispatchRegionCandidate;
import com.kri.p6.ncrc.pairing.model.Member;
import com.kri.p6.ncrc.pairing.model.Municipality;
import com.kri.p6.ncrc.pairing.model.PairCandidate;
import com.kri.p6.ncrc.pairing.model.PairingCandidates;
import com.kri.p6.ncrc.pairing.model.PairingData;
import com.kri.p6.ncrc.pairing.model.PreferenceMatchRule;
import java.time.LocalDate;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.PriorityQueue;
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 PairingCandidateService {
private final PairingProperties pairingProperties;
public PairingCandidates generate(PairingData data) {
// 후보 생성은 "가능한 조합을 넓게 만들고, 명백히 불가능한 조합만 제거"하는 단계입니다.
// 이후 PairingScheduleService가 이 후보들 중 실제 방문 일정을 선택합니다.
List<PairCandidate> pairCandidates = trimPairCandidates(
createPairCandidates(data.getMembers()), data.getMembers());
List<DispatchRegionCandidate> dispatchRegionCandidates = trimDispatchRegionCandidates(
createDispatchRegionCandidates(data, pairCandidates));
Map<String, Set<String>> unassignedCenterReasons = createInitialCenterReasonMap(data);
List<AssignmentCandidate> rawAssignmentCandidates = createAssignmentCandidates(data,
pairCandidates, dispatchRegionCandidates, unassignedCenterReasons);
List<AssignmentCandidate> residencePreferredCandidates = preferResidenceMatchesByCenter(
rawAssignmentCandidates, unassignedCenterReasons);
List<AssignmentCandidate> assignmentCandidates = trimAssignmentCandidates(
residencePreferredCandidates,
data.getCenters(), unassignedCenterReasons);
return PairingCandidates.builder().pairCandidates(pairCandidates)
.dispatchRegionCandidates(dispatchRegionCandidates)
.assignmentCandidates(assignmentCandidates).unassignedCenterReasons(unassignedCenterReasons)
.build();
}
private List<PairCandidate> createPairCandidates(List<Member> members) {
// 현장위원 1명 + 외부위원 1명을 기본 조로 봅니다.
// 두 위원의 활동 가능 기간이 전혀 겹치지 않으면 이후 센터 배정이 불가능하므로 제외합니다.
List<Member> fieldMembers = members.stream()
.filter(member -> member.getRole() == MemberRole.FIELD).toList();
List<Member> externalMembers = members.stream()
.filter(member -> member.getRole() == MemberRole.EXTERNAL).toList();
List<PairCandidate> candidates = new ArrayList<>();
for (Member fieldMember : fieldMembers) {
for (Member externalMember : externalMembers) {
if (hasDateOverlap(fieldMember, externalMember)) {
candidates.add(PairCandidate.builder().fieldMemberId(fieldMember.getId())
.externalMemberId(externalMember.getId())
.residenceMatchScore(calculateResidenceMatchScore(fieldMember, externalMember))
.build());
}
}
}
return candidates;
}
private List<DispatchRegionCandidate> createDispatchRegionCandidates(PairingData data,
List<PairCandidate> pairCandidates) {
// 조가 갈 수 있는 파견 권역 후보를 만듭니다.
// 상피제(위원 활동지역과 파견 권역 일치)는 여기서 제거합니다.
Map<String, Member> memberMap = toMemberMap(data.getMembers());
Set<String> dispatchRegions = data.getCenterAdjacentRegions().stream()
.map(CenterAdjacentRegion::getDispatchRegion).collect(Collectors.toSet());
List<DispatchRegionCandidate> candidates = new ArrayList<>();
for (PairCandidate pairCandidate : pairCandidates) {
Member fieldMember = memberMap.get(pairCandidate.getFieldMemberId());
Member externalMember = memberMap.get(pairCandidate.getExternalMemberId());
for (String dispatchRegion : dispatchRegions) {
if (!isConflictRegion(fieldMember, externalMember, dispatchRegion)) {
int fieldRank = findPreferenceRank(fieldMember, dispatchRegion);
int externalRank = findPreferenceRank(externalMember, dispatchRegion);
Optional<PreferenceMatchRule> matchRule = findPreferenceMatchRule(
data.getPreferenceMatchRules(), fieldRank, externalRank);
// fieldRank/externalRank가 -1이어도 희망지역 매칭표의 99(wildcard) 규칙은 적용될 수 있습니다.
// 99는 "해당 위원의 희망지역을 고려하지 않음"이라는 후순위 fallback입니다.
candidates.add(DispatchRegionCandidate.builder().fieldMemberId(fieldMember.getId())
.externalMemberId(externalMember.getId()).dispatchRegion(dispatchRegion)
.preferencePriority(matchRule.map(PreferenceMatchRule::getPriority)
.orElse(fallbackPreferencePriority(data.getPreferenceMatchRules())))
.fieldMemberPreferenceRank(fieldRank).externalMemberPreferenceRank(externalRank)
.build());
}
}
}
return candidates;
}
private List<AssignmentCandidate> createAssignmentCandidates(
PairingData data,
List<PairCandidate> pairCandidates,
List<DispatchRegionCandidate> dispatchRegionCandidates,
Map<String, Set<String>> unassignedCenterReasons
) {
// 파견 권역 후보를 실제 센터와 날짜 후보로 확장합니다.
// 여성전용, 기방문센터, 위원/지자체/센터 불가능일, 공휴일/주말은 이 단계에서 제외합니다.
Map<String, Member> memberMap = toMemberMap(data.getMembers());
Map<String, Municipality> municipalityMap = data.getMunicipalities().stream()
.collect(Collectors.toMap(Municipality::getId, Function.identity(), (left, right) -> left));
Map<String, PairCandidate> pairMap = pairCandidates.stream()
.collect(Collectors.toMap(this::pairKey, Function.identity(), (left, right) -> left));
Map<String, Set<String>> adjacentClassificationsByDispatchRegion = data.getCenterAdjacentRegions()
.stream().collect(Collectors.groupingBy(CenterAdjacentRegion::getDispatchRegion,
Collectors.mapping(CenterAdjacentRegion::getAdjacentRegionClassification,
Collectors.toSet())));
Map<String, List<Center>> centersByAdjacentClassification = data.getCenters().stream()
.collect(Collectors.groupingBy(Center::getAdjacentRegionClassification,
LinkedHashMap::new, Collectors.toList()));
Set<LocalDate> commonUnavailableDates = commonUnavailableDates(data);
Map<String, PriorityQueue<AssignmentCandidate>> centerCandidateBuckets = new LinkedHashMap<>();
Map<String, PriorityQueue<AssignmentCandidate>> memberCandidateBuckets = new LinkedHashMap<>();
for (DispatchRegionCandidate dispatchCandidate : dispatchRegionCandidates) {
Member fieldMember = memberMap.get(dispatchCandidate.getFieldMemberId());
Member externalMember = memberMap.get(dispatchCandidate.getExternalMemberId());
PairCandidate pairCandidate = pairMap.get(
pairKey(dispatchCandidate.getFieldMemberId(),
dispatchCandidate.getExternalMemberId()));
Set<String> adjacentClassifications = adjacentClassificationsByDispatchRegion
.getOrDefault(dispatchCandidate.getDispatchRegion(), Set.of());
for (Center center : centersForDispatch(adjacentClassifications,
centersByAdjacentClassification)) {
if (!adjacentClassifications.contains(center.getAdjacentRegionClassification())) {
addReason(unassignedCenterReasons, center.getId(), "파견 권역과 센터 인접지역 분류 불일치");
} else {
Municipality municipality = municipalityMap.get(
center.getMunicipalityId());
List<String> centerReasons = findCenterHardRuleReasons(fieldMember, externalMember,
center);
if (!centerReasons.isEmpty()) {
centerReasons.forEach(
reason -> addReason(unassignedCenterReasons, center.getId(), reason));
} else {
List<LocalDate> assignableDates = findAssignableDates(fieldMember,
externalMember, municipality, center, commonUnavailableDates);
if (assignableDates.isEmpty()) {
addReason(unassignedCenterReasons, center.getId(),
"위원/지자체/센터 일정 또는 국공휴일 조건 불일치");
} else {
for (LocalDate assignableDate : assignableDates) {
addBoundedAssignmentCandidate(centerCandidateBuckets, memberCandidateBuckets,
AssignmentCandidate.builder().fieldMemberId(fieldMember.getId())
.externalMemberId(externalMember.getId()).centerId(center.getId())
.municipalityId(center.getMunicipalityId()).date(assignableDate)
.dispatchRegion(dispatchCandidate.getDispatchRegion())
.adjacentRegionClassification(center.getAdjacentRegionClassification())
.preferencePriority(dispatchCandidate.getPreferencePriority())
.fieldMemberPreferenceRank(dispatchCandidate.getFieldMemberPreferenceRank())
.externalMemberPreferenceRank(dispatchCandidate.getExternalMemberPreferenceRank())
.residenceMatchScore(
pairCandidate == null ? 0 : pairCandidate.getResidenceMatchScore()).build());
}
}
}
}
}
}
return mergeAssignmentCandidateBuckets(centerCandidateBuckets, memberCandidateBuckets);
}
private List<AssignmentCandidate> preferResidenceMatchesByCenter(
List<AssignmentCandidate> candidates, Map<String, Set<String>> unassignedCenterReasons) {
// 위원 전원 조편성이 0순위 HARD 룰이므로 거주지 유사도는 후보 제거 조건으로 쓰지 않습니다.
// 거주지 3자리/2자리 일치 여부는 solver 점수로만 반영합니다.
return candidates;
}
private List<DispatchRegionCandidate> trimDispatchRegionCandidates(
List<DispatchRegionCandidate> candidates) {
int limit = maxDispatchRegionsPerPair();
if (limit <= 0) {
return candidates;
}
return candidates.stream()
.collect(Collectors.groupingBy(this::pairKey, LinkedHashMap::new, Collectors.toList()))
.values()
.stream()
.flatMap(group -> group.stream()
.sorted(dispatchRegionCandidateComparator())
.limit(limit))
.toList();
}
private List<PairCandidate> trimPairCandidates(List<PairCandidate> candidates,
List<Member> members) {
int limit = maxPairCandidatesPerMember();
if (limit <= 0) {
return candidates;
}
Map<String, Member> memberMap = toMemberMap(members);
Map<String, Integer> memberUsage = new HashMap<>();
List<PairCandidate> selected = new ArrayList<>();
Set<String> selectedKeys = new LinkedHashSet<>();
for (PairCandidate candidate : candidates.stream()
.sorted(pairCandidateComparator(memberMap))
.toList()) {
int fieldCount = memberUsage.getOrDefault(candidate.getFieldMemberId(), 0);
int externalCount = memberUsage.getOrDefault(candidate.getExternalMemberId(), 0);
if (fieldCount < limit && externalCount < limit) {
addPairCandidate(selected, selectedKeys, memberUsage, candidate);
}
}
Set<String> missingMemberIds = candidates.stream()
.flatMap(candidate -> java.util.stream.Stream.of(candidate.getFieldMemberId(),
candidate.getExternalMemberId()))
.filter(memberId -> memberUsage.getOrDefault(memberId, 0) == 0)
.collect(Collectors.toCollection(LinkedHashSet::new));
for (PairCandidate candidate : candidates.stream()
.sorted(pairCandidateComparator(memberMap))
.toList()) {
if (missingMemberIds.isEmpty()) {
break;
}
if (selectedKeys.contains(pairKey(candidate))) {
continue;
}
if (!missingMemberIds.contains(candidate.getFieldMemberId())
&& !missingMemberIds.contains(candidate.getExternalMemberId())) {
continue;
}
addPairCandidate(selected, selectedKeys, memberUsage, candidate);
missingMemberIds.remove(candidate.getFieldMemberId());
missingMemberIds.remove(candidate.getExternalMemberId());
}
return selected;
}
private void addPairCandidate(List<PairCandidate> selected, Set<String> selectedKeys,
Map<String, Integer> memberUsage, PairCandidate candidate) {
selected.add(candidate);
selectedKeys.add(pairKey(candidate));
memberUsage.merge(candidate.getFieldMemberId(), 1, Integer::sum);
memberUsage.merge(candidate.getExternalMemberId(), 1, Integer::sum);
}
private List<Center> centersForDispatch(Set<String> adjacentClassifications,
Map<String, List<Center>> centersByAdjacentClassification) {
return adjacentClassifications.stream()
.flatMap(adjacentClassification -> centersByAdjacentClassification
.getOrDefault(adjacentClassification, List.of()).stream())
.toList();
}
private void addBoundedAssignmentCandidate(
Map<String, PriorityQueue<AssignmentCandidate>> centerCandidateBuckets,
Map<String, PriorityQueue<AssignmentCandidate>> memberCandidateBuckets,
AssignmentCandidate candidate) {
// 후보 수가 너무 커지면 처리 시간이 급격히 늘어납니다.
// 센터별/위원별 후보 상한을 두되, 0이면 제한하지 않습니다.
addBounded(centerCandidateBuckets, candidate.getCenterId(), candidate,
maxAssignmentsPerCenter());
addBounded(memberCandidateBuckets, candidate.getFieldMemberId(), candidate,
maxAssignmentsPerMember());
addBounded(memberCandidateBuckets, candidate.getExternalMemberId(), candidate,
maxAssignmentsPerMember());
}
private void addBounded(Map<String, PriorityQueue<AssignmentCandidate>> buckets, String key,
AssignmentCandidate candidate, int limit) {
PriorityQueue<AssignmentCandidate> bucket = buckets.computeIfAbsent(key,
ignored -> new PriorityQueue<>(worstAssignmentComparator()));
if (limit <= 0 || bucket.size() < limit) {
bucket.add(candidate);
return;
}
AssignmentCandidate worstCandidate = bucket.peek();
if (worstCandidate != null
&& assignmentCandidateComparator().compare(candidate, worstCandidate) < 0) {
bucket.poll();
bucket.add(candidate);
}
}
private List<AssignmentCandidate> mergeAssignmentCandidateBuckets(
Map<String, PriorityQueue<AssignmentCandidate>> centerCandidateBuckets,
Map<String, PriorityQueue<AssignmentCandidate>> memberCandidateBuckets) {
Map<String, AssignmentCandidate> merged = new LinkedHashMap<>();
centerCandidateBuckets.values().forEach(bucket -> bucket.forEach(candidate ->
merged.putIfAbsent(assignmentKey(candidate), candidate)));
memberCandidateBuckets.values().forEach(bucket -> bucket.forEach(candidate ->
merged.putIfAbsent(assignmentKey(candidate), candidate)));
return merged.values().stream()
.sorted(assignmentCandidateComparator())
.toList();
}
private List<AssignmentCandidate> trimAssignmentCandidates(List<AssignmentCandidate> candidates,
List<Center> centers, Map<String, Set<String>> unassignedCenterReasons) {
List<AssignmentCandidate> trimmedByCenter = trimAssignmentsPerCenter(candidates);
List<AssignmentCandidate> trimmedByMember = trimAssignmentsPerMember(trimmedByCenter);
List<AssignmentCandidate> memberPreservedCandidates = preserveMinimumMemberCandidates(
candidates, new ArrayList<>(trimmedByMember), memberUsage(trimmedByMember),
maxAssignmentsPerMember());
addTrimmedCenterReasons(candidates, memberPreservedCandidates, centers, unassignedCenterReasons);
return memberPreservedCandidates;
}
private List<AssignmentCandidate> trimAssignmentsPerCenter(List<AssignmentCandidate> candidates) {
int limit = maxAssignmentsPerCenter();
if (limit <= 0) {
return candidates;
}
return candidates.stream()
.collect(Collectors.groupingBy(AssignmentCandidate::getCenterId, LinkedHashMap::new,
Collectors.toList()))
.values()
.stream()
.flatMap(group -> group.stream()
.sorted(assignmentCandidateComparator())
.limit(limit))
.toList();
}
private List<AssignmentCandidate> trimAssignmentsPerMember(List<AssignmentCandidate> candidates) {
int limit = maxAssignmentsPerMember();
if (limit <= 0) {
return candidates;
}
Map<String, Integer> memberUsage = new HashMap<>();
List<AssignmentCandidate> selected = new ArrayList<>();
for (AssignmentCandidate candidate : candidates.stream()
.sorted(assignmentCandidateComparator())
.toList()) {
int fieldCount = memberUsage.getOrDefault(candidate.getFieldMemberId(), 0);
int externalCount = memberUsage.getOrDefault(candidate.getExternalMemberId(), 0);
if (fieldCount < limit && externalCount < limit) {
addAssignmentCandidate(selected, memberUsage, candidate);
}
}
return preserveMinimumMemberCandidates(candidates, selected, memberUsage, limit);
}
private List<AssignmentCandidate> preserveMinimumMemberCandidates(
List<AssignmentCandidate> candidates, List<AssignmentCandidate> selected,
Map<String, Integer> memberUsage, int limit) {
Set<String> selectedKeys = selected.stream()
.map(this::assignmentKey)
.collect(Collectors.toSet());
Set<String> missingMemberIds = candidates.stream()
.flatMap(candidate -> java.util.stream.Stream.of(candidate.getFieldMemberId(),
candidate.getExternalMemberId()))
.filter(memberId -> memberUsage.getOrDefault(memberId, 0) == 0)
.collect(Collectors.toCollection(LinkedHashSet::new));
for (AssignmentCandidate candidate : candidates.stream()
.sorted(assignmentCandidateComparator())
.toList()) {
if (missingMemberIds.isEmpty()) {
break;
}
if (selectedKeys.contains(assignmentKey(candidate))) {
continue;
}
if (!missingMemberIds.contains(candidate.getFieldMemberId())
&& !missingMemberIds.contains(candidate.getExternalMemberId())) {
continue;
}
int fieldCount = memberUsage.getOrDefault(candidate.getFieldMemberId(), 0);
int externalCount = memberUsage.getOrDefault(candidate.getExternalMemberId(), 0);
if (fieldCount < limit && externalCount < limit) {
addAssignmentCandidate(selected, memberUsage, candidate);
selectedKeys.add(assignmentKey(candidate));
missingMemberIds.remove(candidate.getFieldMemberId());
missingMemberIds.remove(candidate.getExternalMemberId());
}
}
return selected;
}
private void addAssignmentCandidate(List<AssignmentCandidate> selected,
Map<String, Integer> memberUsage, AssignmentCandidate candidate) {
selected.add(candidate);
memberUsage.merge(candidate.getFieldMemberId(), 1, Integer::sum);
memberUsage.merge(candidate.getExternalMemberId(), 1, Integer::sum);
}
private Map<String, Integer> memberUsage(List<AssignmentCandidate> candidates) {
Map<String, Integer> memberUsage = new HashMap<>();
candidates.forEach(candidate -> {
memberUsage.merge(candidate.getFieldMemberId(), 1, Integer::sum);
memberUsage.merge(candidate.getExternalMemberId(), 1, Integer::sum);
});
return memberUsage;
}
private void addTrimmedCenterReasons(List<AssignmentCandidate> originalCandidates,
List<AssignmentCandidate> trimmedCandidates, List<Center> centers,
Map<String, Set<String>> unassignedCenterReasons) {
Set<String> originalCenterIds = originalCandidates.stream()
.map(AssignmentCandidate::getCenterId)
.collect(Collectors.toSet());
Set<String> trimmedCenterIds = trimmedCandidates.stream()
.map(AssignmentCandidate::getCenterId)
.collect(Collectors.toSet());
for (Center center : centers) {
if (originalCenterIds.contains(center.getId()) && !trimmedCenterIds.contains(center.getId())) {
addReason(unassignedCenterReasons, center.getId(),
"후보 축소 과정에서 상위 후보에 들지 못함");
}
}
}
private boolean hasDateOverlap(Member fieldMember, Member externalMember) {
LocalDate latestStart = max(fieldMember.getAvailableStartDate(),
externalMember.getAvailableStartDate());
LocalDate earliestEnd = min(fieldMember.getAvailableEndDate(),
externalMember.getAvailableEndDate());
return !latestStart.isAfter(earliestEnd);
}
private int calculateResidenceMatchScore(Member fieldMember, Member externalMember) {
if (isSameResidencePrefix(fieldMember, externalMember, residenceMatchPrefixLength())) {
return 2;
}
if (isSameResidencePrefix(fieldMember, externalMember, secondaryResidenceMatchPrefixLength())) {
return 1;
}
return 0;
}
private boolean isSameResidencePrefix(Member fieldMember, Member externalMember, int length) {
String fieldPrefix = prefix(fieldMember.getResidenceCode(), length);
String externalPrefix = prefix(externalMember.getResidenceCode(), length);
return !fieldPrefix.isBlank() && fieldPrefix.equals(externalPrefix);
}
private boolean isConflictRegion(Member fieldMember, Member externalMember,
String dispatchRegion) {
return hasActivityRegion(fieldMember, dispatchRegion) || hasActivityRegion(externalMember,
dispatchRegion);
}
private boolean hasActivityRegion(Member member, String dispatchRegion) {
return java.util.Arrays.stream(member.getActivityRegion().split(","))
.map(String::trim)
.anyMatch(dispatchRegion::equals);
}
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 Optional<PreferenceMatchRule> findPreferenceMatchRule(List<PreferenceMatchRule> rules,
int fieldRank, int externalRank) {
// 99 규칙은 wildcard입니다. 예를 들어 fieldRank가 -1이어도
// 매칭표에 99/1 규칙이 있으면 "현장위원 선호지역 고려하지 않음 + 외부위원 1순위"로 인정합니다.
return rules.stream().filter(
rule -> matchesPreferenceRank(rule.getFieldMemberPreferenceRank(), fieldRank)
)
.filter(rule -> matchesPreferenceRank(rule.getExternalMemberPreferenceRank(), externalRank))
.min(Comparator.comparingInt(PreferenceMatchRule::getPriority))
;
}
private int fallbackPreferencePriority(List<PreferenceMatchRule> rules) {
return rules.stream()
.mapToInt(PreferenceMatchRule::getPriority)
.max()
.orElse(0) + 1000;
}
private boolean matchesPreferenceRank(int ruleRank, int memberRank) {
return ruleRank == ignoredPreferenceRank() || ruleRank == memberRank;
}
private List<String> findCenterHardRuleReasons(Member fieldMember, Member externalMember,
Center center) {
List<String> reasons = new ArrayList<>();
if (center.isWomenOnly() && (fieldMember.getGender() != Gender.FEMALE
|| externalMember.getGender() != Gender.FEMALE)) {
reasons.add("여성 전용 센터 조건 불충족");
}
if (fieldMember.getHistoryCenterIds().contains(center.getId())
|| externalMember.getHistoryCenterIds().contains(center.getId())) {
reasons.add("2023년 진행 센터 재배정 제외");
}
return reasons;
}
private List<LocalDate> findAssignableDates(Member fieldMember, Member externalMember,
Municipality municipality, Center center, Set<LocalDate> commonUnavailableDates) {
List<LocalDate> dates = new ArrayList<>();
LocalDate start = max(
max(fieldMember.getAvailableStartDate(), externalMember.getAvailableStartDate()),
max(municipality.getAvailableStartDate(), center.getAvailableStartDate()));
LocalDate end = min(
min(fieldMember.getAvailableEndDate(), externalMember.getAvailableEndDate()),
min(municipality.getAvailableEndDate(), center.getAvailableEndDate()));
if (!start.isAfter(end)) {
for (LocalDate date = start; !date.isAfter(end); date = date.plusDays(1L)) {
if (isAvailableOn(date, fieldMember, externalMember, municipality, center,
commonUnavailableDates)) {
dates.add(date);
}
}
}
return spreadDates(dates, maxDatesPerAssignmentCandidate());
}
private List<LocalDate> spreadDates(List<LocalDate> dates, int limit) {
if (limit <= 0 || dates.size() <= limit) {
return dates;
}
if (limit == 1) {
return List.of(dates.get(0));
}
List<LocalDate> spread = new ArrayList<>();
for (int i = 0; i < limit; i++) {
int index = (int) Math.round((double) i * (dates.size() - 1) / (limit - 1));
LocalDate date = dates.get(index);
if (!spread.contains(date)) {
spread.add(date);
}
}
return spread;
}
private boolean isAvailableOn(LocalDate date, Member fieldMember, Member externalMember,
Municipality municipality, Center center, Set<LocalDate> commonUnavailableDates) {
return !fieldMember.getUnavailableDates().contains(date)
&& !externalMember.getUnavailableDates().contains(date)
&& !municipality.getUnavailableDates().contains(date) && !center.getUnavailableDates()
.contains(date) && !commonUnavailableDates.contains(date);
}
private Map<String, Set<String>> createInitialCenterReasonMap(PairingData data) {
Map<String, Set<String>> reasons = new HashMap<>();
data.getCenters().forEach(center -> reasons.put(center.getId(), new LinkedHashSet<>()));
return reasons;
}
private void addReason(Map<String, Set<String>> reasons, String centerId, String reason) {
reasons.computeIfAbsent(centerId, key -> new LinkedHashSet<>()).add(reason);
}
private Set<LocalDate> commonUnavailableDates(PairingData data) {
return data.getCommonUnavailableDates() == null ? Set.of() : data.getCommonUnavailableDates();
}
private Map<String, Member> toMemberMap(List<Member> members) {
return members.stream()
.collect(Collectors.toMap(Member::getId, Function.identity(), (left, right) -> left));
}
private String pairKey(PairCandidate pairCandidate) {
return pairKey(pairCandidate.getFieldMemberId(), pairCandidate.getExternalMemberId());
}
private String pairKey(DispatchRegionCandidate dispatchRegionCandidate) {
return pairKey(dispatchRegionCandidate.getFieldMemberId(),
dispatchRegionCandidate.getExternalMemberId());
}
private String pairKey(String fieldMemberId, String externalMemberId) {
return fieldMemberId + "|" + externalMemberId;
}
private String assignmentKey(AssignmentCandidate candidate) {
return candidate.getFieldMemberId() + "|" + candidate.getExternalMemberId() + "|"
+ candidate.getCenterId() + "|" + candidate.getDate();
}
private String prefix(String value) {
return prefix(value, residenceMatchPrefixLength());
}
private String prefix(String value, int length) {
return value.substring(0, Math.min(length, value.length()));
}
private String anyRegionCode() {
return pairingProperties.getCode().getAnyRegionCode();
}
private int anywherePreferenceRank() {
return pairingProperties.getPreference().getAnywhereRank();
}
private int ignoredPreferenceRank() {
return pairingProperties.getPreference().getIgnoredRank();
}
private int residenceMatchPrefixLength() {
return pairingProperties.getCode().getResidenceMatchPrefixLength();
}
private int secondaryResidenceMatchPrefixLength() {
return Math.max(1, residenceMatchPrefixLength() - 1);
}
private int maxDispatchRegionsPerPair() {
return pairingProperties.getCandidate().getMaxDispatchRegionsPerPair();
}
private int maxAssignmentsPerCenter() {
return pairingProperties.getCandidate().getMaxAssignmentsPerCenter();
}
private int maxAssignmentsPerMember() {
return pairingProperties.getCandidate().getMaxAssignmentsPerMember();
}
private int maxPairCandidatesPerMember() {
return pairingProperties.getCandidate().getMaxPairCandidatesPerMember();
}
private int maxDatesPerAssignmentCandidate() {
return pairingProperties.getCandidate().getMaxDatesPerAssignmentCandidate();
}
private Comparator<PairCandidate> pairCandidateComparator(Map<String, Member> memberMap) {
return Comparator.comparingInt((PairCandidate candidate) -> pairCandidateScore(candidate,
memberMap))
.reversed()
.thenComparing(PairCandidate::getFieldMemberId)
.thenComparing(PairCandidate::getExternalMemberId);
}
private Comparator<DispatchRegionCandidate> dispatchRegionCandidateComparator() {
return Comparator.comparingInt(this::dispatchRegionCandidateScore).reversed()
.thenComparing(DispatchRegionCandidate::getDispatchRegion);
}
private Comparator<AssignmentCandidate> assignmentCandidateComparator() {
return Comparator.comparingInt(this::assignmentCandidateScore).reversed()
.thenComparing(AssignmentCandidate::getDate)
.thenComparing(AssignmentCandidate::getCenterId)
.thenComparing(AssignmentCandidate::getFieldMemberId)
.thenComparing(AssignmentCandidate::getExternalMemberId);
}
private Comparator<AssignmentCandidate> worstAssignmentComparator() {
return Comparator.comparingInt(this::assignmentCandidateScore)
.thenComparing(AssignmentCandidate::getDate, Comparator.reverseOrder())
.thenComparing(AssignmentCandidate::getCenterId, Comparator.reverseOrder())
.thenComparing(AssignmentCandidate::getFieldMemberId, Comparator.reverseOrder())
.thenComparing(AssignmentCandidate::getExternalMemberId, Comparator.reverseOrder());
}
private int dispatchRegionCandidateScore(DispatchRegionCandidate candidate) {
return preferenceScore(candidate.getPreferencePriority())
+ preferenceRankBonus(candidate.getFieldMemberPreferenceRank())
+ preferenceRankBonus(candidate.getExternalMemberPreferenceRank());
}
private int pairCandidateScore(PairCandidate candidate, Map<String, Member> memberMap) {
Member fieldMember = memberMap.get(candidate.getFieldMemberId());
Member externalMember = memberMap.get(candidate.getExternalMemberId());
return preferenceIntersectionScore(fieldMember, externalMember)
+ candidate.getResidenceMatchScore() * 10;
}
private int preferenceIntersectionScore(Member fieldMember, Member externalMember) {
if (fieldMember == null || externalMember == null) {
return 0;
}
Set<String> externalPreferences = new LinkedHashSet<>(externalMember.getPreferenceRegions());
int score = 0;
for (String preference : fieldMember.getPreferenceRegions()) {
if (ignoredPreferenceCode(preference)) {
continue;
}
if (anyRegionCode().equals(preference) && externalPreferences.contains(preference)) {
score += 10;
} else if (externalPreferences.contains(preference)) {
score += 100;
}
}
return score;
}
private boolean ignoredPreferenceCode(String preference) {
return String.valueOf(ignoredPreferenceRank()).equals(preference);
}
private int assignmentCandidateScore(AssignmentCandidate candidate) {
return preferenceScore(candidate.getPreferencePriority())
+ preferenceRankBonus(candidate.getFieldMemberPreferenceRank())
+ preferenceRankBonus(candidate.getExternalMemberPreferenceRank())
+ wildcardFallbackBonus(candidate)
+ candidate.getResidenceMatchScore() * (int) pairingProperties.getObjective()
.getResidenceMatchWeight();
}
private int wildcardFallbackBonus(AssignmentCandidate candidate) {
// wildcard 적극 사용 옵션입니다. true이면 99 규칙으로 살아난 후보가
// 후보 축소 단계에서 너무 쉽게 밀려나지 않도록 보너스를 줍니다.
if (!activeWildcardFallbackEnabled()) {
return 0;
}
if (!usesWildcardFallback(candidate)) {
return 0;
}
return (int) Math.min(Integer.MAX_VALUE, wildcardFallbackScoreBonus());
}
private int preferenceScore(int priority) {
return (int) Math.max(0L, pairingProperties.getObjective().getPreferenceBaseWeight()
- priority * pairingProperties.getObjective().getPreferenceRankPenalty());
}
private int preferenceRankBonus(int rank) {
if (rank == anywherePreferenceRank()) {
return 1;
}
if (rank <= 0 || rank == ignoredPreferenceRank()) {
return 0;
}
return Math.max(0, 10 - rank);
}
private boolean usesWildcardFallback(AssignmentCandidate candidate) {
return candidate.getFieldMemberPreferenceRank() < 0
|| candidate.getExternalMemberPreferenceRank() < 0;
}
private boolean activeWildcardFallbackEnabled() {
return pairingProperties.getPreference().isActiveWildcardFallbackEnabled();
}
private long wildcardFallbackScoreBonus() {
return pairingProperties.getPreference().getWildcardFallbackScoreBonus();
}
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;
}
}

View File

@@ -1,18 +1,8 @@
package com.kri.p6.ncrc.pairing.service;
import static com.kri.p6.ncrc.pairing.common.consts.PairingConstant.RESULT_SHEET_AB_PAIR;
import static com.kri.p6.ncrc.pairing.common.consts.PairingConstant.RESULT_SHEET_APPLIED_SETTING;
import static com.kri.p6.ncrc.pairing.common.consts.PairingConstant.RESULT_SHEET_ASSIGNMENT;
import static com.kri.p6.ncrc.pairing.common.consts.PairingConstant.RESULT_SHEET_CANDIDATE_SUMMARY;
import static com.kri.p6.ncrc.pairing.common.consts.PairingConstant.RESULT_SHEET_RULE_CHECK;
import static com.kri.p6.ncrc.pairing.common.consts.PairingConstant.RESULT_SHEET_SUMMARY;
import static com.kri.p6.ncrc.pairing.common.consts.PairingConstant.RESULT_SHEET_UNASSIGNED_CENTER;
import static com.kri.p6.ncrc.pairing.common.consts.PairingConstant.RESULT_SHEET_UNUSED_MEMBER;
import static com.kri.p6.ncrc.pairing.common.consts.PairingConstant.RESULT_SHEET_VALIDATION_ERROR;
import static com.kri.p6.ncrc.pairing.common.consts.PairingConstant.SHEET_CENTER;
import static com.kri.p6.ncrc.pairing.common.consts.PairingConstant.SHEET_CENTER_ADJACENT_REGION;
import static com.kri.p6.ncrc.pairing.common.consts.PairingConstant.SHEET_MEMBER;
import static com.kri.p6.ncrc.pairing.common.consts.PairingConstant.SHEET_MEMBER_REGION_CODE;
import static com.kri.p6.ncrc.pairing.common.consts.PairingConstant.SHEET_MUNICIPALITY;
import static com.kri.p6.ncrc.pairing.common.consts.PairingConstant.SHEET_PREFERENCE_MATCH;
@@ -22,13 +12,9 @@ import com.kri.p6.ncrc.pairing.config.PairingProperties;
import com.kri.p6.ncrc.pairing.dto.excel.input.CenterAdjacentRegionExcelDto;
import com.kri.p6.ncrc.pairing.dto.excel.input.CenterExcelDto;
import com.kri.p6.ncrc.pairing.dto.excel.input.MemberExcelDto;
import com.kri.p6.ncrc.pairing.dto.excel.input.MemberRegionCodeExcelDto;
import com.kri.p6.ncrc.pairing.dto.excel.input.MunicipalityExcelDto;
import com.kri.p6.ncrc.pairing.dto.excel.input.PairingWorkbookData;
import com.kri.p6.ncrc.pairing.dto.excel.input.PreferenceMatchExcelDto;
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;
@@ -36,13 +22,9 @@ 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;
import java.io.InputStream;
@@ -72,8 +54,6 @@ public class PairingExcelService {
.members(readSheet(workbook, MemberExcelDto.class, SHEET_MEMBER))
.municipalities(readSheet(workbook, MunicipalityExcelDto.class, SHEET_MUNICIPALITY))
.centers(readSheet(workbook, CenterExcelDto.class, SHEET_CENTER))
.memberRegionCodes(readSheet(workbook, MemberRegionCodeExcelDto.class,
SHEET_MEMBER_REGION_CODE))
.centerAdjacentRegions(readSheet(workbook, CenterAdjacentRegionExcelDto.class,
SHEET_CENTER_ADJACENT_REGION))
.preferenceMatchRules(readSheet(workbook, PreferenceMatchExcelDto.class,
@@ -87,46 +67,15 @@ public class PairingExcelService {
}
}
public byte[] write(PairingResult result) {
try (Workbook workbook = ExcelMapper.writeToWorkbook(result.getAssignments(),
AssignmentResultExcelDto.class, RESULT_SHEET_ASSIGNMENT);
ByteArrayOutputStream outputStream = new ByteArrayOutputStream()) {
ExcelMapper.appendSheetToWorkbook(workbook, result.getUnassignedCenters(),
UnassignedCenterExcelDto.class, RESULT_SHEET_UNASSIGNED_CENTER, headerRowIndex());
ExcelMapper.appendSheetToWorkbook(workbook, result.getUnusedMembers(),
UnusedMemberExcelDto.class, RESULT_SHEET_UNUSED_MEMBER, headerRowIndex());
ExcelMapper.appendSheetToWorkbook(workbook, result.getSummaries(),
PairingSummaryExcelDto.class, RESULT_SHEET_SUMMARY, headerRowIndex());
ExcelMapper.appendSheetToWorkbook(workbook, result.getAbPairs(), ABPairExcelDto.class,
RESULT_SHEET_AB_PAIR, headerRowIndex());
ExcelMapper.appendSheetToWorkbook(workbook, result.getCandidateSummaries(),
CandidateSummaryExcelDto.class, RESULT_SHEET_CANDIDATE_SUMMARY, headerRowIndex());
ExcelMapper.appendSheetToWorkbook(workbook, result.getAppliedSettings(),
AppliedSettingExcelDto.class, RESULT_SHEET_APPLIED_SETTING, headerRowIndex());
ExcelMapper.appendSheetToWorkbook(workbook, result.getValidationErrors(),
ValidationErrorExcelDto.class, RESULT_SHEET_VALIDATION_ERROR, headerRowIndex());
ExcelMapper.appendSheetToWorkbook(workbook, result.getRuleViolations(),
RuleViolationExcelDto.class, RESULT_SHEET_RULE_CHECK, headerRowIndex());
workbook.write(outputStream);
return outputStream.toByteArray();
} catch (IOException e) {
throw BusinessException.badRequest("PAIRING_EXCEL_WRITE_FAILED",
"결과 엑셀 파일을 생성하는 중 오류가 발생했습니다: " + e.getMessage());
}
}
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());
NewFinalAssignmentExcelDto.class, "최종 배정 with 인접지역", headerRowIndex());
ExcelMapper.appendSheetToWorkbook(workbook, result.getFinalAssignmentsWithCenters(),
NewFinalAssignmentWithCenterExcelDto.class, "최종 배정 with 센터", headerRowIndex());
ExcelMapper.appendSheetToWorkbook(workbook, result.getAdjacentRegions(),
NewAdjacentRegionExcelDto.class, "인접지역목록", headerRowIndex());
ExcelMapper.appendSheetToWorkbook(workbook, result.getCenters(),
@@ -147,18 +96,16 @@ public class PairingExcelService {
}
public byte[] writeValidationError(String code, String message) {
PairingResult result = PairingResult.builder()
.assignments(List.of())
.unassignedCenters(List.of())
.unusedMembers(List.of())
.summaries(List.of(new PairingSummaryExcelDto("처리 상태", "검증 실패")))
.abPairs(List.of())
.candidateSummaries(List.of())
.appliedSettings(appliedSettings())
.validationErrors(List.of(new ValidationErrorExcelDto(code, message, "ERROR")))
.ruleViolations(List.of())
.build();
return write(result);
try (Workbook workbook = ExcelMapper.writeToWorkbook(
List.of(new ValidationErrorExcelDto(code, message, "ERROR")),
ValidationErrorExcelDto.class, "검증오류");
ByteArrayOutputStream outputStream = new ByteArrayOutputStream()) {
workbook.write(outputStream);
return outputStream.toByteArray();
} catch (IOException e) {
throw BusinessException.badRequest("PAIRING_EXCEL_WRITE_FAILED",
"오류 엑셀 파일을 생성하는 중 오류가 발생했습니다: " + e.getMessage());
}
}
private <T> List<T> readSheet(Workbook workbook, Class<T> type, String sheetName) {
@@ -176,76 +123,6 @@ public class PairingExcelService {
return pairingProperties.getExcel().getHeaderRowIndex();
}
private List<AppliedSettingExcelDto> appliedSettings() {
PairingProperties.Excel excel = pairingProperties.getExcel();
PairingProperties.Code code = pairingProperties.getCode();
PairingProperties.Rule rule = pairingProperties.getRule();
PairingProperties.Preference preference = pairingProperties.getPreference();
PairingProperties.Objective objective = pairingProperties.getObjective();
PairingProperties.Candidate candidate = pairingProperties.getCandidate();
PairingProperties.Solver solver = pairingProperties.getSolver();
return List.of(
setting("pairing.excel.header-row-index", "엑셀 헤더로 사용하는 행 인덱스",
excel.getHeaderRowIndex()),
setting("pairing.code.region-code-length", "지역코드 정규화 길이",
code.getRegionCodeLength()),
setting("pairing.code.residence-code-length", "거주지코드 정규화 길이",
code.getResidenceCodeLength()),
setting("pairing.code.residence-match-prefix-length", "거주지 일치 판단에 사용하는 앞자리 길이",
code.getResidenceMatchPrefixLength()),
setting("pairing.code.any-region-code", "희망지역 anywhere로 처리하는 코드",
code.getAnyRegionCode()),
setting("pairing.rule.max-centers-per-pair-per-day", "같은 페어가 하루에 방문할 수 있는 최대 센터 수",
rule.getMaxCentersPerPairPerDay()),
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를 의미하는 순위",
preference.getAnywhereRank()),
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 후보에 추가하는 점수",
preference.getWildcardFallbackScoreBonus()),
setting("pairing.objective.assignment-weight", "센터 하나를 배정하는 것에 부여하는 기본 점수",
objective.getAssignmentWeight()),
setting("pairing.objective.preference-base-weight", "희망지역 매칭 1건마다 부여하는 기본 점수",
objective.getPreferenceBaseWeight()),
setting("pairing.objective.preference-rank-penalty", "희망 순위가 낮아질 때 감점하는 점수",
objective.getPreferenceRankPenalty()),
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이면 무제한",
candidate.getMaxPairCandidatesPerMember()),
setting("pairing.candidate.max-dispatch-regions-per-pair",
"페어별 파견 권역 후보 축소 상한, 0이면 무제한",
candidate.getMaxDispatchRegionsPerPair()),
setting("pairing.candidate.max-assignments-per-center", "센터별 배정 후보 축소 상한",
candidate.getMaxAssignmentsPerCenter()),
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 사용 시 허용할 최대 탐색 시간",
solver.getMaxTimeSeconds()),
setting("pairing.solver.num-search-workers", "CP-SAT 사용 시 사용할 worker 수",
solver.getNumSearchWorkers())
);
}
private AppliedSettingExcelDto setting(String name, String description, Object value) {
return new AppliedSettingExcelDto(name, description, String.valueOf(value));
}
private boolean isBlankRow(Object row) {
return Arrays.stream(row.getClass().getDeclaredFields())
.allMatch(field -> isBlankField(row, field));

View File

@@ -24,7 +24,7 @@ public class PairingHolidayService {
Set<LocalDate> holidays = datagoHolidayCache.getHolidays(years).stream()
.map(this::toHolidayDate).collect(Collectors.toSet());
return PairingData.builder().members(data.getMembers()).municipalities(data.getMunicipalities())
.centers(data.getCenters()).memberRegionCodes(data.getMemberRegionCodes())
.centers(data.getCenters())
.centerAdjacentRegions(data.getCenterAdjacentRegions())
.preferenceMatchRules(data.getPreferenceMatchRules()).commonUnavailableDates(holidays)
.build();

View File

@@ -1,140 +0,0 @@
package com.kri.p6.ncrc.pairing.service;
import com.kri.p6.ncrc.pairing.config.PairingProperties;
import com.kri.p6.ncrc.pairing.model.Member;
import com.kri.p6.ncrc.pairing.model.PairCandidate;
import com.kri.p6.ncrc.pairing.model.PairingData;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.stream.Collectors;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Service;
@Service
@RequiredArgsConstructor
public class PairingMemberPairService {
private final PairingProperties pairingProperties;
public PairSelection select(PairingData data, List<PairCandidate> pairCandidates) {
return select(data, pairCandidates, Map.of());
}
public PairSelection select(PairingData data, List<PairCandidate> pairCandidates,
Map<String, Long> assignmentCountByPair) {
// 0순위 전제: 모든 위원은 최소 1개 이상의 조에 포함되어야 합니다.
// 그래서 센터 배정 전에 먼저 조편성만 수행합니다.
Set<String> allMemberIds = data.getMembers().stream()
.map(Member::getId)
.collect(Collectors.toCollection(LinkedHashSet::new));
Map<String, Set<String>> counterpartsByMember = createCounterpartMap(allMemberIds);
List<PairCandidate> selectedPairs = new ArrayList<>();
List<PairCandidate> sortedCandidates = pairCandidates.stream()
.sorted(pairComparator(assignmentCountByPair))
.toList();
boolean changed;
do {
// 아직 조가 없는 위원을 우선 포함시키는 greedy 방식입니다.
// assignmentCountByPair가 큰 조는 실제 센터 후보가 많다는 뜻이므로 먼저 선택합니다.
changed = false;
Set<String> unmatchedMemberIds = unmatchedMemberIds(allMemberIds, counterpartsByMember);
for (PairCandidate candidate : sortedCandidates) {
if (unmatchedMemberIds.isEmpty()) {
break;
}
if (!coversUnmatchedMember(candidate, unmatchedMemberIds)) {
continue;
}
if (!canAddPair(candidate, counterpartsByMember)) {
continue;
}
addPair(selectedPairs, counterpartsByMember, candidate);
unmatchedMemberIds.remove(candidate.getFieldMemberId());
unmatchedMemberIds.remove(candidate.getExternalMemberId());
changed = true;
}
} while (changed && !unmatchedMemberIds(allMemberIds, counterpartsByMember).isEmpty());
Set<String> unmatchedMemberIds = unmatchedMemberIds(allMemberIds, counterpartsByMember);
if (!unmatchedMemberIds.isEmpty()) {
return new PairSelection(false, selectedPairs,
"페어링되지 않은 위원이 있습니다: " + String.join(", ", unmatchedMemberIds));
}
selectedPairs.sort(Comparator.comparing(PairCandidate::getFieldMemberId)
.thenComparing(PairCandidate::getExternalMemberId));
return new PairSelection(true, selectedPairs, "GREEDY_PAIRED");
}
private Map<String, Set<String>> createCounterpartMap(Set<String> memberIds) {
Map<String, Set<String>> counterpartsByMember = new HashMap<>();
memberIds.forEach(memberId -> counterpartsByMember.put(memberId, new HashSet<>()));
return counterpartsByMember;
}
private Set<String> unmatchedMemberIds(Set<String> allMemberIds,
Map<String, Set<String>> counterpartsByMember) {
return allMemberIds.stream()
.filter(memberId -> counterpartsByMember.getOrDefault(memberId, Set.of()).isEmpty())
.collect(Collectors.toCollection(LinkedHashSet::new));
}
private boolean coversUnmatchedMember(PairCandidate candidate, Set<String> unmatchedMemberIds) {
return unmatchedMemberIds.contains(candidate.getFieldMemberId())
|| unmatchedMemberIds.contains(candidate.getExternalMemberId());
}
private boolean canAddPair(PairCandidate candidate,
Map<String, Set<String>> counterpartsByMember) {
if (counterpartsByMember.get(candidate.getFieldMemberId())
.contains(candidate.getExternalMemberId())) {
return false;
}
return counterpartsByMember.get(candidate.getFieldMemberId()).size() < maxCounterpartsPerMember()
&& counterpartsByMember.get(candidate.getExternalMemberId()).size()
< maxCounterpartsPerMember();
}
private void addPair(List<PairCandidate> selectedPairs,
Map<String, Set<String>> counterpartsByMember, PairCandidate candidate) {
selectedPairs.add(candidate);
counterpartsByMember.get(candidate.getFieldMemberId()).add(candidate.getExternalMemberId());
counterpartsByMember.get(candidate.getExternalMemberId()).add(candidate.getFieldMemberId());
}
private Comparator<PairCandidate> pairComparator(Map<String, Long> assignmentCountByPair) {
// 1순위: 해당 조가 갈 수 있는 센터/날짜 후보 수
// 2순위: 거주지 유사도
// 이후 id 정렬은 같은 점수일 때 결과가 매번 흔들리지 않게 하기 위한 tie-breaker입니다.
return Comparator.comparingLong((PairCandidate candidate) ->
assignmentCountByPair.getOrDefault(pairKey(candidate), 0L))
.reversed()
.thenComparing(Comparator.comparingInt(this::unmatchedPairScore).reversed())
.thenComparing(PairCandidate::getFieldMemberId)
.thenComparing(PairCandidate::getExternalMemberId);
}
private int unmatchedPairScore(PairCandidate candidate) {
return candidate.getResidenceMatchScore();
}
private int maxCounterpartsPerMember() {
return pairingProperties.getRule().getMaxCounterpartsPerMember();
}
private String pairKey(PairCandidate candidate) {
return candidate.getFieldMemberId() + "|" + candidate.getExternalMemberId();
}
public record PairSelection(boolean hasSolution, List<PairCandidate> selectedPairs,
String status) {
}
}

View File

@@ -48,7 +48,8 @@ public class PairingNewService {
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 boolean USE_AVAILABLE_ADJACENT_REGION_IN_PAIR_SCORE = true;
private static final long AVAILABLE_ADJACENT_REGION_WEIGHT = 1_000_000_000_000_000L;
private final PairingProperties pairingProperties;

View File

@@ -8,21 +8,19 @@ import com.kri.p6.ncrc.pairing.config.PairingProperties;
import com.kri.p6.ncrc.pairing.dto.excel.input.CenterAdjacentRegionExcelDto;
import com.kri.p6.ncrc.pairing.dto.excel.input.CenterExcelDto;
import com.kri.p6.ncrc.pairing.dto.excel.input.MemberExcelDto;
import com.kri.p6.ncrc.pairing.dto.excel.input.MemberRegionCodeExcelDto;
import com.kri.p6.ncrc.pairing.dto.excel.input.MunicipalityExcelDto;
import com.kri.p6.ncrc.pairing.dto.excel.input.PairingWorkbookData;
import com.kri.p6.ncrc.pairing.dto.excel.input.PreferenceMatchExcelDto;
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.MemberRegionCode;
import com.kri.p6.ncrc.pairing.model.Municipality;
import com.kri.p6.ncrc.pairing.model.PairingData;
import com.kri.p6.ncrc.pairing.model.PreferenceMatchRule;
import java.time.LocalDate;
import java.time.ZonedDateTime;
import java.time.format.DateTimeParseException;
import java.time.format.DateTimeFormatter;
import java.time.format.DateTimeParseException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.LinkedHashSet;
@@ -41,21 +39,21 @@ public class PairingNormalizeService {
public PairingData normalize(PairingWorkbookData workbookData) {
return PairingData.builder()
.members(workbookData.getMembers().stream().map(this::toMember).toList()).municipalities(
workbookData.getMunicipalities().stream().map(this::toMunicipality).toList())
.centers(workbookData.getCenters().stream().map(this::toCenter).toList()).memberRegionCodes(
workbookData.getMemberRegionCodes().stream().map(this::toMemberRegionCode).toList())
.centerAdjacentRegions(
workbookData.getCenterAdjacentRegions().stream().map(this::toCenterAdjacentRegion)
.toList()).preferenceMatchRules(
workbookData.getPreferenceMatchRules().stream().map(this::toPreferenceMatchRule)
.toList()).commonUnavailableDates(Set.of()).build();
.members(workbookData.getMembers().stream().map(this::toMember).toList())
.municipalities(workbookData.getMunicipalities().stream().map(this::toMunicipality).toList())
.centers(workbookData.getCenters().stream().map(this::toCenter).toList())
.centerAdjacentRegions(workbookData.getCenterAdjacentRegions().stream()
.flatMap(row -> toCenterAdjacentRegions(row).stream())
.toList())
.preferenceMatchRules(workbookData.getPreferenceMatchRules().stream()
.map(this::toPreferenceMatchRule).toList())
.commonUnavailableDates(Set.of())
.build();
}
private Member toMember(MemberExcelDto row) {
return Member.builder().id(required(row.getId(), "위원 id"))
return Member.builder()
.id(required(row.getId(), "위원 id"))
.gender(parseGender(row.getGender()))
.experienceType(parseExperienceType(row.getExperience()))
.role(parseMemberRole(row.getRole()))
@@ -63,70 +61,66 @@ public class PairingNormalizeService {
.availableEndDate(parseDate(row.getAvailableEndDate(), "위원 진행 종료일"))
.unavailableDates(parseDateSet(row.getUnavailableDates(), "위원 진행 불가 일자"))
.activityRegion(normalizeCsvCodes(row.getActivityRegion(), regionCodeLength(), "위원 활동지역"))
.historyCenterIds(parseHistoryCenterIds(row.getHistoryCenters())).residenceCode(
normalizeOptionalCode(row.getResidenceCode(), residenceCodeLength(), "위원 거주지"))
.preferenceRegions(normalizePreferenceRegions(row)).build();
.historyCenterIds(parseHistoryCenterIds(row.getHistoryCenters()))
.residenceCode(normalizeOptionalCode(row.getResidenceCode(), residenceCodeLength(), "위원 거주지"))
.preferenceRegions(normalizePreferenceRegions(row))
.build();
}
private Municipality toMunicipality(MunicipalityExcelDto row) {
return Municipality.builder().id(required(row.getId(), "지자체 id"))
return Municipality.builder()
.id(required(row.getId(), "지자체 id"))
.availableStartDate(parseDate(row.getAvailableStartDate(), "지자체 진행 시작일"))
.availableEndDate(parseDate(row.getAvailableEndDate(), "지자체 진행 종료일"))
.unavailableDates(parseDateSet(row.getUnavailableDates(), "지자체 진행 불가 일자")).build();
.unavailableDates(parseDateSet(row.getUnavailableDates(), "지자체 진행 불가 일자"))
.build();
}
private Center toCenter(CenterExcelDto row) {
return Center.builder().id(required(row.getId(), "센터 id"))
return Center.builder()
.id(required(row.getId(), "센터 id"))
.municipalityId(required(row.getMunicipalityId(), "센터 지자체 id"))
.womenOnly(parseBooleanFlag(row.getWomenOnly(), "센터 여성 위원만"))
.adjacentRegionClassification(
required(row.getAdjacentRegionClassification(), "센터 인접지역 분류"))
.womenOnly(parseBooleanFlag(row.getWomenOnly()))
.adjacentRegionClassification(required(row.getAdjacentRegionClassification(), "센터 인접지역 분류"))
.availableStartDate(parseDate(row.getAvailableStartDate(), "센터 진행 시작일"))
.availableEndDate(parseDate(row.getAvailableEndDate(), "센터 진행 종료일"))
.unavailableDates(parseDateSet(row.getUnavailableDates(), "센터 진행 불가 일자")).build();
.unavailableDates(parseDateSet(row.getUnavailableDates(), "센터 진행 불가 일자"))
.build();
}
private MemberRegionCode toMemberRegionCode(MemberRegionCodeExcelDto row) {
String regionCode = normalizeCode(row.getRegionCode(), regionCodeLength(), "권역코드");
String detailRegionCode = normalizeCode(row.getDetailRegionCode(), 1, "세부권역코드");
String detailAreaCode = normalizeCode(row.getDetailAreaCode(), 2, "세부지역코드");
return MemberRegionCode.builder().sido(clean(row.getSido()))
.sigungu(clean(row.getSigungu())).regionCode(regionCode)
.detailRegionCode(detailRegionCode).detailAreaCode(detailAreaCode).fullRegionCode(
normalizeFullRegionCode(row.getFullRegionCode(), regionCode, detailRegionCode,
detailAreaCode)).build();
}
private CenterAdjacentRegion toCenterAdjacentRegion(CenterAdjacentRegionExcelDto row) {
return CenterAdjacentRegion.builder().dispatchRegion(
normalizeCode(row.getDispatchRegion(), regionCodeLength(), "센터 인접지역표 권역"))
.adjacentRegionClassification(
required(row.getAdjacentRegionClassification(), "인접지역 분류")).build();
private List<CenterAdjacentRegion> toCenterAdjacentRegions(CenterAdjacentRegionExcelDto row) {
String adjacentRegionClassification = required(row.getAdjacentRegionClassification(), "인접지역 분류");
return parseCsv(row.getDispatchRegion()).stream()
.map(dispatchRegion -> CenterAdjacentRegion.builder()
.dispatchRegion(normalizeCode(dispatchRegion, regionCodeLength(), "파견 권역"))
.adjacentRegionClassification(adjacentRegionClassification)
.build())
.toList();
}
private PreferenceMatchRule toPreferenceMatchRule(PreferenceMatchExcelDto row) {
return PreferenceMatchRule.builder().priority(parseInt(row.getPriority(), "매칭 순위"))
return PreferenceMatchRule.builder()
.priority(parseInt(row.getPriority(), "매칭 순위"))
.fieldMemberPreferenceRank(parseInt(row.getFieldMemberPreferenceRank(), "현장위원 선호 순위"))
.externalMemberPreferenceRank(
parseInt(row.getExternalMemberPreferenceRank(), "외부위원 선호 순위")).build();
.externalMemberPreferenceRank(parseInt(row.getExternalMemberPreferenceRank(), "외부위원 선호 순위"))
.build();
}
private List<String> normalizePreferenceRegions(MemberExcelDto row) {
List<String> preferences = new ArrayList<>(Arrays.asList(
normalizeCode(row.getPreferenceRegion1(), regionCodeLength(), "선호 지역1"),
normalizeCode(row.getPreferenceRegion2(), regionCodeLength(), "선호 지역2"),
normalizeCode(row.getPreferenceRegion3(), regionCodeLength(), "선호 지역3"),
normalizeCode(row.getPreferenceRegion4(), regionCodeLength(), "선호 지역4")));
normalizeCode(row.getPreferenceRegion1(), regionCodeLength(), "선호 지역"),
normalizeCode(row.getPreferenceRegion2(), regionCodeLength(), "선호 지역"),
normalizeCode(row.getPreferenceRegion3(), regionCodeLength(), "선호 지역"),
normalizeCode(row.getPreferenceRegion4(), regionCodeLength(), "선호 지역")));
boolean anyRegionAppeared = false;
for (int i = 0; i < preferences.size(); ++i) {
for (int i = 0; i < preferences.size(); i++) {
if (anyRegionAppeared) {
preferences.set(i, anyRegionCode());
} else if (anyRegionCode().equals(preferences.get(i))) {
anyRegionAppeared = true;
}
}
return preferences;
}
@@ -135,43 +129,45 @@ public class PairingNormalizeService {
if ("여성".equals(cleaned) || "여".equals(cleaned) || "F".equalsIgnoreCase(cleaned)
|| "FEMALE".equalsIgnoreCase(cleaned)) {
return Gender.FEMALE;
} else if ("남성".equals(cleaned) || "남".equals(cleaned) || "M".equalsIgnoreCase(cleaned)
}
if ("남성".equals(cleaned) || "남".equals(cleaned) || "M".equalsIgnoreCase(cleaned)
|| "MALE".equalsIgnoreCase(cleaned)) {
return Gender.MALE;
} else {
}
throw BusinessException.badRequest("PAIRING_INVALID_GENDER", "성별 값이 올바르지 않습니다: " + value);
}
}
private ExperienceType parseExperienceType(String value) {
String cleaned = required(value, "경력 여부");
if ("경력".equals(cleaned) || "경력자".equals(cleaned)
|| "EXPERIENCED".equalsIgnoreCase(cleaned)) {
return ExperienceType.EXPERIENCED;
} else if ("신규".equals(cleaned) || "NEW".equalsIgnoreCase(cleaned)) {
}
if ("신규".equals(cleaned) || "NEW".equalsIgnoreCase(cleaned)) {
return ExperienceType.NEW;
} else {
}
throw BusinessException.badRequest("PAIRING_INVALID_EXPERIENCE",
"경력 여부 값이 올바르지 않습니다: " + value);
}
}
private MemberRole parseMemberRole(String value) {
String cleaned = required(value, "현장/외부 구분");
if ("현장".equals(cleaned) || "FIELD".equalsIgnoreCase(cleaned)) {
return MemberRole.FIELD;
} else if ("외부".equals(cleaned) || "EXTERNAL".equalsIgnoreCase(cleaned)) {
}
if ("외부".equals(cleaned) || "EXTERNAL".equalsIgnoreCase(cleaned)) {
return MemberRole.EXTERNAL;
} else {
}
throw BusinessException.badRequest("PAIRING_INVALID_MEMBER_ROLE",
"현장/외부 구분 값이 올바르지 않습니다: " + value);
}
private boolean parseBooleanFlag(String value) {
return "1".equals(required(value, "여성위원만"));
}
private boolean parseBooleanFlag(String value, String fieldName) {
String cleaned = required(value, fieldName);
return "1".equals(cleaned);
}
private LocalDate parseDate(String value, String fieldName) {
String cleaned = required(value, fieldName);
try {
return LocalDate.parse(cleaned);
} catch (DateTimeParseException ignored) {
@@ -202,14 +198,6 @@ public class PairingNormalizeService {
return cleaned.startsWith("=") || cleaned.matches("[A-Za-z]+\\(.*");
}
private Set<String> parseCsv(String value) {
String cleaned = clean(value);
return (cleaned.isBlank() ? new LinkedHashSet<>()
: Arrays.stream(cleaned.split(",")).map(String::trim)
.filter(token -> !token.isBlank())
.collect(Collectors.toCollection(LinkedHashSet::new)));
}
private Set<String> parseHistoryCenterIds(String value) {
return parseCsv(value).stream()
.map(this::normalizeExcelIdText)
@@ -226,10 +214,9 @@ public class PairingNormalizeService {
private int parseInt(String value, String fieldName) {
String cleaned = required(value, fieldName);
try {
return Integer.parseInt(cleaned);
} catch (NumberFormatException var5) {
} catch (NumberFormatException e) {
throw BusinessException.badRequest("PAIRING_INVALID_NUMBER",
fieldName + " 숫자 형식이 올바르지 않습니다: " + value);
}
@@ -240,16 +227,15 @@ public class PairingNormalizeService {
if (cleaned.endsWith(".0")) {
cleaned = cleaned.substring(0, cleaned.length() - 2);
}
if (!cleaned.matches("\\d+")) {
throw BusinessException.badRequest("PAIRING_INVALID_CODE",
fieldName + " 코드는 숫자만 허용됩니다: " + value);
} else if (cleaned.length() > length) {
fieldName + " 코드는 숫자만 허용합니다: " + value);
}
if (cleaned.length() > length) {
throw BusinessException.badRequest("PAIRING_INVALID_CODE",
fieldName + " 코드 길이가 올바르지 않습니다: " + value);
} else {
return cleaned.length() == length ? cleaned : "0".repeat(length - cleaned.length()) + cleaned;
}
return cleaned.length() == length ? cleaned : "0".repeat(length - cleaned.length()) + cleaned;
}
private String normalizeOptionalCode(String value, int length, String fieldName) {
@@ -263,11 +249,15 @@ public class PairingNormalizeService {
.collect(Collectors.joining(","));
}
private String normalizeFullRegionCode(String value, String regionCode, String detailRegionCode,
String detailAreaCode) {
private Set<String> parseCsv(String value) {
String cleaned = clean(value);
return cleaned.matches("\\d+") ? normalizeCode(cleaned, 5, "지역 코드")
: regionCode + detailRegionCode + detailAreaCode;
if (cleaned.isBlank()) {
return new LinkedHashSet<>();
}
return Arrays.stream(cleaned.split(","))
.map(String::trim)
.filter(token -> !token.isBlank())
.collect(Collectors.toCollection(LinkedHashSet::new));
}
private String required(String value, String fieldName) {
@@ -275,9 +265,8 @@ public class PairingNormalizeService {
if (cleaned.isBlank()) {
throw BusinessException.badRequest("PAIRING_REQUIRED_VALUE_MISSING",
"필수 값이 없습니다: " + fieldName);
} else {
return cleaned;
}
return cleaned;
}
private String clean(String value) {
@@ -295,5 +284,4 @@ public class PairingNormalizeService {
private String anyRegionCode() {
return pairingProperties.getCode().getAnyRegionCode();
}
}

View File

@@ -3,7 +3,6 @@ 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;
import org.springframework.stereotype.Service;
import org.springframework.web.multipart.MultipartFile;
@@ -16,18 +15,8 @@ public class PairingService {
private final PairingNormalizeService pairingNormalizeService;
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);
PairingData pairingData = pairingNormalizeService.normalize(workbookData);
pairingData = pairingHolidayService.applyHolidayUnavailableDates(pairingData);
pairingValidationService.validate(pairingData);
PairingResult result = pairingScheduleService.schedule(pairingData);
return pairingExcelService.write(result);
}
public byte[] pairingMemberByCenterNew(MultipartFile file) {
PairingWorkbookData workbookData = pairingExcelService.read(file);
PairingData pairingData = pairingNormalizeService.normalize(workbookData);

View File

@@ -1,808 +0,0 @@
package com.kri.p6.ncrc.pairing.service;
import com.google.ortools.Loader;
import com.google.ortools.sat.BoolVar;
import com.google.ortools.sat.CpModel;
import com.google.ortools.sat.CpSolver;
import com.google.ortools.sat.CpSolverStatus;
import com.google.ortools.sat.LinearArgument;
import com.google.ortools.sat.LinearExpr;
import com.kri.p6.ncrc.pairing.common.enums.ExperienceType;
import com.kri.p6.ncrc.pairing.common.enums.Gender;
import com.kri.p6.ncrc.pairing.config.PairingProperties;
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.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.model.ABPairMatch;
import com.kri.p6.ncrc.pairing.model.AssignmentCandidate;
import com.kri.p6.ncrc.pairing.model.Center;
import com.kri.p6.ncrc.pairing.model.Member;
import com.kri.p6.ncrc.pairing.model.PairingCandidates;
import com.kri.p6.ncrc.pairing.model.PairingData;
import com.kri.p6.ncrc.pairing.model.PairingResult;
import java.time.LocalDate;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Comparator;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.Set;
import java.util.function.Function;
import java.util.stream.Collectors;
import java.util.stream.Stream;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Service;
@Service
@RequiredArgsConstructor
public class PairingSolverService {
private final PairingProperties pairingProperties;
public PairingResult solve(PairingData data, PairingCandidates candidates) {
SolveSelection selection = select(candidates);
if (!selection.hasSolution()) {
return emptyResult(data, candidates, selection.status());
}
return toResult(data, candidates, selection.selectedAssignments(), selection.status(), Set.of());
}
public SolveSelection select(PairingCandidates candidates) {
return select(candidates, Map.of());
}
public SolveSelection select(PairingCandidates candidates,
Map<String, Set<String>> existingCounterpartsByMember) {
return select(candidates, existingCounterpartsByMember, Map.of());
}
public SolveSelection select(PairingCandidates candidates,
Map<String, Set<String>> existingCounterpartsByMember,
Map<String, Integer> visitCountsByMember) {
if (candidates.getAssignmentCandidates().isEmpty()) {
return new SolveSelection(false, List.of(), "배정 가능한 후보가 없습니다.");
}
CpModel model = new CpModel();
List<AssignmentCandidate> assignmentCandidates = candidates.getAssignmentCandidates();
// CP-SAT에서는 각 배정 후보를 0/1 변수로 봅니다.
// 1이면 해당 후보 선택, 0이면 미선택입니다.
BoolVar[] assignmentVars = createAssignmentVars(model, assignmentCandidates);
Map<String, BoolVar> pairUsedVars = createPairUsedVars(model, assignmentCandidates);
Map<String, BoolVar> pairDayVars = createPairDayVars(model, assignmentCandidates);
Map<String, BoolVar> pairDayAdjacentVars = createPairDayAdjacentVars(model, assignmentCandidates);
// 현재 메인 배정은 Greedy가 담당하지만, CP-SAT 모델은 부분 최적화와 기존 방식 호환을 위해 유지합니다.
linkHelperVars(model, assignmentCandidates, assignmentVars, pairUsedVars, pairDayVars, pairDayAdjacentVars);
addCenterAssignedAtMostOnce(model, assignmentCandidates, assignmentVars);
addPairDailyCapacity(model, assignmentCandidates, assignmentVars);
addMemberDailyOnePair(model, assignmentCandidates, pairDayVars);
addPairDailyOneAdjacentClassification(model, assignmentCandidates, pairDayAdjacentVars);
addCumulativeBuddyLimit(model, assignmentCandidates, pairUsedVars,
existingCounterpartsByMember);
model.maximize(createObjective(assignmentCandidates, assignmentVars, visitCountsByMember));
CpSolver solver = new CpSolver();
solver.getParameters().setMaxTimeInSeconds(pairingProperties.getSolver().getMaxTimeSeconds());
solver.getParameters().setNumSearchWorkers(pairingProperties.getSolver().getNumSearchWorkers());
CpSolverStatus status = solver.solve(model);
if (status != CpSolverStatus.OPTIMAL && status != CpSolverStatus.FEASIBLE) {
return new SolveSelection(false, List.of(), "solver가 feasible 해를 찾지 못했습니다: " + status);
}
return new SolveSelection(true, collectSelectedAssignments(assignmentCandidates, assignmentVars, solver), status.name());
}
public PairingResult buildResult(PairingData data, PairingCandidates candidates,
List<AssignmentCandidate> selectedAssignments, String status) {
return toResult(data, candidates, selectedAssignments, status, Set.of());
}
public PairingResult buildResult(PairingData data, PairingCandidates candidates,
List<AssignmentCandidate> selectedAssignments, String status, Set<String> pairedMemberIds) {
return toResult(data, candidates, selectedAssignments, status, pairedMemberIds);
}
private BoolVar[] createAssignmentVars(CpModel model, List<AssignmentCandidate> candidates) {
BoolVar[] vars = new BoolVar[candidates.size()];
for (int i = 0; i < candidates.size(); i++) {
vars[i] = model.newBoolVar("assign_" + i + "_" + candidates.get(i).getCenterId());
}
return vars;
}
private Map<String, BoolVar> createPairUsedVars(CpModel model, List<AssignmentCandidate> candidates) {
return candidates.stream().map(this::pairKey).distinct()
.collect(Collectors.toMap(Function.identity(), key -> model.newBoolVar("pair_used_" + key)));
}
private Map<String, BoolVar> createPairDayVars(CpModel model, List<AssignmentCandidate> candidates) {
return candidates.stream().map(this::pairDayKey).distinct()
.collect(Collectors.toMap(Function.identity(), key -> model.newBoolVar("pair_day_" + key)));
}
private Map<String, BoolVar> createPairDayAdjacentVars(CpModel model, List<AssignmentCandidate> candidates) {
return candidates.stream().map(this::pairDayAdjacentKey).distinct()
.collect(Collectors.toMap(Function.identity(), key -> model.newBoolVar("pair_day_adjacent_" + key)));
}
private void linkHelperVars(CpModel model, List<AssignmentCandidate> candidates,
BoolVar[] assignmentVars, Map<String, BoolVar> pairUsedVars, Map<String, BoolVar> pairDayVars,
Map<String, BoolVar> pairDayAdjacentVars) {
for (int i = 0; i < candidates.size(); i++) {
AssignmentCandidate candidate = candidates.get(i);
model.addLessOrEqual(assignmentVars[i], pairUsedVars.get(pairKey(candidate)));
model.addLessOrEqual(assignmentVars[i], pairDayVars.get(pairDayKey(candidate)));
model.addLessOrEqual(assignmentVars[i], pairDayAdjacentVars.get(pairDayAdjacentKey(candidate)));
}
}
private void addCenterAssignedAtMostOnce(CpModel model, List<AssignmentCandidate> candidates,
BoolVar[] assignmentVars) {
// 하나의 센터는 최대 1번만 배정됩니다.
groupIndexes(candidates, AssignmentCandidate::getCenterId).values()
.forEach(indexes -> model.addAtMostOne(toLiteralArray(indexes, assignmentVars)));
}
private void addPairDailyCapacity(CpModel model, List<AssignmentCandidate> candidates,
BoolVar[] assignmentVars) {
// 같은 조가 하루에 방문할 수 있는 센터 수 상한입니다.
groupIndexes(candidates, this::pairDayKey).values().forEach(indexes -> model.addLessOrEqual(
LinearExpr.sum(toLinearArgumentArray(indexes, assignmentVars)),
pairingProperties.getRule().getMaxCentersPerPairPerDay()));
}
private void addMemberDailyOnePair(CpModel model, List<AssignmentCandidate> candidates,
Map<String, BoolVar> pairDayVars) {
// 한 위원은 같은 날짜에 여러 조로 동시에 활동할 수 없습니다.
Map<String, Set<String>> pairDayKeysByMemberDay = candidates.stream()
.collect(Collectors.groupingBy(candidate -> candidate.getFieldMemberId() + "|" + candidate.getDate(),
Collectors.mapping(this::pairDayKey, Collectors.toSet())));
Map<String, Set<String>> externalPairDayKeysByMemberDay = candidates.stream()
.collect(Collectors.groupingBy(candidate -> candidate.getExternalMemberId() + "|" + candidate.getDate(),
Collectors.mapping(this::pairDayKey, Collectors.toSet())));
externalPairDayKeysByMemberDay.forEach((key, value) -> pairDayKeysByMemberDay.merge(key, value, (left, right) -> {
left.addAll(right);
return left;
}));
pairDayKeysByMemberDay.values().forEach(pairDayKeys ->
model.addAtMostOne(pairDayKeys.stream().map(pairDayVars::get).toArray(BoolVar[]::new)));
}
private void addPairDailyOneAdjacentClassification(CpModel model,
List<AssignmentCandidate> candidates, Map<String, BoolVar> pairDayAdjacentVars) {
// 같은 조/같은 날짜에는 하나의 인접지역 분류만 방문합니다.
Map<String, Set<String>> adjacentKeysByPairDay = candidates.stream()
.collect(Collectors.groupingBy(this::pairDayKey,
Collectors.mapping(this::pairDayAdjacentKey, Collectors.toSet())));
adjacentKeysByPairDay.values().forEach(adjacentKeys ->
model.addAtMostOne(adjacentKeys.stream().map(pairDayAdjacentVars::get).toArray(BoolVar[]::new)));
}
private void addCumulativeBuddyLimit(CpModel model, List<AssignmentCandidate> candidates,
Map<String, BoolVar> pairUsedVars, Map<String, Set<String>> existingCounterpartsByMember) {
// 위원 1명당 누적 상대 위원 수 제한입니다. 현재 업무 기준은 application.yaml의 max-counterparts-per-member입니다.
Map<String, Set<String>> pairKeysByMember = candidates.stream()
.collect(Collectors.groupingBy(AssignmentCandidate::getFieldMemberId,
Collectors.mapping(this::pairKey, Collectors.toSet())));
Map<String, Set<String>> externalPairKeysByMember = candidates.stream()
.collect(Collectors.groupingBy(AssignmentCandidate::getExternalMemberId,
Collectors.mapping(this::pairKey, Collectors.toSet())));
externalPairKeysByMember.forEach((key, value) -> pairKeysByMember.merge(key, value, (left, right) -> {
left.addAll(right);
return left;
}));
pairKeysByMember.forEach((memberId, pairKeys) -> {
Set<String> existingCounterparts = existingCounterpartsByMember.getOrDefault(memberId,
Set.of());
List<BoolVar> newCounterpartVars = pairKeys.stream()
.filter(pairKey -> !existingCounterparts.contains(counterpartId(pairKey, memberId)))
.map(pairUsedVars::get)
.toList();
if (newCounterpartVars.isEmpty()) {
return;
}
int remainingNewCounterpartSlots = Math.max(0,
pairingProperties.getRule().getMaxCounterpartsPerMember() - existingCounterparts.size());
model.addLessOrEqual(
LinearExpr.sum(newCounterpartVars.toArray(LinearArgument[]::new)),
remainingNewCounterpartSlots);
});
}
private LinearExpr createObjective(List<AssignmentCandidate> candidates,
BoolVar[] assignmentVars, Map<String, Integer> visitCountsByMember) {
// soft rule 점수입니다. 센터를 많이 배정하는 점수가 가장 크고,
// 희망지역/거주지/방문 균형은 같은 배정 수 안에서 우열을 정하는 보조 점수입니다.
List<LinearArgument> vars = new ArrayList<>();
List<Long> weights = new ArrayList<>();
for (int i = 0; i < assignmentVars.length; i++) {
AssignmentCandidate candidate = candidates.get(i);
vars.add(assignmentVars[i]);
weights.add(pairingProperties.getObjective().getAssignmentWeight()
+ Math.max(0L, pairingProperties.getObjective().getPreferenceBaseWeight()
- candidate.getPreferencePriority() * pairingProperties.getObjective().getPreferenceRankPenalty())
+ candidate.getResidenceMatchScore() * pairingProperties.getObjective().getResidenceMatchWeight()
- memberBalancePenalty(candidate, visitCountsByMember));
}
return LinearExpr.weightedSum(vars.toArray(LinearArgument[]::new),
weights.stream().mapToLong(Long::longValue).toArray());
}
private long memberBalancePenalty(AssignmentCandidate candidate,
Map<String, Integer> visitCountsByMember) {
return (long) (visitCountsByMember.getOrDefault(candidate.getFieldMemberId(), 0)
+ visitCountsByMember.getOrDefault(candidate.getExternalMemberId(), 0))
* pairingProperties.getObjective().getMemberBalanceWeight();
}
private List<AssignmentCandidate> collectSelectedAssignments(List<AssignmentCandidate> candidates,
BoolVar[] assignmentVars, CpSolver solver) {
List<AssignmentCandidate> selected = new ArrayList<>();
for (int i = 0; i < candidates.size(); i++) {
if (solver.booleanValue(assignmentVars[i])) {
selected.add(candidates.get(i));
}
}
selected.sort(Comparator.comparing(AssignmentCandidate::getDate)
.thenComparing(AssignmentCandidate::getFieldMemberId)
.thenComparing(AssignmentCandidate::getCenterId));
return selected;
}
private PairingResult toResult(PairingData data, PairingCandidates candidates,
List<AssignmentCandidate> selectedAssignments, String status, Set<String> pairedMemberIds) {
Set<String> assignedCenterIds = selectedAssignments.stream().map(AssignmentCandidate::getCenterId).collect(Collectors.toSet());
Set<String> usedMemberIds = selectedAssignments.stream()
.flatMap(candidate -> Stream.of(candidate.getFieldMemberId(), candidate.getExternalMemberId()))
.collect(Collectors.toSet());
usedMemberIds.addAll(pairedMemberIds);
Map<String, Member> memberMap = data.getMembers().stream()
.collect(Collectors.toMap(Member::getId, Function.identity(), (left, right) -> left));
Map<String, Center> centerMap = data.getCenters().stream()
.collect(Collectors.toMap(Center::getId, Function.identity(), (left, right) -> left));
ABPairBuildResult abPairBuildResult = createABPairMatches(selectedAssignments);
Map<String, ABPairMatch> abPairMatches = abPairBuildResult.matches();
List<AssignmentResultExcelDto> assignments = selectedAssignments.stream()
.map(candidate -> toAssignmentResult(candidate, memberMap, centerMap, abPairMatches))
.toList();
List<UnassignedCenterExcelDto> unassignedCenters = data.getCenters().stream()
.filter(center -> !assignedCenterIds.contains(center.getId()))
.map(center -> toUnassignedCenter(center, candidates.getUnassignedCenterReasons()))
.toList();
List<UnusedMemberExcelDto> unusedMembers = data.getMembers().stream()
.filter(member -> !usedMemberIds.contains(member.getId()))
.map(member -> new UnusedMemberExcelDto(member.getId(), member.getRole().name(),
"최종 배정에 포함되지 않았습니다. 후보 부족 또는 제약 충돌 가능"))
.toList();
return PairingResult.builder()
.assignments(assignments)
.unassignedCenters(unassignedCenters)
.unusedMembers(unusedMembers)
.summaries(createSummaries(data, candidates, assignments.size(), unassignedCenters.size(),
unusedMembers.size(), countABGroups(abPairMatches), status))
.abPairs(abPairBuildResult.rows())
.candidateSummaries(createCandidateSummaries(data, candidates, assignments.size(),
unassignedCenters.size(), unusedMembers.size(), countABGroups(abPairMatches)))
.appliedSettings(createAppliedSettings())
.validationErrors(List.of())
.ruleViolations(createRuleChecks(data, selectedAssignments, abPairMatches, pairedMemberIds))
.build();
}
private PairingResult emptyResult(PairingData data, PairingCandidates candidates, String reason) {
return PairingResult.builder()
.assignments(List.of())
.unassignedCenters(data.getCenters().stream()
.map(center -> new UnassignedCenterExcelDto(center.getId(), center.getMunicipalityId(), reason))
.toList())
.unusedMembers(data.getMembers().stream()
.map(member -> new UnusedMemberExcelDto(member.getId(), member.getRole().name(), reason))
.toList())
.summaries(createSummaries(data, candidates, 0, data.getCenters().size(), data.getMembers().size(), 0, reason))
.abPairs(List.of())
.candidateSummaries(createCandidateSummaries(data, candidates, 0, data.getCenters().size(), data.getMembers().size(), 0))
.appliedSettings(createAppliedSettings())
.validationErrors(List.of())
.ruleViolations(List.of(new RuleViolationExcelDto("solver feasible 해", "FAIL", reason)))
.build();
}
private AssignmentResultExcelDto toAssignmentResult(AssignmentCandidate candidate,
Map<String, Member> memberMap, Map<String, Center> centerMap,
Map<String, ABPairMatch> abPairMatches) {
Member fieldMember = memberMap.get(candidate.getFieldMemberId());
Member externalMember = memberMap.get(candidate.getExternalMemberId());
Center center = centerMap.get(candidate.getCenterId());
ABPairMatch abPairMatch = abPairMatches.get(pairKey(candidate));
return new AssignmentResultExcelDto(candidate.getDate().toString(),
candidate.getFieldMemberId(), formatGender(fieldMember.getGender()),
formatExperience(fieldMember.getExperienceType()), fieldMember.getResidenceCode(),
fieldMember.getActivityRegion(), formatPreferenceRank(candidate.getFieldMemberPreferenceRank()),
candidate.getExternalMemberId(), formatGender(externalMember.getGender()),
formatExperience(externalMember.getExperienceType()), externalMember.getResidenceCode(),
externalMember.getActivityRegion(), formatPreferenceRank(candidate.getExternalMemberPreferenceRank()),
candidate.getCenterId(), candidate.getMunicipalityId(), center.isWomenOnly() ? "1" : "0",
candidate.getDispatchRegion(), candidate.getAdjacentRegionClassification(),
String.valueOf(candidate.getPreferencePriority()),
abPairMatch == null ? "" : abPairMatch.getGroupId(),
abPairMatch == null ? "" : abPairMatch.getCounterpartFieldMemberId(),
abPairMatch == null ? "" : abPairMatch.getCounterpartExternalMemberId());
}
private UnassignedCenterExcelDto toUnassignedCenter(Center center, Map<String, Set<String>> reasonMap) {
Set<String> reasons = new LinkedHashSet<>(reasonMap == null ? Set.of()
: reasonMap.getOrDefault(center.getId(), Set.of()));
reasons.add("solver 최적화에서 선택되지 않음");
return new UnassignedCenterExcelDto(center.getId(), center.getMunicipalityId(), String.join(", ", reasons));
}
private String formatGender(Gender gender) {
return gender == Gender.FEMALE ? "여" : "남";
}
private String formatExperience(ExperienceType experienceType) {
return experienceType == ExperienceType.EXPERIENCED ? "경력" : "신규";
}
private String formatPreferenceRank(int rank) {
if (rank == 0) {
return "00";
}
return rank == 99 ? "99" : String.valueOf(rank);
}
private List<PairingSummaryExcelDto> createSummaries(PairingData data,
PairingCandidates candidates, int assignmentCount, int unassignedCenterCount,
int unusedMemberCount, int abGroupCount, String status) {
return List.of(
new PairingSummaryExcelDto("위원 수", String.valueOf(data.getMembers().size())),
new PairingSummaryExcelDto("지자체 수", String.valueOf(data.getMunicipalities().size())),
new PairingSummaryExcelDto("센터 수", String.valueOf(data.getCenters().size())),
new PairingSummaryExcelDto("페어 후보 수", String.valueOf(candidates.getPairCandidates().size())),
new PairingSummaryExcelDto("파견 권역 후보 수", String.valueOf(candidates.getDispatchRegionCandidates().size())),
new PairingSummaryExcelDto("배정 후보 수", String.valueOf(candidates.getAssignmentCandidates().size())),
new PairingSummaryExcelDto("배정 센터 수", String.valueOf(assignmentCount)),
new PairingSummaryExcelDto("미배정 센터 수", String.valueOf(unassignedCenterCount)),
new PairingSummaryExcelDto("미사용 위원 수", String.valueOf(unusedMemberCount)),
new PairingSummaryExcelDto("AB 그룹 수", String.valueOf(abGroupCount)),
new PairingSummaryExcelDto("처리 상태", status));
}
private ABPairBuildResult createABPairMatches(List<AssignmentCandidate> selectedAssignments) {
Map<String, List<AssignmentCandidate>> assignmentsByPair = selectedAssignments.stream()
.collect(Collectors.groupingBy(this::pairKey));
List<UsedPair> usedPairs = assignmentsByPair.entrySet().stream()
.map(entry -> UsedPair.of(entry.getKey(), entry.getValue()))
.sorted(Comparator.comparing(UsedPair::pairKey))
.toList();
Map<String, ABPairMatch> matches = new HashMap<>();
List<ABPairExcelDto> rows = new ArrayList<>();
Set<String> alreadyMatched = new HashSet<>();
int groupSequence = 1;
for (UsedPair pair : usedPairs) {
if (alreadyMatched.contains(pair.pairKey())) {
continue;
}
UsedPair counterpart = usedPairs.stream()
.filter(candidate -> !alreadyMatched.contains(candidate.pairKey()))
.filter(candidate -> !candidate.pairKey().equals(pair.pairKey()))
.filter(pair::canBeABWith)
.findFirst()
.orElse(null);
if (counterpart == null) {
continue;
}
String groupId = "AB-" + String.format("%03d", groupSequence++);
matches.put(pair.pairKey(), toABPairMatch(groupId, pair, counterpart));
matches.put(counterpart.pairKey(), toABPairMatch(groupId, counterpart, pair));
rows.add(toABPairRow(groupId, pair, counterpart));
alreadyMatched.add(pair.pairKey());
alreadyMatched.add(counterpart.pairKey());
}
return new ABPairBuildResult(matches, rows);
}
private ABPairMatch toABPairMatch(String groupId, UsedPair pair, UsedPair counterpart) {
return ABPairMatch.builder()
.groupId(groupId)
.fieldMemberId(pair.fieldMemberId())
.externalMemberId(pair.externalMemberId())
.counterpartFieldMemberId(counterpart.fieldMemberId())
.counterpartExternalMemberId(counterpart.externalMemberId())
.build();
}
private int countABGroups(Map<String, ABPairMatch> matches) {
return (int) matches.values().stream().map(ABPairMatch::getGroupId).distinct().count();
}
private ABPairExcelDto toABPairRow(String groupId, UsedPair pair, UsedPair counterpart) {
Set<String> counterpartDispatchRegions = counterpart.dispatchRegions();
String sharedDispatchRegion = pair.dispatchRegions().stream()
.filter(counterpartDispatchRegions::contains)
.sorted()
.findFirst()
.orElse("");
boolean dateOverlapped = pair.dates().stream().anyMatch(counterpart.dates()::contains);
return new ABPairExcelDto(groupId, pair.fieldMemberId(), pair.externalMemberId(),
counterpart.fieldMemberId(), counterpart.externalMemberId(), sharedDispatchRegion,
formatDates(pair.dates()), formatDates(counterpart.dates()), dateOverlapped ? "Y" : "N");
}
private List<CandidateSummaryExcelDto> createCandidateSummaries(PairingData data,
PairingCandidates candidates, int assignmentCount, int unassignedCenterCount,
int unusedMemberCount, int abGroupCount) {
long fieldMemberCount = data.getMembers().stream().filter(member -> member.getRole().name().equals("FIELD")).count();
long externalMemberCount = data.getMembers().stream().filter(member -> member.getRole().name().equals("EXTERNAL")).count();
long womenOnlyCenterCount = data.getCenters().stream().filter(Center::isWomenOnly).count();
long noCandidateCenterCount = data.getCenters().stream()
.filter(center -> candidates.getAssignmentCandidates().stream()
.noneMatch(candidate -> candidate.getCenterId().equals(center.getId())))
.count();
return List.of(
new CandidateSummaryExcelDto("전체 위원 수", String.valueOf(data.getMembers().size()), "입력 위원 수"),
new CandidateSummaryExcelDto("현장위원 수", String.valueOf(fieldMemberCount), "현장위원 입력 수"),
new CandidateSummaryExcelDto("외부위원 수", String.valueOf(externalMemberCount), "외부위원 입력 수"),
new CandidateSummaryExcelDto("센터 수", String.valueOf(data.getCenters().size()), "입력 센터 수"),
new CandidateSummaryExcelDto("여성 전용 센터 수", String.valueOf(womenOnlyCenterCount), "여성 위원만 가능한 센터 수"),
new CandidateSummaryExcelDto("공통 불가일 수", String.valueOf(commonUnavailableDates(data).size()), "배정 제외 공통 불가능 일자 수"),
new CandidateSummaryExcelDto("페어 후보 수", String.valueOf(candidates.getPairCandidates().size()), "현장+외부 조합 후보 수"),
new CandidateSummaryExcelDto("파견 권역 후보 수", String.valueOf(candidates.getDispatchRegionCandidates().size()), "페어별 파견 권역 후보 수"),
new CandidateSummaryExcelDto("배정 후보 수", String.valueOf(candidates.getAssignmentCandidates().size()), "solver 입력 배정 후보 수"),
new CandidateSummaryExcelDto("후보 없는 센터 수", String.valueOf(noCandidateCenterCount), "배정 후보가 하나도 없는 센터 수"),
new CandidateSummaryExcelDto("배정 센터 수", String.valueOf(assignmentCount), "최종 배정된 센터 수"),
new CandidateSummaryExcelDto("미배정 센터 수", String.valueOf(unassignedCenterCount), "최종 미배정 센터 수"),
new CandidateSummaryExcelDto("미사용 위원 수", String.valueOf(unusedMemberCount), "최종 배정에 포함되지 않은 위원 수"),
new CandidateSummaryExcelDto("AB 그룹 수", String.valueOf(abGroupCount), "후처리로 구성된 AB 그룹 수"));
}
private List<AppliedSettingExcelDto> createAppliedSettings() {
PairingProperties.Excel excel = pairingProperties.getExcel();
PairingProperties.Code code = pairingProperties.getCode();
PairingProperties.Rule rule = pairingProperties.getRule();
PairingProperties.Preference preference = pairingProperties.getPreference();
PairingProperties.Objective objective = pairingProperties.getObjective();
PairingProperties.Candidate candidate = pairingProperties.getCandidate();
PairingProperties.Solver solver = pairingProperties.getSolver();
return List.of(
setting("pairing.excel.header-row-index",
"엑셀 헤더로 사용할 행 인덱스",
excel.getHeaderRowIndex()),
setting("pairing.code.region-code-length",
"지역코드 정규화 길이", code.getRegionCodeLength()),
setting("pairing.code.residence-code-length",
"거주지코드 정규화 길이",
code.getResidenceCodeLength()),
setting("pairing.code.residence-match-prefix-length",
"거주지 일치 판단에 사용하는 앞자리 길이",
code.getResidenceMatchPrefixLength()),
setting("pairing.code.any-region-code",
"희망지역 anywhere로 처리하는 코드",
code.getAnyRegionCode()),
setting("pairing.rule.max-centers-per-pair-per-day",
"페어가 하루에 방문할 수 있는 최대 센터 수",
rule.getMaxCentersPerPairPerDay()),
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를 의미하는 순위",
preference.getAnywhereRank()),
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 후보에 추가할 점수",
preference.getWildcardFallbackScoreBonus()),
setting("pairing.objective.assignment-weight",
"센터 하나를 더 배정하는 것에 부여하는 기본 점수",
objective.getAssignmentWeight()),
setting("pairing.objective.preference-base-weight",
"희망지역 매칭 품질에 부여하는 기본 점수",
objective.getPreferenceBaseWeight()),
setting("pairing.objective.preference-rank-penalty",
"희망순위가 낮아질 때 감점하는 점수",
objective.getPreferenceRankPenalty()),
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이면 무제한",
candidate.getMaxPairCandidatesPerMember()),
setting("pairing.candidate.max-dispatch-regions-per-pair",
"페어별 파견 권역 후보 축소 상한, 0이면 무제한",
candidate.getMaxDispatchRegionsPerPair()),
setting("pairing.candidate.max-assignments-per-center",
"센터별 배정 후보 축소 상한",
candidate.getMaxAssignmentsPerCenter()),
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 사용 시 허용할 최대 탐색 시간",
solver.getMaxTimeSeconds()),
setting("pairing.solver.num-search-workers",
"CP-SAT 사용 시 사용할 worker 수",
solver.getNumSearchWorkers())
);
}
private AppliedSettingExcelDto setting(String name, String description, Object value) {
return new AppliedSettingExcelDto(name, description, String.valueOf(value));
}
private List<RuleViolationExcelDto> createRuleChecks(PairingData data,
List<AssignmentCandidate> selectedAssignments, Map<String, ABPairMatch> abPairMatches,
Set<String> pairedMemberIds) {
Map<String, Member> memberMap = data.getMembers().stream()
.collect(Collectors.toMap(Member::getId, Function.identity(), (left, right) -> left));
Map<String, Center> centerMap = data.getCenters().stream()
.collect(Collectors.toMap(Center::getId, Function.identity(), (left, right) -> left));
List<RuleViolationExcelDto> checks = new ArrayList<>();
checks.add(checkDuplicate(selectedAssignments.stream().map(AssignmentCandidate::getCenterId).toList(), "센터 1회 초과 배정"));
checks.add(checkMaxGroupCount(selectedAssignments, this::pairDayKey,
pairingProperties.getRule().getMaxCentersPerPairPerDay(), "페어 하루 최대 센터 수"));
checks.add(checkMemberDateDuplicate(selectedAssignments));
checks.add(checkPairDayAdjacentClassification(selectedAssignments));
checks.add(checkWomenOnly(selectedAssignments, memberMap, centerMap));
checks.add(checkActivityRegion(selectedAssignments, memberMap));
checks.add(checkHistoryCenter(selectedAssignments, memberMap));
checks.add(checkHoliday(selectedAssignments, commonUnavailableDates(data)));
checks.add(checkABDateOverlap(abPairMatches));
checks.add(checkAllMembersUsed(data, selectedAssignments, pairedMemberIds));
checks.add(checkMemberVisitBalance(data, selectedAssignments));
checks.add(checkMemberVisitUpperBound(data, selectedAssignments));
return checks;
}
private RuleViolationExcelDto checkDuplicate(List<String> values, String ruleName) {
Set<String> seen = new HashSet<>();
Set<String> duplicates = values.stream().filter(value -> !seen.add(value))
.collect(Collectors.toCollection(LinkedHashSet::new));
return new RuleViolationExcelDto(ruleName, duplicates.isEmpty() ? "PASS" : "FAIL",
duplicates.isEmpty() ? "위반 없음" : String.join(", ", duplicates));
}
private RuleViolationExcelDto checkMaxGroupCount(List<AssignmentCandidate> assignments,
Function<AssignmentCandidate, String> classifier, int max, String ruleName) {
Map<String, Long> countsByKey = assignments.stream().collect(Collectors.groupingBy(classifier, Collectors.counting()));
List<String> violations = countsByKey.entrySet().stream()
.filter(entry -> entry.getValue() > max)
.map(entry -> entry.getKey() + "=" + entry.getValue())
.toList();
return new RuleViolationExcelDto(ruleName, violations.isEmpty() ? "PASS" : "FAIL",
violations.isEmpty() ? "위반 없음" : String.join(", ", violations));
}
private RuleViolationExcelDto checkMemberDateDuplicate(List<AssignmentCandidate> assignments) {
Map<String, Set<String>> pairKeysByMemberDate = new HashMap<>();
assignments.forEach(candidate -> {
pairKeysByMemberDate.computeIfAbsent(candidate.getFieldMemberId() + "|" + candidate.getDate(), key -> new HashSet<>()).add(pairKey(candidate));
pairKeysByMemberDate.computeIfAbsent(candidate.getExternalMemberId() + "|" + candidate.getDate(), key -> new HashSet<>()).add(pairKey(candidate));
});
List<String> violations = pairKeysByMemberDate.entrySet().stream()
.filter(entry -> entry.getValue().size() > 1)
.map(entry -> entry.getKey() + "=" + String.join("/", entry.getValue()))
.toList();
return new RuleViolationExcelDto("같은 위원 같은 날짜 중복", violations.isEmpty() ? "PASS" : "FAIL",
violations.isEmpty() ? "위반 없음" : String.join(", ", violations));
}
private RuleViolationExcelDto checkPairDayAdjacentClassification(List<AssignmentCandidate> assignments) {
Map<String, Set<String>> adjacentClassificationsByPairDay = assignments.stream()
.collect(Collectors.groupingBy(this::pairDayKey,
Collectors.mapping(AssignmentCandidate::getAdjacentRegionClassification, Collectors.toSet())));
List<String> violations = adjacentClassificationsByPairDay.entrySet().stream()
.filter(entry -> entry.getValue().size() > 1)
.map(entry -> entry.getKey() + "=" + String.join("/", entry.getValue()))
.toList();
return new RuleViolationExcelDto("페어 하루 1개 인접지역분류", violations.isEmpty() ? "PASS" : "FAIL",
violations.isEmpty() ? "위반 없음" : String.join(", ", violations));
}
private RuleViolationExcelDto checkWomenOnly(List<AssignmentCandidate> assignments,
Map<String, Member> memberMap, Map<String, Center> centerMap) {
List<String> violations = assignments.stream()
.filter(candidate -> centerMap.get(candidate.getCenterId()).isWomenOnly())
.filter(candidate -> memberMap.get(candidate.getFieldMemberId()).getGender() != Gender.FEMALE
|| memberMap.get(candidate.getExternalMemberId()).getGender() != Gender.FEMALE)
.map(AssignmentCandidate::getCenterId)
.toList();
return new RuleViolationExcelDto("여성 전용 센터 조건", violations.isEmpty() ? "PASS" : "FAIL",
violations.isEmpty() ? "위반 없음" : String.join(", ", violations));
}
private RuleViolationExcelDto checkActivityRegion(List<AssignmentCandidate> assignments, Map<String, Member> memberMap) {
List<String> violations = assignments.stream()
.filter(candidate -> hasActivityRegion(memberMap.get(candidate.getFieldMemberId()), candidate.getDispatchRegion())
|| hasActivityRegion(memberMap.get(candidate.getExternalMemberId()), candidate.getDispatchRegion()))
.map(candidate -> candidate.getCenterId() + ":" + candidate.getDispatchRegion())
.toList();
return new RuleViolationExcelDto("활동지역 상피제", violations.isEmpty() ? "PASS" : "FAIL",
violations.isEmpty() ? "위반 없음" : String.join(", ", violations));
}
private boolean hasActivityRegion(Member member, String dispatchRegion) {
return java.util.Arrays.stream(member.getActivityRegion().split(",")).map(String::trim).anyMatch(dispatchRegion::equals);
}
private RuleViolationExcelDto checkHistoryCenter(List<AssignmentCandidate> assignments, Map<String, Member> memberMap) {
List<String> violations = assignments.stream()
.filter(candidate -> memberMap.get(candidate.getFieldMemberId()).getHistoryCenterIds().contains(candidate.getCenterId())
|| memberMap.get(candidate.getExternalMemberId()).getHistoryCenterIds().contains(candidate.getCenterId()))
.map(AssignmentCandidate::getCenterId)
.toList();
return new RuleViolationExcelDto("2023년 진행 센터 재배정", violations.isEmpty() ? "PASS" : "FAIL",
violations.isEmpty() ? "위반 없음" : String.join(", ", violations));
}
private RuleViolationExcelDto checkHoliday(List<AssignmentCandidate> assignments, Set<LocalDate> holidays) {
List<String> violations = assignments.stream()
.filter(candidate -> holidays.contains(candidate.getDate()))
.map(candidate -> candidate.getCenterId() + ":" + candidate.getDate())
.toList();
return new RuleViolationExcelDto("공휴일 배정", violations.isEmpty() ? "PASS" : "FAIL",
violations.isEmpty() ? "위반 없음" : String.join(", ", violations));
}
private RuleViolationExcelDto checkABDateOverlap(Map<String, ABPairMatch> abPairMatches) {
return new RuleViolationExcelDto("A/B 페어 날짜 겹침", "PASS", "A/B 그룹은 날짜가 겹치지 않는 페어만 후처리로 생성합니다.");
}
private RuleViolationExcelDto checkAllMembersUsed(PairingData data,
List<AssignmentCandidate> assignments, Set<String> pairedMemberIds) {
Set<String> usedMemberIds = assignments.stream()
.flatMap(candidate -> Stream.of(candidate.getFieldMemberId(),
candidate.getExternalMemberId()))
.collect(Collectors.toSet());
usedMemberIds.addAll(pairedMemberIds);
List<String> unusedMemberIds = data.getMembers().stream()
.map(Member::getId)
.filter(memberId -> !usedMemberIds.contains(memberId))
.toList();
return new RuleViolationExcelDto("위원 전원 조편성", unusedMemberIds.isEmpty() ? "PASS" : "FAIL",
unusedMemberIds.isEmpty() ? "위반 없음" : String.join(", ", unusedMemberIds));
}
private RuleViolationExcelDto checkMemberVisitBalance(PairingData data,
List<AssignmentCandidate> assignments) {
Map<String, Long> visitCounts = data.getMembers().stream()
.collect(Collectors.toMap(Member::getId, member -> 0L, (left, right) -> left));
assignments.forEach(candidate -> {
visitCounts.merge(candidate.getFieldMemberId(), 1L, Long::sum);
visitCounts.merge(candidate.getExternalMemberId(), 1L, Long::sum);
});
long min = visitCounts.values().stream().mapToLong(Long::longValue).min().orElse(0L);
long max = visitCounts.values().stream().mapToLong(Long::longValue).max().orElse(0L);
double average = visitCounts.values().stream().mapToLong(Long::longValue).average().orElse(0.0D);
long maxAllowed = maxMemberVisitCount(data);
String detail = "min=" + min + ", max=" + max + ", avg=" + String.format("%.2f", average)
+ ", maxAllowed=" + maxAllowed;
return new RuleViolationExcelDto("위원별 방문 센터 수 균등 배분", "PASS", detail);
}
private long maxMemberVisitCount(PairingData data) {
if (data.getMembers().isEmpty()) {
return 0L;
}
double fullAssignmentAverage = (double) data.getCenters().size() * 2D
/ data.getMembers().size();
return Math.max(1L, (long) Math.ceil(fullAssignmentAverage
* pairingProperties.getRule().getMaxMemberVisitAverageRatioPercent() / 100D));
}
private RuleViolationExcelDto checkMemberVisitUpperBound(PairingData data,
List<AssignmentCandidate> assignments) {
Map<String, Long> visitCounts = data.getMembers().stream()
.collect(Collectors.toMap(Member::getId, member -> 0L, (left, right) -> left));
assignments.forEach(candidate -> {
visitCounts.merge(candidate.getFieldMemberId(), 1L, Long::sum);
visitCounts.merge(candidate.getExternalMemberId(), 1L, Long::sum);
});
long max = visitCounts.values().stream().mapToLong(Long::longValue).max().orElse(0L);
long maxAllowed = maxMemberVisitCount(data);
String detail = "max=" + max + ", maxAllowed=" + maxAllowed
+ ", ratioPercent=" + pairingProperties.getRule()
.getMaxMemberVisitAverageRatioPercent();
return new RuleViolationExcelDto("위원 최대 방문 센터 수 상한",
max <= maxAllowed ? "PASS" : "FAIL", detail);
}
private String formatDates(Set<LocalDate> dates) {
return dates.stream().sorted().map(LocalDate::toString).collect(Collectors.joining(", "));
}
private Set<LocalDate> commonUnavailableDates(PairingData data) {
return data.getCommonUnavailableDates() == null ? Set.of() : data.getCommonUnavailableDates();
}
private Map<String, List<Integer>> groupIndexes(List<AssignmentCandidate> candidates,
Function<AssignmentCandidate, String> classifier) {
Map<String, List<Integer>> grouped = new HashMap<>();
for (int i = 0; i < candidates.size(); i++) {
grouped.computeIfAbsent(classifier.apply(candidates.get(i)), key -> new ArrayList<>()).add(i);
}
return grouped;
}
private BoolVar[] toLiteralArray(List<Integer> indexes, BoolVar[] assignmentVars) {
return indexes.stream().map(index -> assignmentVars[index]).toArray(BoolVar[]::new);
}
private LinearArgument[] toLinearArgumentArray(List<Integer> indexes, BoolVar[] assignmentVars) {
return indexes.stream().map(index -> assignmentVars[index]).toArray(LinearArgument[]::new);
}
private String pairKey(AssignmentCandidate candidate) {
return candidate.getFieldMemberId() + "|" + candidate.getExternalMemberId();
}
private String counterpartId(String pairKey, String memberId) {
String[] memberIds = pairKey.split("\\|", 2);
if (memberIds.length != 2) {
return "";
}
return memberId.equals(memberIds[0]) ? memberIds[1] : memberIds[0];
}
private String pairDayKey(AssignmentCandidate candidate) {
return pairKey(candidate) + "|" + candidate.getDate();
}
private String pairDayAdjacentKey(AssignmentCandidate candidate) {
return pairDayKey(candidate) + "|" + candidate.getAdjacentRegionClassification();
}
public record SolveSelection(boolean hasSolution, List<AssignmentCandidate> selectedAssignments, String status) {
}
private record ABPairBuildResult(Map<String, ABPairMatch> matches, List<ABPairExcelDto> rows) {
}
private record UsedPair(String pairKey, String fieldMemberId, String externalMemberId,
Set<LocalDate> dates, Set<String> dispatchRegions) {
private static UsedPair of(String pairKey, List<AssignmentCandidate> assignments) {
AssignmentCandidate first = assignments.get(0);
return new UsedPair(pairKey, first.getFieldMemberId(), first.getExternalMemberId(),
assignments.stream().map(AssignmentCandidate::getDate).collect(Collectors.toSet()),
assignments.stream().map(AssignmentCandidate::getDispatchRegion).collect(Collectors.toSet()));
}
private boolean canBeABWith(UsedPair other) {
return dates.stream().noneMatch(other.dates::contains)
&& dispatchRegions.stream().anyMatch(other.dispatchRegions::contains)
&& !Objects.equals(fieldMemberId, other.fieldMemberId)
&& !Objects.equals(fieldMemberId, other.externalMemberId)
&& !Objects.equals(externalMemberId, other.fieldMemberId)
&& !Objects.equals(externalMemberId, other.externalMemberId);
}
}
static {
Loader.loadNativeLibraries();
}
}

View File

@@ -32,33 +32,37 @@ public class PairingValidationService {
private void validateNotEmpty(PairingData data) {
if (data.getMembers().isEmpty()) {
throw BusinessException.badRequest("PAIRING_EMPTY_MEMBER", "위원정보 시트에 데이터가 없습니다.");
} else if (data.getMunicipalities().isEmpty()) {
}
if (data.getMunicipalities().isEmpty()) {
throw BusinessException.badRequest("PAIRING_EMPTY_MUNICIPALITY", "지자체 정보 시트에 데이터가 없습니다.");
} else if (data.getCenters().isEmpty()) {
}
if (data.getCenters().isEmpty()) {
throw BusinessException.badRequest("PAIRING_EMPTY_CENTER", "센터정보 시트에 데이터가 없습니다.");
} else if (data.getCenterAdjacentRegions().isEmpty()) {
}
if (data.getCenterAdjacentRegions().isEmpty()) {
throw BusinessException.badRequest("PAIRING_EMPTY_CENTER_ADJACENT_REGION",
"센터 인접지역표 시트에 데이터가 없습니다.");
} else if (data.getPreferenceMatchRules().isEmpty()) {
}
if (data.getPreferenceMatchRules().isEmpty()) {
throw BusinessException.badRequest("PAIRING_EMPTY_PREFERENCE_MATCH",
"희망지역 매칭표 시트에 데이터가 없습니다.");
}
}
private void validateDateRanges(PairingData data) {
data.getMembers().forEach((member) -> {
data.getMembers().forEach(member -> {
if (member.getAvailableEndDate().isBefore(member.getAvailableStartDate())) {
throw BusinessException.badRequest("PAIRING_INVALID_DATE_RANGE",
"위원 종료일이 시작일보다 빠릅니다: " + member.getId());
}
});
data.getMunicipalities().forEach((municipality) -> {
data.getMunicipalities().forEach(municipality -> {
if (municipality.getAvailableEndDate().isBefore(municipality.getAvailableStartDate())) {
throw BusinessException.badRequest("PAIRING_INVALID_DATE_RANGE",
"지자체 종료일이 시작일보다 빠릅니다: " + municipality.getId());
}
});
data.getCenters().forEach((center) -> {
data.getCenters().forEach(center -> {
if (center.getAvailableEndDate().isBefore(center.getAvailableStartDate())) {
throw BusinessException.badRequest("PAIRING_INVALID_DATE_RANGE",
"센터 종료일이 시작일보다 빠릅니다: " + center.getId());
@@ -67,53 +71,45 @@ public class PairingValidationService {
}
private void validateMunicipalityReferences(PairingData data) {
Map<String, Municipality> municipalities = (Map) data.getMunicipalities().stream()
Map<String, Municipality> municipalities = data.getMunicipalities().stream()
.collect(Collectors.toMap(Municipality::getId, Function.identity(), (left, right) -> left));
for (Center center : data.getCenters()) {
if (!municipalities.containsKey(center.getMunicipalityId())) {
String var10001 = center.getId();
throw BusinessException.badRequest("PAIRING_BROKEN_MUNICIPALITY_REFERENCE",
"센터가 존재하지 않는 지자체를 참조합니다. centerId=" + var10001 + ", municipalityId="
+ center.getMunicipalityId());
"센터가 존재하지 않는 지자체를 참조합니다. centerId=" + center.getId()
+ ", municipalityId=" + center.getMunicipalityId());
}
}
}
private void validatePreferenceRules(PairingData data) {
Set<Integer> priorities = new HashSet();
Set<Integer> priorities = new HashSet<>();
for (PreferenceMatchRule rule : data.getPreferenceMatchRules()) {
if (!priorities.add(rule.getPriority())) {
throw BusinessException.badRequest("PAIRING_DUPLICATE_PREFERENCE_PRIORITY",
"희망지역 매칭표의 매칭 순위가 중복됩니다: " + rule.getPriority());
}
if (rule.getFieldMemberPreferenceRank() < 0 || rule.getExternalMemberPreferenceRank() < 0) {
throw BusinessException.badRequest("PAIRING_INVALID_PREFERENCE_RANK",
"희망지역 매칭표의 선호 순위는 0 이상이어야 합니다.");
}
}
}
private void validatePreferenceAnyRegionOrder(PairingData data) {
for (Member member : data.getMembers()) {
boolean anyRegionAppeared = false;
for (String preferenceRegion : member.getPreferenceRegions()) {
if (anyRegionAppeared && !anyRegionCode().equals(preferenceRegion)) {
throw BusinessException.badRequest("PAIRING_INVALID_PREFERENCE_ORDER",
"선호지역 00 이후에는 다른 지역이 올 수 없습니다. memberId=" + member.getId());
"희망지역 00 이후에는 다른 지역이 올 수 없습니다. memberId=" + member.getId());
}
if (anyRegionCode().equals(preferenceRegion)) {
anyRegionAppeared = true;
}
}
}
}
private String anyRegionCode() {

View File

@@ -4,8 +4,7 @@ server:
spring:
application:
name: narc-pairing
name: ncrc-pairing
servlet:
multipart:
max-file-size: 50MB
@@ -21,7 +20,7 @@ kri:
security:
enabled: true
public-paths: # 인증 없이 열어둘 URL
public-paths:
- /v3/api-docs/**
- /swagger-ui.html
- /swagger-ui/**
@@ -30,75 +29,36 @@ kri:
swagger:
enabled: true
allowed-ips:
- 211.254.145.130
- 1.235.195.3
title: "KRI P6 NCRC Pairing API"
description: "KRI P6 아동관리 보장원 조편성 API"
description: "아동권리보장원 조편성 API"
version: "v1.0.0"
base-package: "com.kri.p6.ncrc.pairing"
web:
enabled: true # 공통 Web 구성 사용 여부 (기본 true)
enabled: true
webmvc:
enabled: true # 공통 Webmvc 구성 사용 여부 (기본 true)
enabled: true
redis:
enabled: false # RedisQueueHelper 사용 시 true
enabled: false
scheduling:
enabled: false # @Scheduled 사용 시 true
enabled: false
pairing:
excel:
# ExcelMapper에서 헤더가 위치한 행 번호입니다. 공통 라이브러리 기준 1부터 시작합니다.(HARD)
# ExcelMapper가 데이터를 읽기 시작하는 헤더 행 번호입니다.
header-row-index: 1
code:
# 활동지역, 선호지역, 파견 권역처럼 권역 비교에 사용하는 코드 길이입니다.
# 활동지역, 희망지역, 파견권역 코드의 표준 길이입니다.
region-code-length: 2
# 위원 거주지 입력 코드 길이입니다.
# 위원 거주지 코드의 표준 길이입니다.
residence-code-length: 5
# 거주지 유사도 비교 시 앞에서 몇 자리까지 비교할지 정합니다.
residence-match-prefix-length: 3
# 선호지역에서 "어디든 가능"을 의미하는 코드입니다.
# 희망지역에서 '어디든 가능'을 의미하는 코드입니다.
any-region-code: "00"
rule:
# 한 페어가 하루에 방문할 수 있는 최대 센터 수입니다. (HARD)
max-centers-per-pair-per-day: 3
# 한 위원이 전체 기간 동안 가질 수 있는 최대 상대 파트너 수입니다.(HARD)
max-counterparts-per-member: 3
# 위원 1명의 최대 방문 센터 수 상한입니다. 전체 센터가 모두 배정됐을 때 평균 방문 수의 N%를 넘지 못하게 합니다.(HARD)
max-member-visit-average-ratio-percent: 130
preference:
# 선호지역 00(anywhere)을 희망지역 매칭표에서 표현하는 rank 값입니다.(HARD)
# 희망지역 00(anywhere)이 희망지역 매칭표에서 표현되는 순위입니다.
anywhere-rank: 0
# 희망지역 매칭표에서 해당 위원의 선호지역을 고려하지 않는 wildcard rank 값입니다.(HARD)
# 희망지역을 고려하지 않는 wildcard 순위입니다.
ignored-rank: 99
# true면 선호지역 미일치 후보도 99 wildcard 매칭표 규칙을 적극 활용합니다. false로 바꾸면 기존 보수적 점수로 되돌아갑니다.
active-wildcard-fallback-enabled: true
# wildcard 후보가 후보 축소/배정 선택에서 너무 뒤로 밀리지 않도록 더하는 점수입니다. 값이 클수록 미배정 센터 감소를 우선합니다.
wildcard-fallback-score-bonus: 25_000
objective:
# 센터 1개를 배정했을 때 부여하는 최우선 점수입니다. 다른 soft score 총합보다 충분히 커야 합니다.
assignment-weight: 1_000_000
# 이미 많이 배정된 위원이 추가 배정될 때 차감하는 점수입니다. 값이 클수록 위원별 방문 센터 수를 평균에 가깝게 분산합니다.
member-balance-weight: 20_000
# 희망지역 매칭 순위 점수의 기준값입니다. 값이 클수록 선호지역 품질 영향이 커집니다.
preference-base-weight: 30_000
# 매칭 순위가 1 내려갈 때마다 차감하는 점수입니다. 값이 클수록 낮은 순위를 더 강하게 불리하게 봅니다.
preference-rank-penalty: 1_000
# 거주지 prefix가 일치하는 페어에 부여하는 점수입니다. 값이 클수록 거주지 유사도를 더 중요하게 봅니다.
residence-match-weight: 10_000
candidate:
# 위원 1명당 유지할 상대 위원 후보 수입니다. 0이면 제한하지 않습니다.
# 모든 위원 조편성이 최우선 HARD 룰이므로 기본값은 제한 없음으로 둡니다.
max-pair-candidates-per-member: 0
# 현장+외부 페어 1개가 solver에 넘기기 전에 유지할 최대 파견 권역 후보 수입니다.
max-dispatch-regions-per-pair: 0
# 센터 1개마다 solver에 넘기기 전에 유지할 최대 배정 후보 수입니다.
max-assignments-per-center: 1_000
# 위원 1명(현장/외부 모두 포함)이 solver 후보에 등장할 수 있는 최대 횟수입니다.
max-assignments-per-member: 3_000
# 페어-센터 후보 1개에서 생성할 최대 가능 날짜 수입니다. 기간 전체에 고르게 분산해 날짜 쏠림을 줄입니다.
max-dates-per-assignment-candidate: 80
solver:
# OR-Tools CP-SAT solver가 한 요청에서 탐색할 최대 시간(초)입니다.
max-time-seconds: 360.0
# OR-Tools CP-SAT 병렬 탐색 worker 수입니다. 서버 CPU 상황에 맞춰 조정합니다.
num-search-workers: 15

Binary file not shown.

View File

@@ -1,105 +0,0 @@
# 배정 규칙 및 완화 검토 자료
이 문서는 개발자가 아닌 업무 담당자와 배정 기준을 논의하기 위한 설명 자료입니다.
현재 프로그램은 "모든 위원을 조편성한 뒤, 가능한 많은 센터를 일정표에 배정"하는 것을 목표로 합니다. 단, 일부 규칙은 반드시 지켜야 하므로 센터가 남을 수 있습니다.
## 용어 설명
| 용어 | 설명 |
| --- | --- |
| 현장위원/외부위원 | 한 조를 구성하는 두 역할입니다. 현재 기본 조는 현장위원 1명 + 외부위원 1명입니다. |
| 센터 배정 | 특정 날짜에 특정 조가 특정 센터를 방문하도록 정하는 것입니다. |
| 상피제 | 위원의 활동지역과 같은 파견 권역에는 배정하지 않는 규칙입니다. |
| 희망지역 00 | 어디든 가능하다는 응답입니다. |
| 희망지역 99 | 희망지역을 고려하지 않는다는 매칭표의 wildcard 규칙입니다. |
| Greedy | 그때그때 가장 좋아 보이는 선택을 빠르게 고르는 방식입니다. 사람으로 비유하면 "막히기 쉬운 센터부터 먼저 잡고, 가능한 후보 중 점수가 좋은 조를 넣는 방식"입니다. |
| CP-SAT | 여러 조건을 동시에 만족하는 조합을 찾는 최적화 도구입니다. 모든 후보를 놓고 수학적으로 좋은 조합을 찾지만, 후보가 많으면 시간이 오래 걸립니다. |
| repair pass | 1차 배정 후 남은 센터를 줄이기 위해 일부 배정을 빼고 다시 끼워 넣어 보는 후처리입니다. |
## 현재 처리 순서
1. 엑셀 파일을 읽습니다.
2. 날짜, 지역코드, 성별, 경력, 불가능일, 희망지역 등 입력값을 정리합니다.
3. 공휴일과 토/일을 공통 불가능일로 추가합니다.
4. 입력 데이터의 필수값과 참조 오류를 검증합니다.
5. 가능한 후보를 생성합니다.
6. 모든 위원이 최소 1개 조에 포함되도록 조편성을 먼저 합니다.
7. 확정된 조를 기준으로 센터 일정을 Greedy 방식으로 배정합니다.
8. 미배정 센터를 줄이기 위해 후처리를 순서대로 수행합니다.
9. 결과 엑셀을 생성합니다.
## 현재 Hard Rule
Hard Rule은 반드시 지켜야 하는 규칙입니다. 이 규칙을 어기면서 센터를 더 배정하지 않습니다.
| 우선순위 | 규칙 | 설명 | 현재 완화 가능성 |
| --- | --- | --- | --- |
| 0 | 모든 위원 조편성 | 모든 위원은 최소 1개 이상의 조에 포함되어야 합니다. | 완화 불가 |
| 1 | 역할 조합 | 현장위원 1명 + 외부위원 1명으로 조를 구성합니다. | 낮음 |
| 2 | 위원 활동 가능 기간 | 두 위원의 활동 가능 기간이 겹쳐야 조 후보가 됩니다. | 낮음 |
| 3 | 날짜 불가 | 위원, 지자체, 센터의 불가능일에는 배정하지 않습니다. | 중간 |
| 4 | 공통 불가능일 | 공휴일과 토/일에는 배정하지 않습니다. | 중간 |
| 5 | 상피제 | 위원의 활동지역과 같은 파견 권역에는 배정하지 않습니다. | 높음 |
| 6 | 여성전용센터 | 여성전용센터는 여성 위원 2명 조만 배정합니다. | 중간 |
| 7 | 기방문센터 제외 | 2023년에 해당 위원이 진행한 센터는 제외합니다. | 높음 |
| 8 | 센터 중복 배정 금지 | 센터 1개는 결과에서 최대 1번만 배정됩니다. | 완화 불가 |
| 9 | 같은 날짜 위원 중복 금지 | 한 위원은 같은 날짜에 여러 조로 동시에 활동할 수 없습니다. | 낮음 |
| 10 | 같은 조의 하루 방문 상한 | 같은 조는 하루 최대 3개 센터까지 방문합니다. | 높음 |
| 11 | 같은 조/날짜의 인접지역 분류 | 같은 조가 같은 날짜에는 하나의 인접지역 분류만 방문합니다. | 높음 |
| 12 | 위원당 상대 파트너 수 | 위원 1명당 최대 3명의 상대 위원까지만 허용합니다. | 높음 |
| 13 | 위원별 최대 방문 상한 | 전체 센터가 모두 배정됐을 때의 평균 방문 수 대비 130%를 넘지 않게 합니다. | 높음 |
## 현재 Soft Rule
Soft Rule은 가능하면 지키는 규칙입니다. Hard Rule을 모두 지킨 후보 중에서 더 좋은 후보를 고르는 기준입니다.
| 우선순위 | 규칙 | 설명 |
| --- | --- | --- |
| 1 | 배정 센터 수 최대화 | 가장 중요한 목표입니다. 희망지역 품질보다 센터를 더 많이 배정하는 것이 우선입니다. |
| 2 | 위원별 방문 수 균형 | 특정 위원에게 센터가 과도하게 몰리지 않도록 합니다. |
| 3 | 희망지역 매칭 품질 | 희망지역 매칭표의 우선순위가 좋은 후보를 선호합니다. |
| 4 | 희망지역 99 wildcard 활용 | 선호지역이 직접 맞지 않아도 "선호지역 고려하지 않음" 규칙으로 후보를 살릴 수 있습니다. 현재 옵션으로 켜져 있습니다. |
| 5 | 거주지 유사도 | 거주지 코드 앞 3자리, 없으면 2자리가 같은 조를 선호합니다. |
| 6 | 같은 조/같은 날짜 묶음 | 이미 같은 조가 같은 날짜에 같은 인접지역 분류를 방문한다면 추가 센터를 묶어서 배정하려고 합니다. |
## 후처리 방식
1차 Greedy 배정 후에도 남은 센터가 있으면 아래 순서로 다시 시도합니다.
| 순서 | 후처리 | 설명 |
| --- | --- | --- |
| 1 | 일반 repair | 미배정 센터 하나를 넣기 위해 충돌되는 기존 배정을 최대 2개까지 빼고 다시 배정합니다. |
| 2 | 저방문 위원 중심 repair | 방문 수가 적은 위원이 남은 센터에 들어갈 수 있는지 먼저 봅니다. |
| 3 | donor-swap repair | 방문 수가 많은 위원의 기존 배정을 빼고, 같은 센터를 저방문 위원이 포함된 조로 넘길 수 있는지 봅니다. |
| 4 | wildcard repair | 희망지역 99 wildcard로 살아난 후보를 남은 센터에 우선 적용해 봅니다. |
## Greedy와 CP-SAT의 현재 역할
현재 1차 배정은 Greedy 중심입니다.
Greedy는 빠르고 큰 데이터에 비교적 안정적으로 동작합니다. 대신 처음 선택한 조합이 뒤쪽 선택에 영향을 주므로, 항상 이론상 최적이라고 보장하지는 않습니다. 그래서 후처리 단계에서 일부 배정을 교환하면서 보정합니다.
CP-SAT는 조건을 모두 수학 모델로 만들어 더 좋은 조합을 찾는 방식입니다. 다만 후보 수가 커지면 시간이 매우 오래 걸리고 PC 사양 영향을 크게 받습니다. 현재 프로젝트에서는 CP-SAT 코드를 유지하되, 전체 배정의 중심은 Greedy로 옮겨 둔 상태입니다.
## 완화하면 미배정 센터가 늘어날 가능성이 큰 순서
아래 순서는 "센터 배정 수 증가 가능성" 기준입니다. 실제 정책적으로 허용 가능한지는 별도 협의가 필요합니다.
| 추천 순서 | 완화 대상 | 기대 효과 | 업무 리스크 |
| --- | --- | --- | --- |
| 1 | 위원별 최대 방문 상한 130% | 현재 max=24에서 더 많은 센터를 넣을 여지가 생깁니다. | 일부 위원에게 방문이 몰릴 수 있습니다. |
| 2 | 위원당 상대 파트너 수 3명 | 조 선택지가 늘어나 날짜/센터 후보가 크게 늘 수 있습니다. | 한 위원이 여러 사람과 조를 이루게 되어 운영 복잡도가 증가합니다. |
| 3 | 같은 조 하루 최대 3개 센터 | 같은 날짜에 더 많은 센터를 묶을 수 있습니다. | 이동 가능성, 업무 피로도 확인이 필요합니다. |
| 4 | 같은 조/날짜의 인접지역 분류 1개 제한 | 인접지역 분류가 다른 센터도 같은 날 묶을 수 있습니다. | 실제 이동 동선이 나빠질 수 있습니다. |
| 5 | 기방문센터 제외 | 특정 위원이 과거 방문한 센터도 다시 갈 수 있어 후보가 늘어납니다. | 기존 정책 취지와 충돌할 수 있습니다. |
| 6 | 상피제 | 활동지역과 파견 권역이 같은 경우도 허용하면 후보가 늘어납니다. | 이해충돌 방지 취지와 충돌할 수 있습니다. |
| 7 | 날짜 불가 일부 완화 | 위원/센터/지자체 일정 제약이 줄어듭니다. | 실제 운영 가능 여부 확인이 필요합니다. |
| 8 | 공휴일/토/일 배정 허용 | 날짜 후보가 늘어납니다. | 운영 정책상 허용 가능성이 낮습니다. |
| 9 | 여성전용센터 성별 조건 | 일부 센터 후보가 늘어납니다. | 정책 리스크가 큽니다. |
## 현재 결과 해석 시 주의점
미배정 센터가 남는다고 해서 희망지역만 문제라는 뜻은 아닙니다. 현재는 희망지역 99 wildcard도 사용하도록 열어 둔 상태입니다. 그래도 남는 센터는 날짜, 상피제, 성별, 기방문센터, 하루 방문 상한, 파트너 수, 방문 수 상한이 복합적으로 막고 있을 가능성이 큽니다.
따라서 클라이언트와 논의할 때는 "희망지역을 더 넓게 보는 것"보다 "어떤 Hard Rule을 어느 수준까지 완화할 수 있는지"가 배정률 개선의 핵심입니다.

View File

@@ -1,129 +0,0 @@
package com.kri.p6.ncrc.pairing.service;
import com.kri.p6.ncrc.pairing.model.Center;
import com.kri.p6.ncrc.pairing.model.CenterAdjacentRegion;
import com.kri.p6.ncrc.pairing.common.enums.ExperienceType;
import com.kri.p6.ncrc.pairing.common.enums.Gender;
import com.kri.p6.ncrc.pairing.config.PairingProperties;
import com.kri.p6.ncrc.pairing.model.Member;
import com.kri.p6.ncrc.pairing.common.enums.MemberRole;
import com.kri.p6.ncrc.pairing.model.Municipality;
import com.kri.p6.ncrc.pairing.model.PairingCandidates;
import com.kri.p6.ncrc.pairing.model.PairingData;
import com.kri.p6.ncrc.pairing.model.PreferenceMatchRule;
import java.time.LocalDate;
import java.util.Collection;
import java.util.List;
import java.util.Set;
import org.assertj.core.api.Assertions;
import org.junit.jupiter.api.Test;
class PairingCandidateServiceTest {
private final PairingCandidateService service = new PairingCandidateService(PairingTestSupport.pairingProperties());
@Test
void generateAllowsNewNewPairBecauseAllMembersMustBePaired() {
PairingCandidates candidates = service.generate(baseData(member("field", MemberRole.FIELD, Gender.FEMALE, ExperienceType.NEW, "02", Set.of()), member("external", MemberRole.EXTERNAL, Gender.FEMALE, ExperienceType.NEW, "03", Set.of()), center("center", false)));
Assertions.assertThat(candidates.getPairCandidates()).hasSize(1);
Assertions.assertThat(candidates.getAssignmentCandidates()).hasSize(3);
}
@Test
void generateExcludesConflictDispatchRegion() {
PairingCandidates candidates = service.generate(baseData(member("field", MemberRole.FIELD, Gender.FEMALE, ExperienceType.EXPERIENCED, "01", Set.of()), member("external", MemberRole.EXTERNAL, Gender.FEMALE, ExperienceType.EXPERIENCED, "03", Set.of()), center("center", false)));
Assertions.assertThat(candidates.getPairCandidates()).hasSize(1);
Assertions.assertThat(candidates.getDispatchRegionCandidates()).isEmpty();
Assertions.assertThat(candidates.getAssignmentCandidates()).isEmpty();
}
@Test
void generateExcludesConflictWhenActivityRegionHasMultipleCodes() {
PairingCandidates candidates = service.generate(baseData(member("field", MemberRole.FIELD, Gender.FEMALE, ExperienceType.EXPERIENCED, "02,01", Set.of()), member("external", MemberRole.EXTERNAL, Gender.FEMALE, ExperienceType.EXPERIENCED, "03", Set.of()), center("center", false)));
Assertions.assertThat(candidates.getPairCandidates()).hasSize(1);
Assertions.assertThat(candidates.getDispatchRegionCandidates()).isEmpty();
Assertions.assertThat(candidates.getAssignmentCandidates()).isEmpty();
}
@Test
void generateAllowsWomenOnlyCenterOnlyForFemalePair() {
PairingCandidates maleIncluded = service.generate(baseData(member("field", MemberRole.FIELD, Gender.FEMALE, ExperienceType.EXPERIENCED, "02", Set.of()), member("external", MemberRole.EXTERNAL, Gender.MALE, ExperienceType.EXPERIENCED, "03", Set.of()), center("center", true)));
PairingCandidates femaleOnly = service.generate(baseData(member("field", MemberRole.FIELD, Gender.FEMALE, ExperienceType.EXPERIENCED, "02", Set.of()), member("external", MemberRole.EXTERNAL, Gender.FEMALE, ExperienceType.EXPERIENCED, "03", Set.of()), center("center", true)));
Assertions.assertThat(maleIncluded.getAssignmentCandidates()).isEmpty();
Assertions.assertThat(femaleOnly.getAssignmentCandidates()).hasSize(3);
}
@Test
void generateExcludesHistoryCenter() {
PairingCandidates candidates = service.generate(baseData(member("field", MemberRole.FIELD, Gender.FEMALE, ExperienceType.EXPERIENCED, "02", Set.of("center")), member("external", MemberRole.EXTERNAL, Gender.FEMALE, ExperienceType.EXPERIENCED, "03", Set.of()), center("center", false)));
Assertions.assertThat(candidates.getAssignmentCandidates()).isEmpty();
}
@Test
void generateTreatsPreferenceRank99AsIgnored() {
PairingData data = PairingData.builder().members(List.of(member("field", MemberRole.FIELD, Gender.FEMALE, ExperienceType.EXPERIENCED, "02", Set.of()), member("external", MemberRole.EXTERNAL, Gender.FEMALE, ExperienceType.EXPERIENCED, "03", Set.of()))).municipalities(List.of(Municipality.builder().id("municipality").availableStartDate(LocalDate.of(2026, 5, 1)).availableEndDate(LocalDate.of(2026, 5, 3)).unavailableDates(Set.of()).build())).centers(List.of(center("center", false))).memberRegionCodes(List.of()).centerAdjacentRegions(List.of(CenterAdjacentRegion.builder().dispatchRegion("01").adjacentRegionClassification("A").build())).preferenceMatchRules(List.of(PreferenceMatchRule.builder().priority(1).fieldMemberPreferenceRank(1).externalMemberPreferenceRank(99).build())).commonUnavailableDates(Set.of()).build();
PairingCandidates candidates = service.generate(data);
Assertions.assertThat(candidates.getDispatchRegionCandidates()).hasSize(1);
Assertions.assertThat(candidates.getAssignmentCandidates()).hasSize(3);
}
@Test
void generateExcludesCommonHolidayDates() {
PairingData data = baseData(member("field", MemberRole.FIELD, Gender.FEMALE, ExperienceType.EXPERIENCED, "02", Set.of()), member("external", MemberRole.EXTERNAL, Gender.FEMALE, ExperienceType.EXPERIENCED, "03", Set.of()), Center.builder().id("center").municipalityId("municipality").womenOnly(false).adjacentRegionClassification("A").availableStartDate(LocalDate.of(2026, 5, 1)).availableEndDate(LocalDate.of(2026, 5, 1)).unavailableDates(Set.of()).build());
data = PairingData.builder().members(data.getMembers()).municipalities(data.getMunicipalities()).centers(data.getCenters()).memberRegionCodes(data.getMemberRegionCodes()).centerAdjacentRegions(data.getCenterAdjacentRegions()).preferenceMatchRules(data.getPreferenceMatchRules()).commonUnavailableDates(Set.of(LocalDate.of(2026, 5, 1))).build();
PairingCandidates candidates = service.generate(data);
Assertions.assertThat(candidates.getAssignmentCandidates()).isEmpty();
Assertions.assertThat((Collection)candidates.getUnassignedCenterReasons().get("center")).contains(new String[]{"위원/지자체/센터 일정 또는 국공휴일 조건 불일치"});
}
@Test
void generateTrimsCandidatesByConfiguredLimits() {
PairingProperties properties = PairingTestSupport.pairingProperties();
properties.getCandidate().setMaxDispatchRegionsPerPair(1);
properties.getCandidate().setMaxAssignmentsPerCenter(1);
properties.getCandidate().setMaxAssignmentsPerMember(1);
PairingCandidateService limitedService = new PairingCandidateService(properties);
PairingData data = PairingData.builder()
.members(List.of(
member("field1", MemberRole.FIELD, Gender.FEMALE, ExperienceType.EXPERIENCED, "09", Set.of()),
member("field2", MemberRole.FIELD, Gender.FEMALE, ExperienceType.EXPERIENCED, "09", Set.of()),
member("external1", MemberRole.EXTERNAL, Gender.FEMALE, ExperienceType.EXPERIENCED, "09", Set.of()),
member("external2", MemberRole.EXTERNAL, Gender.FEMALE, ExperienceType.EXPERIENCED, "09", Set.of())
))
.municipalities(List.of(Municipality.builder().id("municipality").availableStartDate(LocalDate.of(2026, 5, 1)).availableEndDate(LocalDate.of(2026, 5, 3)).unavailableDates(Set.of()).build()))
.centers(List.of(center("center1", false), center("center2", false)))
.memberRegionCodes(List.of())
.centerAdjacentRegions(List.of(
CenterAdjacentRegion.builder().dispatchRegion("01").adjacentRegionClassification("A").build(),
CenterAdjacentRegion.builder().dispatchRegion("02").adjacentRegionClassification("A").build()
))
.preferenceMatchRules(List.of(
PreferenceMatchRule.builder().priority(1).fieldMemberPreferenceRank(1).externalMemberPreferenceRank(1).build(),
PreferenceMatchRule.builder().priority(2).fieldMemberPreferenceRank(2).externalMemberPreferenceRank(2).build()
))
.commonUnavailableDates(Set.of())
.build();
PairingCandidates candidates = limitedService.generate(data);
Assertions.assertThat(candidates.getDispatchRegionCandidates()).hasSize(4);
Assertions.assertThat(candidates.getAssignmentCandidates()).hasSizeLessThanOrEqualTo(2);
Assertions.assertThat(candidates.getAssignmentCandidates())
.extracting(candidate -> candidate.getFieldMemberId())
.doesNotHaveDuplicates();
Assertions.assertThat(candidates.getAssignmentCandidates())
.extracting(candidate -> candidate.getExternalMemberId())
.doesNotHaveDuplicates();
}
private PairingData baseData(Member fieldMember, Member externalMember, Center center) {
return PairingData.builder().members(List.of(fieldMember, externalMember)).municipalities(List.of(Municipality.builder().id("municipality").availableStartDate(LocalDate.of(2026, 5, 1)).availableEndDate(LocalDate.of(2026, 5, 3)).unavailableDates(Set.of()).build())).centers(List.of(center)).memberRegionCodes(List.of()).centerAdjacentRegions(List.of(CenterAdjacentRegion.builder().dispatchRegion("01").adjacentRegionClassification("A").build())).preferenceMatchRules(List.of(PreferenceMatchRule.builder().priority(1).fieldMemberPreferenceRank(1).externalMemberPreferenceRank(1).build())).commonUnavailableDates(Set.of()).build();
}
private Member member(String id, MemberRole role, Gender gender, ExperienceType experienceType, String activityRegion, Set<String> historyCenterIds) {
return Member.builder().id(id).gender(gender).experienceType(experienceType).role(role).availableStartDate(LocalDate.of(2026, 5, 1)).availableEndDate(LocalDate.of(2026, 5, 3)).unavailableDates(Set.of()).activityRegion(activityRegion).historyCenterIds(historyCenterIds).residenceCode("01101").preferenceRegions(List.of("01", "00", "00", "00")).build();
}
private Center center(String id, boolean womenOnly) {
return Center.builder().id(id).municipalityId("municipality").womenOnly(womenOnly).adjacentRegionClassification("A").availableStartDate(LocalDate.of(2026, 5, 1)).availableEndDate(LocalDate.of(2026, 5, 3)).unavailableDates(Set.of()).build();
}
}

View File

@@ -1,31 +0,0 @@
package com.kri.p6.ncrc.pairing.service;
import com.kri.p6.ncrc.pairing.dto.excel.input.PairingWorkbookData;
import java.io.IOException;
import java.io.InputStream;
import org.assertj.core.api.Assertions;
import org.junit.jupiter.api.Test;
import org.springframework.mock.web.MockMultipartFile;
class PairingExcelServiceTest {
private final PairingExcelService pairingExcelService = new PairingExcelService(
PairingTestSupport.pairingProperties());
@Test
void readSampleWorkbook() throws IOException {
try (InputStream inputStream = getClass().getResourceAsStream("/sample/기초 data TEST.xlsx")) {
MockMultipartFile file = new MockMultipartFile("file", "기초 data TEST.xlsx",
"application/vnd.openxmlformats-officedocument.spreadsheetml.sheet", inputStream);
PairingWorkbookData data = pairingExcelService.read(file);
Assertions.assertThat(data.getMembers()).isNotEmpty();
Assertions.assertThat(data.getMunicipalities()).isNotEmpty();
Assertions.assertThat(data.getCenters()).isNotEmpty();
Assertions.assertThat(data.getMemberRegionCodes()).isNotEmpty();
Assertions.assertThat(data.getCenterAdjacentRegions()).isNotEmpty();
Assertions.assertThat(data.getPreferenceMatchRules()).isNotEmpty();
}
}
}

View File

@@ -1,91 +0,0 @@
package com.kri.p6.ncrc.pairing.service;
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.common.external.datago.DatagoExtentionApiClient;
import com.kri.p6.ncrc.pairing.common.cache.DatagoHolidayCache;
import com.kri.p6.ncrc.pairing.common.external.datago.HolidayDto;
import com.kri.p6.ncrc.pairing.model.Member;
import com.kri.p6.ncrc.pairing.model.PairingData;
import java.time.LocalDate;
import java.util.List;
import java.util.Set;
import org.assertj.core.api.Assertions;
import org.junit.jupiter.api.Test;
class PairingHolidayServiceTest {
@Test
void applyHolidayUnavailableDatesAddsDatagoHolidays() {
PairingHolidayService service = new PairingHolidayService(new DatagoHolidayCache(new StubDatagoExtentionApiClient()));
PairingData data = PairingData.builder().members(List.of(
Member.builder()
.id("member")
.gender(Gender.FEMALE)
.experienceType(ExperienceType.EXPERIENCED)
.role(MemberRole.FIELD)
.availableStartDate(LocalDate.of(2026, 5, 1))
.availableEndDate(LocalDate.of(2026, 5, 10))
.unavailableDates(Set.of())
.activityRegion("02")
.historyCenterIds(Set.of())
.residenceCode("01101")
.preferenceRegions(List.of("01", "00", "00", "00"))
.build()))
.municipalities(List.of())
.centers(List.of())
.memberRegionCodes(List.of())
.centerAdjacentRegions(List.of())
.preferenceMatchRules(List.of())
.commonUnavailableDates(Set.of())
.build();
PairingData result = service.applyHolidayUnavailableDates(data);
Assertions.assertThat(result.getCommonUnavailableDates()).contains(
LocalDate.of(2026, 5, 2),
LocalDate.of(2026, 5, 3),
LocalDate.of(2026, 5, 5)
);
}
@Test
void getWeekendReturnsSaturdayAndSundayForYear() {
DatagoHolidayCache cache = new DatagoHolidayCache(new StubDatagoExtentionApiClient());
List<String> weekendDates = cache.getWeekend("2026").stream()
.map(HolidayDto::getHolidayDate)
.toList();
Assertions.assertThat(weekendDates)
.contains("20260103", "20260104", "20261226", "20261227")
.doesNotContain("20260102");
}
@Test
void applyHolidayUnavailableDatesUsesCacheForSameYear() {
CountingDatagoExtentionApiClient client = new CountingDatagoExtentionApiClient();
PairingHolidayService service = new PairingHolidayService(new DatagoHolidayCache(client));
PairingData data = baseData();
service.applyHolidayUnavailableDates(data);
service.applyHolidayUnavailableDates(data);
Assertions.assertThat(client.callCount).isEqualTo(1);
}
private PairingData baseData() {
return PairingData.builder().members(List.of(Member.builder().id("member").gender(Gender.FEMALE).experienceType(ExperienceType.EXPERIENCED).role(MemberRole.FIELD).availableStartDate(LocalDate.of(2026, 5, 1)).availableEndDate(LocalDate.of(2026, 5, 10)).unavailableDates(Set.of()).activityRegion("02").historyCenterIds(Set.of()).residenceCode("01101").preferenceRegions(List.of("01", "00", "00", "00")).build())).municipalities(List.of()).centers(List.of()).memberRegionCodes(List.of()).centerAdjacentRegions(List.of()).preferenceMatchRules(List.of()).commonUnavailableDates(Set.of()).build();
}
private static class StubDatagoExtentionApiClient extends DatagoExtentionApiClient {
public List<HolidayDto> getHoliDayList(String year) {
return List.of(HolidayDto.of(year + "0505", "어린이날"));
}
}
private static class CountingDatagoExtentionApiClient extends DatagoExtentionApiClient {
private int callCount;
public List<HolidayDto> getHoliDayList(String year) {
++callCount;
return List.of(HolidayDto.of(year + "0505", "어린이날"));
}
}
}

View File

@@ -1,75 +0,0 @@
package com.kri.p6.ncrc.pairing.service;
import static com.kri.p6.ncrc.pairing.common.consts.PairingConstant.RESULT_SHEET_AB_PAIR;
import static com.kri.p6.ncrc.pairing.common.consts.PairingConstant.RESULT_SHEET_ASSIGNMENT;
import static com.kri.p6.ncrc.pairing.common.consts.PairingConstant.RESULT_SHEET_CANDIDATE_SUMMARY;
import static com.kri.p6.ncrc.pairing.common.consts.PairingConstant.RESULT_SHEET_RULE_CHECK;
import static com.kri.p6.ncrc.pairing.common.consts.PairingConstant.RESULT_SHEET_SUMMARY;
import static com.kri.p6.ncrc.pairing.common.consts.PairingConstant.RESULT_SHEET_UNASSIGNED_CENTER;
import static com.kri.p6.ncrc.pairing.common.consts.PairingConstant.RESULT_SHEET_UNUSED_MEMBER;
import static com.kri.p6.ncrc.pairing.common.consts.PairingConstant.RESULT_SHEET_VALIDATION_ERROR;
import com.kri.common.feature.excel.ExcelMapper;
import com.kri.p6.ncrc.pairing.dto.excel.output.RuleViolationExcelDto;
import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.List;
import org.apache.poi.ss.usermodel.Workbook;
import org.apache.poi.ss.usermodel.WorkbookFactory;
import org.assertj.core.api.Assertions;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.autoconfigure.web.servlet.AutoConfigureMockMvc;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.mock.web.MockMultipartFile;
import org.springframework.test.web.servlet.MockMvc;
import org.springframework.test.web.servlet.MvcResult;
import org.springframework.test.web.servlet.request.MockMvcRequestBuilders;
import org.springframework.test.web.servlet.result.MockMvcResultMatchers;
@SpringBootTest
@AutoConfigureMockMvc
class PairingServiceTest {
@Autowired
private MockMvc mockMvc;
@Test
void pairingMemberByCenterCreatesResultWorkbook() throws Exception {
Path sample = Path.of("src/main/resources/sample/기초 data TEST.xlsx");
try (InputStream inputStream = Files.newInputStream(sample)) {
MockMultipartFile file = new MockMultipartFile("file", sample.getFileName().toString(),
"application/vnd.openxmlformats-officedocument.spreadsheetml.sheet", inputStream);
MvcResult mvcResult = mockMvc.perform(MockMvcRequestBuilders.multipart("/api/v1/pairing/run")
.file(file))
.andExpect(MockMvcResultMatchers.status().isOk())
.andReturn();
byte[] result = mvcResult.getResponse().getContentAsByteArray();
Assertions.assertThat(result).isNotEmpty();
Files.createDirectories(Path.of("build"));
Files.write(Files.createTempFile(Path.of("build"), "pairing-result", ".xlsx"), result);
try (Workbook workbook = WorkbookFactory.create(new ByteArrayInputStream(result))) {
Assertions.assertThat(workbook.getSheet(RESULT_SHEET_ASSIGNMENT)).isNotNull();
Assertions.assertThat(workbook.getSheet(RESULT_SHEET_UNASSIGNED_CENTER)).isNotNull();
Assertions.assertThat(workbook.getSheet(RESULT_SHEET_UNUSED_MEMBER)).isNotNull();
Assertions.assertThat(workbook.getSheet(RESULT_SHEET_SUMMARY)).isNotNull();
Assertions.assertThat(workbook.getSheet(RESULT_SHEET_AB_PAIR)).isNotNull();
Assertions.assertThat(workbook.getSheet(RESULT_SHEET_CANDIDATE_SUMMARY)).isNotNull();
Assertions.assertThat(workbook.getSheet(RESULT_SHEET_VALIDATION_ERROR)).isNotNull();
Assertions.assertThat(workbook.getSheet(RESULT_SHEET_RULE_CHECK)).isNotNull();
List<RuleViolationExcelDto> ruleChecks = ExcelMapper.readFromWorkbook(workbook,
RuleViolationExcelDto.class, RESULT_SHEET_RULE_CHECK, 1);
Assertions.assertThat(ruleChecks)
.extracting(RuleViolationExcelDto::getResult)
.doesNotContain("FAIL");
}
}
}
}

View File

@@ -1,110 +0,0 @@
package com.kri.p6.ncrc.pairing.service;
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.model.AssignmentCandidate;
import com.kri.p6.ncrc.pairing.model.Center;
import com.kri.p6.ncrc.pairing.model.Member;
import com.kri.p6.ncrc.pairing.model.Municipality;
import com.kri.p6.ncrc.pairing.model.PairCandidate;
import com.kri.p6.ncrc.pairing.model.PairingCandidates;
import com.kri.p6.ncrc.pairing.model.PairingData;
import com.kri.p6.ncrc.pairing.model.PairingResult;
import java.time.LocalDate;
import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.stream.Collectors;
import org.assertj.core.api.Assertions;
import org.junit.jupiter.api.Test;
class PairingSolverServiceTest {
private final PairingSolverService service = new PairingSolverService(PairingTestSupport.pairingProperties());
@Test
void solveAssignsCenterAtMostOnceAndPairMaxThreeCentersPerDay() {
PairingData data = dataWithCenters("c1", "c2", "c3", "c4");
PairingCandidates candidates = PairingCandidates.builder().pairCandidates(List.of(PairCandidate.builder().fieldMemberId("field").externalMemberId("external").residenceMatchScore(1).build())).dispatchRegionCandidates(List.of()).assignmentCandidates(List.of(assignment("field", "external", "c1", "A"), assignment("field", "external", "c2", "A"), assignment("field", "external", "c3", "A"), assignment("field", "external", "c4", "A"))).build();
PairingResult result = service.solve(data, candidates);
Assertions.assertThat(result.getAssignments()).hasSize(3);
Assertions.assertThat(result.getAssignments()).extracting((assignment) -> assignment.getCenterId()).doesNotHaveDuplicates();
}
@Test
void solveAllowsOnlyOnePairForMemberOnSameDay() {
PairingData data = dataWithMembersAndCenters(List.of(member("field", MemberRole.FIELD), member("external1", MemberRole.EXTERNAL), member("external2", MemberRole.EXTERNAL)), List.of(center("c1"), center("c2")));
PairingCandidates candidates = PairingCandidates.builder().pairCandidates(List.of(PairCandidate.builder().fieldMemberId("field").externalMemberId("external1").build(), PairCandidate.builder().fieldMemberId("field").externalMemberId("external2").build())).dispatchRegionCandidates(List.of()).assignmentCandidates(List.of(assignment("field", "external1", "c1", "A"), assignment("field", "external2", "c2", "A"))).build();
PairingResult result = service.solve(data, candidates);
Assertions.assertThat(result.getAssignments()).hasSize(1);
}
@Test
void solveAllowsOnlyOneAdjacentClassificationPerPairDay() {
PairingData data = dataWithCenters("c1", "c2");
PairingCandidates candidates = PairingCandidates.builder().pairCandidates(List.of(PairCandidate.builder().fieldMemberId("field").externalMemberId("external").build())).dispatchRegionCandidates(List.of()).assignmentCandidates(List.of(assignment("field", "external", "c1", "A"), assignment("field", "external", "c2", "B"))).build();
PairingResult result = service.solve(data, candidates);
Assertions.assertThat(result.getAssignments()).hasSize(1);
}
@Test
void solveLimitsCounterpartsPerMemberToThree() {
PairingData data = dataWithMembersAndCenters(List.of(member("field", MemberRole.FIELD), member("external1", MemberRole.EXTERNAL), member("external2", MemberRole.EXTERNAL), member("external3", MemberRole.EXTERNAL)), List.of(center("c1"), center("c2"), center("c3")));
PairingCandidates candidates = PairingCandidates.builder().pairCandidates(List.of(PairCandidate.builder().fieldMemberId("field").externalMemberId("external1").build(), PairCandidate.builder().fieldMemberId("field").externalMemberId("external2").build(), PairCandidate.builder().fieldMemberId("field").externalMemberId("external3").build())).dispatchRegionCandidates(List.of()).assignmentCandidates(List.of(assignment("field", "external1", "c1", "A", LocalDate.of(2026, 5, 1)), assignment("field", "external2", "c2", "A", LocalDate.of(2026, 5, 2)), assignment("field", "external3", "c3", "A", LocalDate.of(2026, 5, 3)))).build();
PairingResult result = service.solve(data, candidates);
Map<String, Long> counterpartCounts = (Map)result.getAssignments().stream().collect(Collectors.groupingBy((assignment) -> assignment.getExternalMemberId(), Collectors.counting()));
Assertions.assertThat(result.getAssignments()).hasSize(3);
Assertions.assertThat(counterpartCounts).hasSize(3);
}
@Test
void selectAppliesExistingCounterpartsToBuddyLimit() {
PairingCandidates candidates = PairingCandidates.builder().pairCandidates(List.of(PairCandidate.builder().fieldMemberId("field").externalMemberId("external1").build(), PairCandidate.builder().fieldMemberId("field").externalMemberId("external2").build(), PairCandidate.builder().fieldMemberId("field").externalMemberId("external3").build())).dispatchRegionCandidates(List.of()).assignmentCandidates(List.of(assignment("field", "external1", "c1", "A", LocalDate.of(2026, 5, 1)), assignment("field", "external2", "c2", "A", LocalDate.of(2026, 5, 2)), assignment("field", "external3", "c3", "A", LocalDate.of(2026, 5, 3)))).build();
PairingSolverService.SolveSelection selection = service.select(candidates,
Map.of("field", Set.of("external1"), "external1", Set.of("field")));
Assertions.assertThat(selection.selectedAssignments()).hasSize(3);
Assertions.assertThat(selection.selectedAssignments())
.extracting(AssignmentCandidate::getExternalMemberId)
.contains("external1");
Assertions.assertThat(selection.selectedAssignments())
.extracting(AssignmentCandidate::getExternalMemberId)
.containsAnyOf("external2", "external3");
}
@Test
void solveAddsABGroupForSimilarPairsWithoutOverlappingDates() {
PairingData data = dataWithMembersAndCenters(List.of(member("field1", MemberRole.FIELD), member("external1", MemberRole.EXTERNAL), member("field2", MemberRole.FIELD), member("external2", MemberRole.EXTERNAL)), List.of(center("c1"), center("c2")));
PairingCandidates candidates = PairingCandidates.builder().pairCandidates(List.of(PairCandidate.builder().fieldMemberId("field1").externalMemberId("external1").build(), PairCandidate.builder().fieldMemberId("field2").externalMemberId("external2").build())).dispatchRegionCandidates(List.of()).assignmentCandidates(List.of(assignment("field1", "external1", "c1", "A", LocalDate.of(2026, 5, 1)), assignment("field2", "external2", "c2", "A", LocalDate.of(2026, 5, 2)))).build();
PairingResult result = service.solve(data, candidates);
Assertions.assertThat(result.getAssignments()).hasSize(2);
Assertions.assertThat(result.getAssignments()).extracting((assignment) -> assignment.getAbGroup()).containsOnly(new String[]{"AB-001"});
Assertions.assertThat(result.getAssignments()).extracting((assignment) -> assignment.getBackupFieldMemberId()).containsExactlyInAnyOrder(new String[]{"field2", "field1"});
}
private PairingData dataWithCenters(String... centerIds) {
return dataWithMembersAndCenters(List.of(member("field", MemberRole.FIELD), member("external", MemberRole.EXTERNAL)), Arrays.stream(centerIds).map(this::center).toList());
}
private PairingData dataWithMembersAndCenters(List<Member> members, List<Center> centers) {
return PairingData.builder().members(members).municipalities(List.of(Municipality.builder().id("municipality").availableStartDate(LocalDate.of(2026, 5, 1)).availableEndDate(LocalDate.of(2026, 5, 10)).unavailableDates(Set.of()).build())).centers(centers).memberRegionCodes(List.of()).centerAdjacentRegions(List.of()).preferenceMatchRules(List.of()).build();
}
private AssignmentCandidate assignment(String fieldMemberId, String externalMemberId, String centerId, String adjacentRegionClassification) {
return assignment(fieldMemberId, externalMemberId, centerId, adjacentRegionClassification, LocalDate.of(2026, 5, 1));
}
private AssignmentCandidate assignment(String fieldMemberId, String externalMemberId, String centerId, String adjacentRegionClassification, LocalDate date) {
return AssignmentCandidate.builder().fieldMemberId(fieldMemberId).externalMemberId(externalMemberId).centerId(centerId).municipalityId("municipality").date(date).dispatchRegion("01").adjacentRegionClassification(adjacentRegionClassification).preferencePriority(1).residenceMatchScore(0).build();
}
private Member member(String id, MemberRole role) {
return Member.builder().id(id).gender(Gender.FEMALE).experienceType(ExperienceType.EXPERIENCED).role(role).availableStartDate(LocalDate.of(2026, 5, 1)).availableEndDate(LocalDate.of(2026, 5, 10)).unavailableDates(Set.of()).activityRegion("02").historyCenterIds(Set.of()).residenceCode("01101").preferenceRegions(List.of("01", "00", "00", "00")).build();
}
private Center center(String id) {
return Center.builder().id(id).municipalityId("municipality").womenOnly(false).adjacentRegionClassification("A").availableStartDate(LocalDate.of(2026, 5, 1)).availableEndDate(LocalDate.of(2026, 5, 10)).unavailableDates(Set.of()).build();
}
}

View File

@@ -1,14 +0,0 @@
package com.kri.p6.ncrc.pairing.service;
import com.kri.p6.ncrc.pairing.config.PairingProperties;
final class PairingTestSupport {
private PairingTestSupport() {
}
static PairingProperties pairingProperties() {
PairingProperties properties = new PairingProperties();
properties.getSolver().setMaxTimeSeconds(0.5);
return properties;
}
}