260420_01_ENH: split 마감

This commit is contained in:
2026-04-20 16:58:35 +09:00
parent 51a2712066
commit 9e58f5b361
16 changed files with 1881 additions and 640 deletions

449
README.md
View File

@@ -1,336 +1,201 @@
# ncrc-pairing # ncrc-pairing
엑셀 파일을 입력받아 위원 페어 후보와 센터 배정 후보를 만들고, Google OR-Tools CP-SAT으로 배정 결과를 계산하는 Spring Boot API입니다. 엑셀 파일을 입력받아 위원 조편성 및 센터 방문 일정을 생성하는 Spring Boot API입니다.
현재 배정 엔진은 Greedy 중심으로 동작합니다. 모든 위원을 먼저 조편성하고, 이후 가능한 많은 센터를 일정표에 배정합니다. OR-Tools CP-SAT 코드는 유지되어 있지만 전체 배정의 중심 경로는 `PairingScheduleService`입니다.
## 실행 흐름 ## 실행 흐름
1. `PairingController` 1. `PairingController`
- `/api/v1/pairing/run`으로 엑셀 파일을 업로드받습니다. - `/api/v1/pairing/run`으로 엑셀 파일을 업로드받습니다.
- 처리 결과를 엑셀 파일로 반환합니다. - 결과 엑셀 파일을 반환합니다.
2. `PairingService` 2. `PairingService`
- 전체 유스케이스 흐름을 순서대로 호출합니다. - 전체 유스케이스를 순서대로 호출합니다.
- `엑셀 읽기 -> 정규화 -> 공휴일 반영 -> 검증 -> 후보 생성 -> solver 실행 -> 결과 엑셀 생성` - `엑셀 읽기 -> 정규화 -> 공휴일/주말 반영 -> 검증 -> 후보 생성 -> 조편성/스케줄링 -> 결과 엑셀 생성`
3. `PairingExcelService` 3. `PairingExcelService`
- 입력 엑셀의 6개 시트를 `dto.excel` DTO로 읽습니다. - 입력 엑셀 시트를 DTO로 읽습니다.
- 결과 엑셀은 `배정결과`, `미배정센터`, `미사용위원`, `처리요약`, `AB페어목록`, `후보요약`, `검증오류`, `규칙위반검사` 시트로 씁니다. - 결과 시트는 배정결과, 미배정센터, 미사용위원, 처리요약, AB페어목록, 후보요약, 검증오류, 규칙위반검사를 포함합니다.
- `/run`에서 입력/검증 오류가 발생하면 오류 내용을 담은 엑셀 파일을 반환합니다.
4. `PairingNormalizeService` 4. `PairingNormalizeService`
- 엑셀 문자열을 내부 모델로 변환합니다. - 엑셀 문자열을 내부 모델로 변환합니다.
- 날짜, CSV, 성별, 경력여부, 현장/외부 구분, 지역코드, 선호지역을 정리합니다. - 날짜, CSV, 성별, 경력, 현장/외부 구분, 지역코드, 희망지역을 정리합니다.
5. `PairingValidationService` 5. `PairingHolidayService`
- 필수 데이터, 날짜 범위, 지자체 참조, 희망지역 매칭표 등을 검증합니다. - `DatagoHolidayCache`를 통해 공휴일을 조회합니다.
- 실패 시 `BusinessException.badRequest(code, message)`를 사용합니다. - 토/일은 `DatagoHolidayCache#getWeekend`에서 생성해 공통 불가능일로 합칩니다.
- 공휴일 API 조회 실패 시 구동되면 안 된다는 정책에 따라 실패 응답을 냅니다.
6. `PairingHolidayService` 6. `PairingValidationService`
- `DatagoExtentionApiClient.getHoliDayList(year)`로 국공휴일을 조회합니다. - 필수 데이터, 날짜 범위, 지자체 참조, 희망지역 매칭표를 검증합니다.
- 조회된 날짜는 모든 위원/지자체/센터에 공통 적용되는 진행 불가일자로 처리합니다. - 검증 실패는 `BusinessException.badRequest(code, message)`를 사용합니다.
- 공휴일 목록은 `DatagoHolidayCache`에서 공용 `AbstractListCache` 기반으로 캐싱합니다.
7. `PairingCandidateService` 7. `PairingCandidateService`
- solver가 선택할 수 있는 후보만 생성합니다. - 가능한 조, 파견권역, 센터/날짜 후보를 생성합니다.
- 불가능한 조합은 이 단계에서 제거합니다. - 상피제, 여성전용센터, 기방문센터, 날짜 불가, 공휴일/주말 등 명확한 Hard Rule을 후보 단계에서 제거합니다.
8. `PairingSolverService` 8. `PairingMemberPairService`
- OR-Tools CP-SAT 모델을 만들고 최적 배정을 계산합니다. - 모든 위원이 최소 1개 조에 포함되도록 조편성을 먼저 수행합니다.
- 센터/날짜 후보가 많은 조를 우선 선택하고, 위원당 상대 파트너 수 상한을 지킵니다.
## OR-Tools 사용 개요 9. `PairingScheduleService`
- 확정된 조를 기준으로 센터 일정을 Greedy 방식으로 배정합니다.
- 이후 repair pass를 통해 미배정 센터 감소와 방문 수 균형을 보정합니다.
현재 사용하는 라이브러리는 `com.google.ortools:ortools-java`입니다. 10. `PairingSolverService`
- 결과 DTO 생성과 규칙 위반 검사를 담당합니다.
- CP-SAT 기반 선택 로직도 유지하고 있으나 현재 주 경로는 Greedy 스케줄링입니다.
OR-Tools CP-SAT은 "조건을 만족하는 조합 중 점수가 가장 좋은 조합"을 찾는 최적화 solver입니다. 이 프로젝트에서는 각 배정 후보를 boolean 변수로 만듭니다. ## 현재 Hard Rule
예를 들어 어떤 후보가 다음 의미를 가진다고 하면: | 규칙 | 구현 위치 |
| --- | --- |
| 모든 위원은 최소 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` |
```text ## 현재 Soft Rule 우선순위
2026-05-01에 fieldMember=100, externalMember=200 페어가 center=300을 방문한다
1. 배정 센터 수 최대화
2. 위원별 방문 수 균형
3. 희망지역 매칭표 우선순위
4. 희망지역 99 wildcard fallback
5. 거주지 유사도
6. 같은 조/같은 날짜/같은 인접지역 분류 재사용
관련 설정:
```yaml
pairing:
rule:
max-centers-per-pair-per-day: 3
max-counterparts-per-member: 3
max-member-visit-average-ratio-percent: 130
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
``` ```
solver 안에서는 이 후보가 하나의 `BoolVar`가 됩니다. ## Greedy 스케줄링 구조
핵심 파일: `PairingScheduleService`
1. `pairingCandidateService.generate`
- 가능한 후보를 생성합니다.
2. `pairingMemberPairService.select`
- 모든 위원을 먼저 조편성합니다.
3. `assignRemainingCenters`
- 후보가 적은 센터부터 선택합니다.
- 해당 센터에 가능한 후보 중 점수가 가장 높은 후보를 배정합니다.
4. `repairUnassignedCenters`
- 미배정 센터를 넣기 위해 기존 충돌 배정을 최대 2개까지 제거하고 다시 채웁니다.
5. `repairLowVisitMembers`
- 방문 수가 적은 위원이 남은 센터에 들어갈 수 있는지 우선 탐색합니다.
6. `repairByDonorSwap`
- 방문 수가 많은 위원의 배정을 저방문 위원이 포함된 후보로 넘길 수 있는지 봅니다.
7. `repairWildcardFallbackCenters`
- 99 wildcard 후보를 남은 센터에 우선 적용해 봅니다.
## OR-Tools CP-SAT 설명
사용 라이브러리:
```gradle
implementation("com.google.ortools:ortools-java:9.15.6755")
```
CP-SAT는 "조건을 모두 지키면서 가장 점수가 높은 조합을 찾는 도구"입니다.
예를 들어 `A조가 2026-05-01에 100번 센터를 방문한다`라는 후보가 있으면, CP-SAT 안에서는 이 후보가 0/1 변수 하나가 됩니다.
```text ```text
1 = 이 후보를 선택한다 1 = 이 후보를 선택한다
0 = 이 후보를 선택하지 않는다 0 = 이 후보를 선택하지 않는다
``` ```
`PairingSolverService`는 이런 boolean 변수들을 놓고 아래를 수행합니다. 현재 프로젝트에서는 전체 후보가 매우 커질 수 있어 CP-SAT만으로는 시간이 오래 걸릴 수 있습니다. 그래서 주 배정은 Greedy가 담당하고, CP-SAT 코드는 향후 부분 최적화나 비교 실험을 위해 유지합니다.
- hard rule: 반드시 지켜야 하는 제약 CP-SAT 관련 수정 위치:
- soft rule: 지키면 점수가 좋아지는 목표
| 변경 내용 | 수정 위치 |
## 현재 적용된 Hard Rule | --- | --- |
| 후보 0/1 변수 | `PairingSolverService#createAssignmentVars` |
후보 생성 단계와 solver 단계에 나뉘어 적용되어 있습니다. | 센터 중복 금지 | `PairingSolverService#addCenterAssignedAtMostOnce` |
| 하루 방문 센터 수 | `PairingSolverService#addPairDailyCapacity` |
### 후보 생성 단계 | 같은 날짜 위원 중복 금지 | `PairingSolverService#addMemberDailyOnePair` |
| 인접지역 분류 제한 | `PairingSolverService#addPairDailyOneAdjacentClassification` |
위치: `PairingCandidateService` | 상대 파트너 수 제한 | `PairingSolverService#addCumulativeBuddyLimit` |
| 점수 조정 | `PairingSolverService#createObjective` |
- 현장위원 + 외부위원 페어만 생성
- 신규 + 신규 페어 제외 ## 규칙 변경 시 수정 위치
- 두 위원의 일정 범위가 겹치지 않으면 제외
- 파견 권역이 위원의 활동지역과 같으면 제외 | 업무 변경 | 수정 위치 |
- 희망지역 매칭표에 없는 선호 조합 제외 | --- | --- |
- 센터 인접지역표를 통해 파견 권역과 센터 연결 | 엑셀 시트명 변경 | `PairingConstant` |
- 여성 전용 센터는 여성 2명 페어만 허용 | 엑셀 컬럼명 변경 | `dto.excel.input`, `dto.excel.output`의 `@ExcelColumn` |
- 2023년 진행 센터는 해당 위원에게 재배정 금지 | 입력 정규화 변경 | `PairingNormalizeService` |
- 위원/지자체/센터의 시작일, 종료일, 불가일자를 모두 반영 | 공휴일/주말 정책 변경 | `PairingHolidayService`, `DatagoHolidayCache` |
- 국공휴일은 모든 배정 후보에서 제외 | 상피제 변경 | `PairingCandidateService#isConflictRegion`, `hasActivityRegion` |
| 여성전용센터 정책 변경 | `PairingCandidateService#findCenterHardRuleReasons` |
현재 후보 수 폭증을 막기 위해 각 페어/센터 조합에서 가장 빠른 feasible 일자 1개만 후보로 만듭니다. | 기방문센터 제외 정책 변경 | `PairingCandidateService#findCenterHardRuleReasons` |
| 희망지역 00/99 해석 변경 | `PairingCandidateService#findPreferenceRank`, `findPreferenceMatchRule`, `matchesPreferenceRank` |
### Solver 단계 | wildcard 적극 사용 롤백 | `application.yaml`의 `active-wildcard-fallback-enabled: false` |
| 위원당 상대 파트너 수 변경 | `application.yaml`의 `max-counterparts-per-member` |
위치: `PairingSolverService` | 하루 센터 방문 수 변경 | `application.yaml`의 `max-centers-per-pair-per-day` |
| 위원 최대 방문 상한 변경 | `application.yaml`의 `max-member-visit-average-ratio-percent` |
- 한 센터는 최대 1번만 배정 | 배정 점수 튜닝 | `application.yaml`의 `objective.*` |
- 한 페어는 하루 최대 3개 센터만 방문 | repair 전략 변경 | `PairingScheduleService`의 `repair...` 메서드 |
- 한 위원은 같은 날짜에 하나의 페어로만 활동
- 한 페어는 같은 날짜에 하나의 인접지역 분류만 방문
- 한 위원은 전체 기간 동안 최대 2명의 상대 파트너만 가짐
## 현재 적용된 Soft Rule
위치: `PairingSolverService#createObjective`
현재 목적함수는 아래 순서가 강하게 반영되도록 가중치를 둡니다.
1. 배정 센터 수 최대화
2. 희망지역 매칭 순위가 좋은 후보 선호
3. 거주지 앞 3자리 일치 페어 선호
배정 센터 수가 가장 중요하므로 가장 큰 가중치를 사용합니다. 선호도와 거주지 유사도는 배정 수가 같은 후보들 사이에서 더 나은 해를 고르는 보조 점수입니다. 현재 업무 기준상 거주지 유사도도 중요한 soft rule이지만, 배정 센터 수보다 우선하지는 않습니다.
## OR-Tools 관련 주요 파일
### `build.gradle`
OR-Tools 의존성을 관리합니다.
```gradle
implementation("com.google.ortools:ortools-java:9.15.6755")
```
OR-Tools 버전을 바꾸면 native library 로딩 방식이나 Java API가 바뀔 수 있으므로 `PairingSolverService` 컴파일과 테스트를 반드시 확인해야 합니다.
### `OrToolsConfig`
Spring Boot 기동 시 `Loader.loadNativeLibraries()`를 실행합니다.
OR-Tools는 Java 라이브러리처럼 보이지만 내부적으로 OS별 native library를 사용합니다. 이 로딩이 빠지면 `UnsatisfiedLinkError`가 발생합니다.
### `PairingSolverService`
실제 CP-SAT 모델을 구성합니다.
수정이 필요한 대표 위치:
- 변수 추가/변경: `createAssignmentVars`, `createPairUsedVars`, `createPairDayVars`
- hard rule 추가: `add...` 형태의 constraint 메서드 추가
- soft rule 변경: `createObjective`
- solver 시간 제한 변경: `solver.getParameters().setMaxTimeInSeconds(...)`
- 결과 해석 변경: `collectSelectedAssignments`, `toResult`
## 결과 엑셀 시트
정상 처리 결과는 항상 아래 8개 시트를 포함합니다.
- `배정결과`: 최종 센터 배정 결과와 위원/센터 주요 속성, AB 보완 페어 정보
- `미배정센터`: 최종 배정되지 않은 센터와 누적 미배정 사유
- `미사용위원`: 최종 배정에 포함되지 않은 위원
- `처리요약`: 전체 입력/후보/배정/AB 그룹 요약
- `AB페어목록`: 후처리로 묶인 AB 페어 그룹 목록
- `후보요약`: 후보 생성 및 solver 입력 규모
- `검증오류`: 정상 처리 시 빈 시트, 입력/검증 오류 엑셀에서는 오류 내용
- `규칙위반검사`: 결과가 hard rule을 위반하지 않았는지 PASS/FAIL 검사
`/run`에서 엑셀 파싱이나 입력 검증 오류가 발생하면 HTTP 200으로 오류 엑셀을 반환합니다. 공휴일 API 실패 같은 시스템 오류는 숨기지 않고 실패 응답으로 처리합니다.
## 업무 조건 변경 시 수정 위치
### 자주 조정될 수 있는 값
아래 값들은 `application.yaml`의 `pairing.*` 설정으로 관리합니다.
```yaml
pairing:
excel:
header-row-index: 1
code:
region-code-length: 2
residence-code-length: 5
residence-match-prefix-length: 3
any-region-code: "00"
rule:
max-centers-per-pair-per-day: 3
max-counterparts-per-member: 2
preference:
anywhere-rank: 0
ignored-rank: 99
objective:
assignment-weight: 1000000
preference-base-weight: 1000
preference-rank-penalty: 100
residence-match-weight: 10000
solver:
max-time-seconds: 30.0
num-search-workers: 15
```
배정 센터 수 최우선 원칙을 유지하려면 `objective.assignment-weight`가 선호지역, 거주지, 향후 추가될 soft score의 최대 합보다 충분히 커야 합니다.
### 엑셀 시트명 또는 컬럼명이 바뀌는 경우
수정 위치:
- `PairingConstant`
- `dto.excel.*`
- `PairingExcelService`
시트명이 바뀌면 `PairingConstant`의 `SHEET_*` 값을 수정합니다. 컬럼명이 바뀌면 해당 `dto.excel` 클래스의 `@ExcelColumn(header = "...")` 값을 수정합니다.
### 결과 엑셀 시트를 바꾸는 경우
수정 위치:
- `PairingConstant`
- `dto.*ExcelDto`
- `PairingExcelService#write`
- `PairingSolverService#toResult`
### 지역 코드 자리수가 바뀌는 경우
수정 위치:
- `PairingConstant`
- `PairingNormalizeService`
- `PairingCandidateService`
현재 활동지역/선호지역은 2자리, 거주지는 5자리, 거주지 비교는 앞 3자리 기준입니다.
### 선호지역 `00` 규칙이 바뀌는 경우
수정 위치:
- `PairingNormalizeService#normalizePreferenceRegions`
- `PairingCandidateService#findPreferenceRank`
현재는 `00`이 나오면 그 위치와 뒤쪽 선호지역을 모두 `00`으로 처리합니다.
### 희망지역 매칭표 해석이 바뀌는 경우
수정 위치:
- `PairingCandidateService#findPreferenceRank`
- `PairingCandidateService#findPreferenceMatchRule`
- `PairingSolverService#createObjective`
현재는 현장위원 rank와 외부위원 rank를 구한 뒤, 엑셀의 `희망지역 매칭표`에서 매칭 순위를 찾습니다.
현재 rank 해석:
- `0`: 위원이 선호지역에 `00`을 입력한 anywhere 응답
- `99`: 해당 위원의 선호지역을 고려하지 않는 wildcard 조건
### 하루 최대 센터 수가 바뀌는 경우
수정 위치:
- `application.yaml`의 `pairing.rule.max-centers-per-pair-per-day`
- `PairingSolverService#addPairDailyCapacity`
### 한 위원의 상대 파트너 수 제한이 바뀌는 경우
수정 위치:
- `application.yaml`의 `pairing.rule.max-counterparts-per-member`
- `PairingSolverService#addBuddyLimit`
### 하루 1개 지역 제한 기준이 바뀌는 경우
수정 위치:
- `AssignmentCandidate`
- `PairingCandidateService#createAssignmentCandidates`
- `PairingSolverService#addPairDailyOneAdjacentClassification`
현재는 `인접지역 분류` 기준입니다. 나중에 권역 단위로 바뀌면 `pairDayAdjacentKey`가 사용하는 값을 바꿔야 합니다.
### 불가일자 또는 일정 조건이 바뀌는 경우
수정 위치:
- `PairingNormalizeService#parseDateSet`
- `PairingHolidayService`
- `PairingCandidateService#findFirstAssignableDate`
- `PairingCandidateService#isAvailableOn`
국공휴일 조회 방식이 바뀌면 `PairingHolidayService`와 `DatagoExtentionApiClient`를 함께 확인해야 합니다.
캐시 동작을 바꾸려면 `DatagoHolidayCache`를 확인합니다.
### 여성 전용 센터 규칙이 바뀌는 경우
수정 위치:
- `PairingNormalizeService#parseBooleanFlag`
- `PairingCandidateService#isAssignableCenter`
### 2023년 진행 센터 제외 규칙이 바뀌는 경우
수정 위치:
- `PairingNormalizeService#parseCsv`
- `PairingCandidateService#isAssignableCenter`
### A/B pair 운영 로직을 추가하는 경우
수정 위치:
- `PairingCandidateService`
- `PairingSolverService`
- 필요 시 `model`에 `ABPairCandidate` 추가
현재 A/B pair는 solver 결과 후처리로 구성합니다. 같은 파견 권역과 같은 인접지역 분류를 공유하고, 배정 날짜가 겹치지 않는 페어끼리 `AB 그룹`으로 묶습니다. 이는 A/B가 완전 대체 전담 관계가 아니라, 각자 배정은 유지하되 유사시에 서로 공백을 보완할 수 있는 관계라는 업무 해석을 따른 것입니다.
### 인접지역 분류 랜덤 선택을 엄격하게 적용하는 경우
수정 위치:
- `PairingCandidateService#createAssignmentCandidates`
- `PairingSolverService`
- 별도 후처리 서비스 추가 가능
현재 solver는 랜덤 없이 최적 선택을 하며, 같은 날짜/페어에 대해 하나의 인접지역 분류만 선택하도록 hard rule을 걸고 있습니다. 따라서 한 팀이 여러 인접지역 분류 그룹을 갈 수 있는 경우에도 solver가 objective에 가장 유리한 하나의 그룹만 선택합니다.
## 현재 구현상 주의점
- 모든 가능한 날짜를 후보로 만들지 않고, 각 페어/센터 조합의 가장 빠른 feasible 일자만 후보로 만듭니다.
- 이 방식은 후보 수를 줄여 빠르게 동작하지만, 날짜 선택 자유도가 낮아 실제 최적 배정률이 떨어질 수 있습니다.
- 배정률이 부족하면 `PairingCandidateService#findFirstAssignableDate`를 확장해 feasible 일자 여러 개를 후보로 생성해야 합니다.
- A/B pair는 현재 후처리 방식입니다. 배정 자체를 막는 hard constraint가 아니며, 결과 엑셀의 `AB 그룹`, `보완 현장위원 id`, `보완 외부위원 id` 컬럼으로 표시합니다.
- 결과 엑셀은 성공 시 파일로 반환합니다. 입력/검증 오류는 오류 엑셀로 반환하고, 시스템 오류는 공통 `BusinessException` 실패 응답을 사용합니다.
## 테스트 ## 테스트
컴파일:
```powershell
.\gradlew.bat compileJava
```
전체 테스트: 전체 테스트:
```powershell ```powershell
.\gradlew.bat clean test .\gradlew.bat test
``` ```
샘플 엑셀 전체 흐름 테스트: 샘플 엑셀 기반 테스트:
```powershell ```powershell
.\gradlew.bat test --tests "com.kri.p6.ncrc.pairing.service.PairingServiceTest.pairingMemberByCenterCreatesResultWorkbook" .\gradlew.bat test --tests com.kri.p6.ncrc.pairing.service.PairingServiceTest
``` ```
실제 API 실행 테스트: 결과 파일은 테스트 실행 시 `build/pairing-result*.xlsx`로 생성됩니다.
```powershell
.\gradlew.bat bootJar
java -jar build/libs/ncrc-pairing-0.0.1-SNAPSHOT.jar
curl.exe -X POST "http://localhost:6111/api/v1/pairing/run" -F "file=@src/main/resources/sample/기초 data dummy.xlsx" -o build/api-result.xlsx
```

View File

@@ -68,5 +68,5 @@ dependencies {
tasks.named('test') { tasks.named('test') {
useJUnitPlatform() useJUnitPlatform()
maxHeapSize = '4g' maxHeapSize = '8g'
} }

View File

@@ -18,6 +18,8 @@ public final class PairingConstant {
public static final String RESULT_SHEET_VALIDATION_ERROR = "검증오류"; public static final String RESULT_SHEET_VALIDATION_ERROR = "검증오류";
public static final String RESULT_SHEET_RULE_CHECK = "규칙위반검사"; public static final String RESULT_SHEET_RULE_CHECK = "규칙위반검사";
public static final String RESULT_SHEET_APPLIED_SETTING = "적용설정";
private PairingConstant() { private PairingConstant() {
} }
} }

View File

@@ -36,7 +36,8 @@ public class PairingProperties {
@Setter @Setter
public static class Rule { public static class Rule {
private int maxCentersPerPairPerDay = 3; private int maxCentersPerPairPerDay = 3;
private int maxCounterpartsPerMember = 2; private int maxCounterpartsPerMember = 3;
private int maxMemberVisitAverageRatioPercent = 130;
} }
@Getter @Getter
@@ -44,26 +45,28 @@ public class PairingProperties {
public static class Preference { public static class Preference {
private int anywhereRank = 0; private int anywhereRank = 0;
private int ignoredRank = 99; private int ignoredRank = 99;
private boolean activeWildcardFallbackEnabled = false;
private long wildcardFallbackScoreBonus = 25_000L;
} }
@Getter @Getter
@Setter @Setter
public static class Objective { public static class Objective {
private long assignmentWeight = 1_000_000L; private long assignmentWeight = 1_000_000L;
private long preferenceBaseWeight = 10_000L; private long preferenceBaseWeight = 30_000L;
private long preferenceRankPenalty = 100L; private long preferenceRankPenalty = 1_000L;
private long residenceMatchWeight = 1_000L; private long residenceMatchWeight = 10_000L;
private long usedMemberWeight = 300_000L; private long memberBalanceWeight = 20_000L;
private long memberBalanceWeight = 1_000L;
} }
@Getter @Getter
@Setter @Setter
public static class Candidate { public static class Candidate {
private int maxDispatchRegionsPerPair = 5; private int maxPairCandidatesPerMember = 0;
private int maxAssignmentsPerCenter = 30; private int maxDispatchRegionsPerPair = 0;
private int maxAssignmentsPerMember = 80; private int maxAssignmentsPerCenter = 1_000;
private int maxDatesPerAssignmentCandidate = 5; private int maxAssignmentsPerMember = 3_000;
private int maxDatesPerAssignmentCandidate = 80;
} }
@Getter @Getter

View File

@@ -0,0 +1,21 @@
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,6 +1,7 @@
package com.kri.p6.ncrc.pairing.model; 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.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.AssignmentResultExcelDto;
import com.kri.p6.ncrc.pairing.dto.excel.output.CandidateSummaryExcelDto; import com.kri.p6.ncrc.pairing.dto.excel.output.CandidateSummaryExcelDto;
import com.kri.p6.ncrc.pairing.dto.excel.output.PairingSummaryExcelDto; import com.kri.p6.ncrc.pairing.dto.excel.output.PairingSummaryExcelDto;
@@ -22,6 +23,7 @@ public class PairingResult {
private final List<PairingSummaryExcelDto> summaries; private final List<PairingSummaryExcelDto> summaries;
private final List<ABPairExcelDto> abPairs; private final List<ABPairExcelDto> abPairs;
private final List<CandidateSummaryExcelDto> candidateSummaries; private final List<CandidateSummaryExcelDto> candidateSummaries;
private final List<AppliedSettingExcelDto> appliedSettings;
private final List<ValidationErrorExcelDto> validationErrors; private final List<ValidationErrorExcelDto> validationErrors;
private final List<RuleViolationExcelDto> ruleViolations; private final List<RuleViolationExcelDto> ruleViolations;

View File

@@ -22,6 +22,7 @@ import java.util.LinkedHashSet;
import java.util.List; import java.util.List;
import java.util.Map; import java.util.Map;
import java.util.Optional; import java.util.Optional;
import java.util.PriorityQueue;
import java.util.Set; import java.util.Set;
import java.util.function.Function; import java.util.function.Function;
import java.util.stream.Collectors; import java.util.stream.Collectors;
@@ -35,7 +36,10 @@ public class PairingCandidateService {
private final PairingProperties pairingProperties; private final PairingProperties pairingProperties;
public PairingCandidates generate(PairingData data) { public PairingCandidates generate(PairingData data) {
List<PairCandidate> pairCandidates = createPairCandidates(data.getMembers()); // 후보 생성은 "가능한 조합을 넓게 만들고, 명백히 불가능한 조합만 제거"하는 단계입니다.
// 이후 PairingScheduleService가 이 후보들 중 실제 방문 일정을 선택합니다.
List<PairCandidate> pairCandidates = trimPairCandidates(
createPairCandidates(data.getMembers()), data.getMembers());
List<DispatchRegionCandidate> dispatchRegionCandidates = trimDispatchRegionCandidates( List<DispatchRegionCandidate> dispatchRegionCandidates = trimDispatchRegionCandidates(
createDispatchRegionCandidates(data, pairCandidates)); createDispatchRegionCandidates(data, pairCandidates));
Map<String, Set<String>> unassignedCenterReasons = createInitialCenterReasonMap(data); Map<String, Set<String>> unassignedCenterReasons = createInitialCenterReasonMap(data);
@@ -53,6 +57,8 @@ public class PairingCandidateService {
} }
private List<PairCandidate> createPairCandidates(List<Member> members) { private List<PairCandidate> createPairCandidates(List<Member> members) {
// 현장위원 1명 + 외부위원 1명을 기본 조로 봅니다.
// 두 위원의 활동 가능 기간이 전혀 겹치지 않으면 이후 센터 배정이 불가능하므로 제외합니다.
List<Member> fieldMembers = members.stream() List<Member> fieldMembers = members.stream()
.filter(member -> member.getRole() == MemberRole.FIELD).toList(); .filter(member -> member.getRole() == MemberRole.FIELD).toList();
List<Member> externalMembers = members.stream() List<Member> externalMembers = members.stream()
@@ -75,6 +81,8 @@ public class PairingCandidateService {
private List<DispatchRegionCandidate> createDispatchRegionCandidates(PairingData data, private List<DispatchRegionCandidate> createDispatchRegionCandidates(PairingData data,
List<PairCandidate> pairCandidates) { List<PairCandidate> pairCandidates) {
// 조가 갈 수 있는 파견 권역 후보를 만듭니다.
// 상피제(위원 활동지역과 파견 권역 일치)는 여기서 제거합니다.
Map<String, Member> memberMap = toMemberMap(data.getMembers()); Map<String, Member> memberMap = toMemberMap(data.getMembers());
Set<String> dispatchRegions = data.getCenterAdjacentRegions().stream() Set<String> dispatchRegions = data.getCenterAdjacentRegions().stream()
.map(CenterAdjacentRegion::getDispatchRegion).collect(Collectors.toSet()); .map(CenterAdjacentRegion::getDispatchRegion).collect(Collectors.toSet());
@@ -92,6 +100,8 @@ public class PairingCandidateService {
Optional<PreferenceMatchRule> matchRule = findPreferenceMatchRule( Optional<PreferenceMatchRule> matchRule = findPreferenceMatchRule(
data.getPreferenceMatchRules(), fieldRank, externalRank); data.getPreferenceMatchRules(), fieldRank, externalRank);
// fieldRank/externalRank가 -1이어도 희망지역 매칭표의 99(wildcard) 규칙은 적용될 수 있습니다.
// 99는 "해당 위원의 희망지역을 고려하지 않음"이라는 후순위 fallback입니다.
candidates.add(DispatchRegionCandidate.builder().fieldMemberId(fieldMember.getId()) candidates.add(DispatchRegionCandidate.builder().fieldMemberId(fieldMember.getId())
.externalMemberId(externalMember.getId()).dispatchRegion(dispatchRegion) .externalMemberId(externalMember.getId()).dispatchRegion(dispatchRegion)
.preferencePriority(matchRule.map(PreferenceMatchRule::getPriority) .preferencePriority(matchRule.map(PreferenceMatchRule::getPriority)
@@ -111,6 +121,8 @@ public class PairingCandidateService {
List<DispatchRegionCandidate> dispatchRegionCandidates, List<DispatchRegionCandidate> dispatchRegionCandidates,
Map<String, Set<String>> unassignedCenterReasons Map<String, Set<String>> unassignedCenterReasons
) { ) {
// 파견 권역 후보를 실제 센터와 날짜 후보로 확장합니다.
// 여성전용, 기방문센터, 위원/지자체/센터 불가능일, 공휴일/주말은 이 단계에서 제외합니다.
Map<String, Member> memberMap = toMemberMap(data.getMembers()); Map<String, Member> memberMap = toMemberMap(data.getMembers());
Map<String, Municipality> municipalityMap = data.getMunicipalities().stream() Map<String, Municipality> municipalityMap = data.getMunicipalities().stream()
.collect(Collectors.toMap(Municipality::getId, Function.identity(), (left, right) -> left)); .collect(Collectors.toMap(Municipality::getId, Function.identity(), (left, right) -> left));
@@ -120,8 +132,13 @@ public class PairingCandidateService {
.stream().collect(Collectors.groupingBy(CenterAdjacentRegion::getDispatchRegion, .stream().collect(Collectors.groupingBy(CenterAdjacentRegion::getDispatchRegion,
Collectors.mapping(CenterAdjacentRegion::getAdjacentRegionClassification, Collectors.mapping(CenterAdjacentRegion::getAdjacentRegionClassification,
Collectors.toSet()))); Collectors.toSet())));
Map<String, List<Center>> centersByAdjacentClassification = data.getCenters().stream()
.collect(Collectors.groupingBy(Center::getAdjacentRegionClassification,
LinkedHashMap::new, Collectors.toList()));
Set<LocalDate> commonUnavailableDates = commonUnavailableDates(data);
List<AssignmentCandidate> candidates = new ArrayList<>(); Map<String, PriorityQueue<AssignmentCandidate>> centerCandidateBuckets = new LinkedHashMap<>();
Map<String, PriorityQueue<AssignmentCandidate>> memberCandidateBuckets = new LinkedHashMap<>();
for (DispatchRegionCandidate dispatchCandidate : dispatchRegionCandidates) { for (DispatchRegionCandidate dispatchCandidate : dispatchRegionCandidates) {
Member fieldMember = memberMap.get(dispatchCandidate.getFieldMemberId()); Member fieldMember = memberMap.get(dispatchCandidate.getFieldMemberId());
@@ -132,7 +149,8 @@ public class PairingCandidateService {
Set<String> adjacentClassifications = adjacentClassificationsByDispatchRegion Set<String> adjacentClassifications = adjacentClassificationsByDispatchRegion
.getOrDefault(dispatchCandidate.getDispatchRegion(), Set.of()); .getOrDefault(dispatchCandidate.getDispatchRegion(), Set.of());
for (Center center : data.getCenters()) { for (Center center : centersForDispatch(adjacentClassifications,
centersByAdjacentClassification)) {
if (!adjacentClassifications.contains(center.getAdjacentRegionClassification())) { if (!adjacentClassifications.contains(center.getAdjacentRegionClassification())) {
addReason(unassignedCenterReasons, center.getId(), "파견 권역과 센터 인접지역 분류 불일치"); addReason(unassignedCenterReasons, center.getId(), "파견 권역과 센터 인접지역 분류 불일치");
} else { } else {
@@ -145,13 +163,14 @@ public class PairingCandidateService {
reason -> addReason(unassignedCenterReasons, center.getId(), reason)); reason -> addReason(unassignedCenterReasons, center.getId(), reason));
} else { } else {
List<LocalDate> assignableDates = findAssignableDates(fieldMember, List<LocalDate> assignableDates = findAssignableDates(fieldMember,
externalMember, municipality, center, commonUnavailableDates(data)); externalMember, municipality, center, commonUnavailableDates);
if (assignableDates.isEmpty()) { if (assignableDates.isEmpty()) {
addReason(unassignedCenterReasons, center.getId(), addReason(unassignedCenterReasons, center.getId(),
"위원/지자체/센터 일정 또는 국공휴일 조건 불일치"); "위원/지자체/센터 일정 또는 국공휴일 조건 불일치");
} else { } else {
for (LocalDate assignableDate : assignableDates) { for (LocalDate assignableDate : assignableDates) {
candidates.add(AssignmentCandidate.builder().fieldMemberId(fieldMember.getId()) addBoundedAssignmentCandidate(centerCandidateBuckets, memberCandidateBuckets,
AssignmentCandidate.builder().fieldMemberId(fieldMember.getId())
.externalMemberId(externalMember.getId()).centerId(center.getId()) .externalMemberId(externalMember.getId()).centerId(center.getId())
.municipalityId(center.getMunicipalityId()).date(assignableDate) .municipalityId(center.getMunicipalityId()).date(assignableDate)
.dispatchRegion(dispatchCandidate.getDispatchRegion()) .dispatchRegion(dispatchCandidate.getDispatchRegion())
@@ -168,7 +187,7 @@ public class PairingCandidateService {
} }
} }
return candidates; return mergeAssignmentCandidateBuckets(centerCandidateBuckets, memberCandidateBuckets);
} }
private List<AssignmentCandidate> preferResidenceMatchesByCenter( private List<AssignmentCandidate> preferResidenceMatchesByCenter(
@@ -195,6 +214,116 @@ public class PairingCandidateService {
.toList(); .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, private List<AssignmentCandidate> trimAssignmentCandidates(List<AssignmentCandidate> candidates,
List<Center> centers, Map<String, Set<String>> unassignedCenterReasons) { List<Center> centers, Map<String, Set<String>> unassignedCenterReasons) {
List<AssignmentCandidate> trimmedByCenter = trimAssignmentsPerCenter(candidates); List<AssignmentCandidate> trimmedByCenter = trimAssignmentsPerCenter(candidates);
@@ -375,13 +504,14 @@ public class PairingCandidateService {
private Optional<PreferenceMatchRule> findPreferenceMatchRule(List<PreferenceMatchRule> rules, private Optional<PreferenceMatchRule> findPreferenceMatchRule(List<PreferenceMatchRule> rules,
int fieldRank, int externalRank) { int fieldRank, int externalRank) {
return fieldRank >= 0 && externalRank >= 0 ? // 99 규칙은 wildcard입니다. 예를 들어 fieldRank가 -1이어도
rules.stream().filter( // 매칭표에 99/1 규칙이 있으면 "현장위원 선호지역 고려하지 않음 + 외부위원 1순위"로 인정합니다.
return rules.stream().filter(
rule -> matchesPreferenceRank(rule.getFieldMemberPreferenceRank(), fieldRank) rule -> matchesPreferenceRank(rule.getFieldMemberPreferenceRank(), fieldRank)
) )
.filter(rule -> matchesPreferenceRank(rule.getExternalMemberPreferenceRank(),externalRank)) .filter(rule -> matchesPreferenceRank(rule.getExternalMemberPreferenceRank(), externalRank))
.min(Comparator.comparingInt(PreferenceMatchRule::getPriority)) .min(Comparator.comparingInt(PreferenceMatchRule::getPriority))
: Optional.empty(); ;
} }
private int fallbackPreferencePriority(List<PreferenceMatchRule> rules) { private int fallbackPreferencePriority(List<PreferenceMatchRule> rules) {
@@ -425,14 +555,30 @@ public class PairingCandidateService {
if (isAvailableOn(date, fieldMember, externalMember, municipality, center, if (isAvailableOn(date, fieldMember, externalMember, municipality, center,
commonUnavailableDates)) { commonUnavailableDates)) {
dates.add(date); dates.add(date);
if (dates.size() >= maxDatesPerAssignmentCandidate()) {
break;
}
} }
} }
} }
return dates; 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, private boolean isAvailableOn(LocalDate date, Member fieldMember, Member externalMember,
@@ -520,10 +666,22 @@ public class PairingCandidateService {
return pairingProperties.getCandidate().getMaxAssignmentsPerMember(); return pairingProperties.getCandidate().getMaxAssignmentsPerMember();
} }
private int maxPairCandidatesPerMember() {
return pairingProperties.getCandidate().getMaxPairCandidatesPerMember();
}
private int maxDatesPerAssignmentCandidate() { private int maxDatesPerAssignmentCandidate() {
return pairingProperties.getCandidate().getMaxDatesPerAssignmentCandidate(); 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() { private Comparator<DispatchRegionCandidate> dispatchRegionCandidateComparator() {
return Comparator.comparingInt(this::dispatchRegionCandidateScore).reversed() return Comparator.comparingInt(this::dispatchRegionCandidateScore).reversed()
.thenComparing(DispatchRegionCandidate::getDispatchRegion); .thenComparing(DispatchRegionCandidate::getDispatchRegion);
@@ -537,20 +695,72 @@ public class PairingCandidateService {
.thenComparing(AssignmentCandidate::getExternalMemberId); .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) { private int dispatchRegionCandidateScore(DispatchRegionCandidate candidate) {
return preferenceScore(candidate.getPreferencePriority()) return preferenceScore(candidate.getPreferencePriority())
+ preferenceRankBonus(candidate.getFieldMemberPreferenceRank()) + preferenceRankBonus(candidate.getFieldMemberPreferenceRank())
+ preferenceRankBonus(candidate.getExternalMemberPreferenceRank()); + 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) { private int assignmentCandidateScore(AssignmentCandidate candidate) {
return preferenceScore(candidate.getPreferencePriority()) return preferenceScore(candidate.getPreferencePriority())
+ preferenceRankBonus(candidate.getFieldMemberPreferenceRank()) + preferenceRankBonus(candidate.getFieldMemberPreferenceRank())
+ preferenceRankBonus(candidate.getExternalMemberPreferenceRank()) + preferenceRankBonus(candidate.getExternalMemberPreferenceRank())
+ wildcardFallbackBonus(candidate)
+ candidate.getResidenceMatchScore() * (int) pairingProperties.getObjective() + candidate.getResidenceMatchScore() * (int) pairingProperties.getObjective()
.getResidenceMatchWeight(); .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) { private int preferenceScore(int priority) {
return (int) Math.max(0L, pairingProperties.getObjective().getPreferenceBaseWeight() return (int) Math.max(0L, pairingProperties.getObjective().getPreferenceBaseWeight()
- priority * pairingProperties.getObjective().getPreferenceRankPenalty()); - priority * pairingProperties.getObjective().getPreferenceRankPenalty());
@@ -568,6 +778,19 @@ public class PairingCandidateService {
return Math.max(0, 10 - rank); 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) { private LocalDate max(LocalDate left, LocalDate right) {
return left.isAfter(right) ? left : right; return left.isAfter(right) ? left : right;
} }

View File

@@ -1,6 +1,7 @@
package com.kri.p6.ncrc.pairing.service; 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_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_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_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_RULE_CHECK;
@@ -26,6 +27,7 @@ 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.PairingWorkbookData;
import com.kri.p6.ncrc.pairing.dto.excel.input.PreferenceMatchExcelDto; 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.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.AssignmentResultExcelDto;
import com.kri.p6.ncrc.pairing.dto.excel.output.CandidateSummaryExcelDto; import com.kri.p6.ncrc.pairing.dto.excel.output.CandidateSummaryExcelDto;
import com.kri.p6.ncrc.pairing.dto.excel.output.PairingSummaryExcelDto; import com.kri.p6.ncrc.pairing.dto.excel.output.PairingSummaryExcelDto;
@@ -93,6 +95,8 @@ public class PairingExcelService {
RESULT_SHEET_AB_PAIR, headerRowIndex()); RESULT_SHEET_AB_PAIR, headerRowIndex());
ExcelMapper.appendSheetToWorkbook(workbook, result.getCandidateSummaries(), ExcelMapper.appendSheetToWorkbook(workbook, result.getCandidateSummaries(),
CandidateSummaryExcelDto.class, RESULT_SHEET_CANDIDATE_SUMMARY, headerRowIndex()); CandidateSummaryExcelDto.class, RESULT_SHEET_CANDIDATE_SUMMARY, headerRowIndex());
ExcelMapper.appendSheetToWorkbook(workbook, result.getAppliedSettings(),
AppliedSettingExcelDto.class, RESULT_SHEET_APPLIED_SETTING, headerRowIndex());
ExcelMapper.appendSheetToWorkbook(workbook, result.getValidationErrors(), ExcelMapper.appendSheetToWorkbook(workbook, result.getValidationErrors(),
ValidationErrorExcelDto.class, RESULT_SHEET_VALIDATION_ERROR, headerRowIndex()); ValidationErrorExcelDto.class, RESULT_SHEET_VALIDATION_ERROR, headerRowIndex());
ExcelMapper.appendSheetToWorkbook(workbook, result.getRuleViolations(), ExcelMapper.appendSheetToWorkbook(workbook, result.getRuleViolations(),
@@ -114,6 +118,7 @@ public class PairingExcelService {
.summaries(List.of(new PairingSummaryExcelDto("처리 상태", "검증 실패"))) .summaries(List.of(new PairingSummaryExcelDto("처리 상태", "검증 실패")))
.abPairs(List.of()) .abPairs(List.of())
.candidateSummaries(List.of()) .candidateSummaries(List.of())
.appliedSettings(appliedSettings())
.validationErrors(List.of(new ValidationErrorExcelDto(code, message, "ERROR"))) .validationErrors(List.of(new ValidationErrorExcelDto(code, message, "ERROR")))
.ruleViolations(List.of()) .ruleViolations(List.of())
.build(); .build();
@@ -135,6 +140,93 @@ public class PairingExcelService {
return pairingProperties.getExcel().getHeaderRowIndex(); 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",
"희망지역 매칭 품질에 부여하는 기본 점수",
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) { private boolean isBlankRow(Object row) {
return Arrays.stream(row.getClass().getDeclaredFields()) return Arrays.stream(row.getClass().getDeclaredFields())
.allMatch(field -> isBlankField(row, field)); .allMatch(field -> isBlankField(row, field));

View File

@@ -0,0 +1,140 @@
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

@@ -11,6 +11,7 @@ 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.Gender;
import com.kri.p6.ncrc.pairing.config.PairingProperties; 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.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.AssignmentResultExcelDto;
import com.kri.p6.ncrc.pairing.dto.excel.output.CandidateSummaryExcelDto; import com.kri.p6.ncrc.pairing.dto.excel.output.CandidateSummaryExcelDto;
import com.kri.p6.ncrc.pairing.dto.excel.output.PairingSummaryExcelDto; import com.kri.p6.ncrc.pairing.dto.excel.output.PairingSummaryExcelDto;
@@ -52,7 +53,7 @@ public class PairingSolverService {
if (!selection.hasSolution()) { if (!selection.hasSolution()) {
return emptyResult(data, candidates, selection.status()); return emptyResult(data, candidates, selection.status());
} }
return toResult(data, candidates, selection.selectedAssignments(), selection.status()); return toResult(data, candidates, selection.selectedAssignments(), selection.status(), Set.of());
} }
public SolveSelection select(PairingCandidates candidates) { public SolveSelection select(PairingCandidates candidates) {
@@ -61,65 +62,40 @@ public class PairingSolverService {
public SolveSelection select(PairingCandidates candidates, public SolveSelection select(PairingCandidates candidates,
Map<String, Set<String>> existingCounterpartsByMember) { Map<String, Set<String>> existingCounterpartsByMember) {
return select(candidates, existingCounterpartsByMember, Map.of(), Set.of()); return select(candidates, existingCounterpartsByMember, Map.of());
} }
public SolveSelection select(PairingCandidates candidates, public SolveSelection select(PairingCandidates candidates,
Map<String, Set<String>> existingCounterpartsByMember, Map<String, Integer> visitCountsByMember, Map<String, Set<String>> existingCounterpartsByMember,
Set<String> mandatoryMemberIds) { Map<String, Integer> visitCountsByMember) {
return select(candidates, existingCounterpartsByMember, visitCountsByMember, mandatoryMemberIds,
true);
}
private SolveSelection select(PairingCandidates candidates,
Map<String, Set<String>> existingCounterpartsByMember, Map<String, Integer> visitCountsByMember,
Set<String> mandatoryMemberIds, boolean enforceCounterpartLimit) {
if (candidates.getAssignmentCandidates().isEmpty()) { if (candidates.getAssignmentCandidates().isEmpty()) {
return new SolveSelection(false, List.of(), "배정 가능한 후보가 없습니다."); return new SolveSelection(false, List.of(), "배정 가능한 후보가 없습니다.");
} }
CpModel model = new CpModel(); CpModel model = new CpModel();
List<AssignmentCandidate> assignmentCandidates = candidates.getAssignmentCandidates(); List<AssignmentCandidate> assignmentCandidates = candidates.getAssignmentCandidates();
// CP-SAT에서는 각 배정 후보를 0/1 변수로 봅니다.
// 1이면 해당 후보 선택, 0이면 미선택입니다.
BoolVar[] assignmentVars = createAssignmentVars(model, assignmentCandidates); BoolVar[] assignmentVars = createAssignmentVars(model, assignmentCandidates);
Map<String, BoolVar> pairUsedVars = createPairUsedVars(model, assignmentCandidates); Map<String, BoolVar> pairUsedVars = createPairUsedVars(model, assignmentCandidates);
Map<String, BoolVar> pairDayVars = createPairDayVars(model, assignmentCandidates); Map<String, BoolVar> pairDayVars = createPairDayVars(model, assignmentCandidates);
Map<String, BoolVar> pairDayAdjacentVars = createPairDayAdjacentVars(model, assignmentCandidates); Map<String, BoolVar> pairDayAdjacentVars = createPairDayAdjacentVars(model, assignmentCandidates);
Map<String, BoolVar> memberUsedVars = createMemberUsedVars(model, assignmentCandidates);
Set<String> missingMandatoryMemberIds = mandatoryMemberIds.stream()
.filter(memberId -> !memberUsedVars.containsKey(memberId))
.collect(Collectors.toCollection(LinkedHashSet::new));
if (!missingMandatoryMemberIds.isEmpty()) {
return new SolveSelection(false, List.of(),
"필수 조편성 위원의 배정 후보가 없습니다: " + String.join(", ", missingMandatoryMemberIds));
}
// 현재 메인 배정은 Greedy가 담당하지만, CP-SAT 모델은 부분 최적화와 기존 방식 호환을 위해 유지합니다.
linkHelperVars(model, assignmentCandidates, assignmentVars, pairUsedVars, pairDayVars, pairDayAdjacentVars); linkHelperVars(model, assignmentCandidates, assignmentVars, pairUsedVars, pairDayVars, pairDayAdjacentVars);
linkMemberUsedVars(model, assignmentCandidates, assignmentVars, memberUsedVars);
addMandatoryMemberUsed(model, memberUsedVars, mandatoryMemberIds);
addCenterAssignedAtMostOnce(model, assignmentCandidates, assignmentVars); addCenterAssignedAtMostOnce(model, assignmentCandidates, assignmentVars);
addPairDailyCapacity(model, assignmentCandidates, assignmentVars); addPairDailyCapacity(model, assignmentCandidates, assignmentVars);
addMemberDailyOnePair(model, assignmentCandidates, pairDayVars); addMemberDailyOnePair(model, assignmentCandidates, pairDayVars);
addPairDailyOneAdjacentClassification(model, assignmentCandidates, pairDayAdjacentVars); addPairDailyOneAdjacentClassification(model, assignmentCandidates, pairDayAdjacentVars);
if (enforceCounterpartLimit) { addCumulativeBuddyLimit(model, assignmentCandidates, pairUsedVars,
addCumulativeBuddyLimit(model, assignmentCandidates, pairUsedVars, existingCounterpartsByMember);
existingCounterpartsByMember); model.maximize(createObjective(assignmentCandidates, assignmentVars, visitCountsByMember));
}
model.maximize(createObjective(assignmentCandidates, assignmentVars, memberUsedVars,
visitCountsByMember));
CpSolver solver = new CpSolver(); CpSolver solver = new CpSolver();
solver.getParameters().setMaxTimeInSeconds(pairingProperties.getSolver().getMaxTimeSeconds()); solver.getParameters().setMaxTimeInSeconds(pairingProperties.getSolver().getMaxTimeSeconds());
solver.getParameters().setNumSearchWorkers(pairingProperties.getSolver().getNumSearchWorkers()); solver.getParameters().setNumSearchWorkers(pairingProperties.getSolver().getNumSearchWorkers());
CpSolverStatus status = solver.solve(model); CpSolverStatus status = solver.solve(model);
if (status != CpSolverStatus.OPTIMAL && status != CpSolverStatus.FEASIBLE) { if (status != CpSolverStatus.OPTIMAL && status != CpSolverStatus.FEASIBLE) {
if (enforceCounterpartLimit && !mandatoryMemberIds.isEmpty()) {
SolveSelection counterpartRelaxedSelection = select(candidates,
existingCounterpartsByMember, visitCountsByMember, mandatoryMemberIds, false);
if (counterpartRelaxedSelection.hasSolution()) {
return new SolveSelection(true, counterpartRelaxedSelection.selectedAssignments(),
counterpartRelaxedSelection.status() + ", counterpartLimitRelaxed=true");
}
}
return new SolveSelection(false, List.of(), "solver가 feasible 해를 찾지 못했습니다: " + status); return new SolveSelection(false, List.of(), "solver가 feasible 해를 찾지 못했습니다: " + status);
} }
return new SolveSelection(true, collectSelectedAssignments(assignmentCandidates, assignmentVars, solver), status.name()); return new SolveSelection(true, collectSelectedAssignments(assignmentCandidates, assignmentVars, solver), status.name());
@@ -127,7 +103,12 @@ public class PairingSolverService {
public PairingResult buildResult(PairingData data, PairingCandidates candidates, public PairingResult buildResult(PairingData data, PairingCandidates candidates,
List<AssignmentCandidate> selectedAssignments, String status) { List<AssignmentCandidate> selectedAssignments, String status) {
return toResult(data, candidates, selectedAssignments, 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) { private BoolVar[] createAssignmentVars(CpModel model, List<AssignmentCandidate> candidates) {
@@ -153,16 +134,6 @@ public class PairingSolverService {
.collect(Collectors.toMap(Function.identity(), key -> model.newBoolVar("pair_day_adjacent_" + key))); .collect(Collectors.toMap(Function.identity(), key -> model.newBoolVar("pair_day_adjacent_" + key)));
} }
private Map<String, BoolVar> createMemberUsedVars(CpModel model,
List<AssignmentCandidate> candidates) {
return candidates.stream()
.flatMap(candidate -> Stream.of(candidate.getFieldMemberId(),
candidate.getExternalMemberId()))
.distinct()
.collect(Collectors.toMap(Function.identity(),
memberId -> model.newBoolVar("member_used_" + memberId)));
}
private void linkHelperVars(CpModel model, List<AssignmentCandidate> candidates, private void linkHelperVars(CpModel model, List<AssignmentCandidate> candidates,
BoolVar[] assignmentVars, Map<String, BoolVar> pairUsedVars, Map<String, BoolVar> pairDayVars, BoolVar[] assignmentVars, Map<String, BoolVar> pairUsedVars, Map<String, BoolVar> pairDayVars,
Map<String, BoolVar> pairDayAdjacentVars) { Map<String, BoolVar> pairDayAdjacentVars) {
@@ -174,40 +145,16 @@ public class PairingSolverService {
} }
} }
private void linkMemberUsedVars(CpModel model, List<AssignmentCandidate> candidates,
BoolVar[] assignmentVars, Map<String, BoolVar> memberUsedVars) {
Map<String, List<Integer>> indexesByMember = new HashMap<>();
for (int i = 0; i < candidates.size(); i++) {
AssignmentCandidate candidate = candidates.get(i);
indexesByMember.computeIfAbsent(candidate.getFieldMemberId(), key -> new ArrayList<>())
.add(i);
indexesByMember.computeIfAbsent(candidate.getExternalMemberId(), key -> new ArrayList<>())
.add(i);
model.addLessOrEqual(assignmentVars[i], memberUsedVars.get(candidate.getFieldMemberId()));
model.addLessOrEqual(assignmentVars[i], memberUsedVars.get(candidate.getExternalMemberId()));
}
indexesByMember.forEach((memberId, indexes) -> model.addLessOrEqual(
memberUsedVars.get(memberId), LinearExpr.sum(toLinearArgumentArray(indexes,
assignmentVars))));
}
private void addMandatoryMemberUsed(CpModel model, Map<String, BoolVar> memberUsedVars,
Set<String> mandatoryMemberIds) {
mandatoryMemberIds.stream()
.map(memberUsedVars::get)
.filter(Objects::nonNull)
.forEach(memberUsedVar -> model.addEquality(memberUsedVar, 1));
}
private void addCenterAssignedAtMostOnce(CpModel model, List<AssignmentCandidate> candidates, private void addCenterAssignedAtMostOnce(CpModel model, List<AssignmentCandidate> candidates,
BoolVar[] assignmentVars) { BoolVar[] assignmentVars) {
// 하나의 센터는 최대 1번만 배정됩니다.
groupIndexes(candidates, AssignmentCandidate::getCenterId).values() groupIndexes(candidates, AssignmentCandidate::getCenterId).values()
.forEach(indexes -> model.addAtMostOne(toLiteralArray(indexes, assignmentVars))); .forEach(indexes -> model.addAtMostOne(toLiteralArray(indexes, assignmentVars)));
} }
private void addPairDailyCapacity(CpModel model, List<AssignmentCandidate> candidates, private void addPairDailyCapacity(CpModel model, List<AssignmentCandidate> candidates,
BoolVar[] assignmentVars) { BoolVar[] assignmentVars) {
// 같은 조가 하루에 방문할 수 있는 센터 수 상한입니다.
groupIndexes(candidates, this::pairDayKey).values().forEach(indexes -> model.addLessOrEqual( groupIndexes(candidates, this::pairDayKey).values().forEach(indexes -> model.addLessOrEqual(
LinearExpr.sum(toLinearArgumentArray(indexes, assignmentVars)), LinearExpr.sum(toLinearArgumentArray(indexes, assignmentVars)),
pairingProperties.getRule().getMaxCentersPerPairPerDay())); pairingProperties.getRule().getMaxCentersPerPairPerDay()));
@@ -215,6 +162,7 @@ public class PairingSolverService {
private void addMemberDailyOnePair(CpModel model, List<AssignmentCandidate> candidates, private void addMemberDailyOnePair(CpModel model, List<AssignmentCandidate> candidates,
Map<String, BoolVar> pairDayVars) { Map<String, BoolVar> pairDayVars) {
// 한 위원은 같은 날짜에 여러 조로 동시에 활동할 수 없습니다.
Map<String, Set<String>> pairDayKeysByMemberDay = candidates.stream() Map<String, Set<String>> pairDayKeysByMemberDay = candidates.stream()
.collect(Collectors.groupingBy(candidate -> candidate.getFieldMemberId() + "|" + candidate.getDate(), .collect(Collectors.groupingBy(candidate -> candidate.getFieldMemberId() + "|" + candidate.getDate(),
Collectors.mapping(this::pairDayKey, Collectors.toSet()))); Collectors.mapping(this::pairDayKey, Collectors.toSet())));
@@ -231,6 +179,7 @@ public class PairingSolverService {
private void addPairDailyOneAdjacentClassification(CpModel model, private void addPairDailyOneAdjacentClassification(CpModel model,
List<AssignmentCandidate> candidates, Map<String, BoolVar> pairDayAdjacentVars) { List<AssignmentCandidate> candidates, Map<String, BoolVar> pairDayAdjacentVars) {
// 같은 조/같은 날짜에는 하나의 인접지역 분류만 방문합니다.
Map<String, Set<String>> adjacentKeysByPairDay = candidates.stream() Map<String, Set<String>> adjacentKeysByPairDay = candidates.stream()
.collect(Collectors.groupingBy(this::pairDayKey, .collect(Collectors.groupingBy(this::pairDayKey,
Collectors.mapping(this::pairDayAdjacentKey, Collectors.toSet()))); Collectors.mapping(this::pairDayAdjacentKey, Collectors.toSet())));
@@ -240,6 +189,7 @@ public class PairingSolverService {
private void addCumulativeBuddyLimit(CpModel model, List<AssignmentCandidate> candidates, private void addCumulativeBuddyLimit(CpModel model, List<AssignmentCandidate> candidates,
Map<String, BoolVar> pairUsedVars, Map<String, Set<String>> existingCounterpartsByMember) { Map<String, BoolVar> pairUsedVars, Map<String, Set<String>> existingCounterpartsByMember) {
// 위원 1명당 누적 상대 위원 수 제한입니다. 현재 업무 기준은 application.yaml의 max-counterparts-per-member입니다.
Map<String, Set<String>> pairKeysByMember = candidates.stream() Map<String, Set<String>> pairKeysByMember = candidates.stream()
.collect(Collectors.groupingBy(AssignmentCandidate::getFieldMemberId, .collect(Collectors.groupingBy(AssignmentCandidate::getFieldMemberId,
Collectors.mapping(this::pairKey, Collectors.toSet()))); Collectors.mapping(this::pairKey, Collectors.toSet())));
@@ -270,8 +220,9 @@ public class PairingSolverService {
} }
private LinearExpr createObjective(List<AssignmentCandidate> candidates, private LinearExpr createObjective(List<AssignmentCandidate> candidates,
BoolVar[] assignmentVars, Map<String, BoolVar> memberUsedVars, BoolVar[] assignmentVars, Map<String, Integer> visitCountsByMember) {
Map<String, Integer> visitCountsByMember) { // soft rule 점수입니다. 센터를 많이 배정하는 점수가 가장 크고,
// 희망지역/거주지/방문 균형은 같은 배정 수 안에서 우열을 정하는 보조 점수입니다.
List<LinearArgument> vars = new ArrayList<>(); List<LinearArgument> vars = new ArrayList<>();
List<Long> weights = new ArrayList<>(); List<Long> weights = new ArrayList<>();
for (int i = 0; i < assignmentVars.length; i++) { for (int i = 0; i < assignmentVars.length; i++) {
@@ -284,13 +235,6 @@ public class PairingSolverService {
- memberBalancePenalty(candidate, visitCountsByMember)); - memberBalancePenalty(candidate, visitCountsByMember));
} }
memberUsedVars.forEach((memberId, memberUsedVar) -> {
if (visitCountsByMember.getOrDefault(memberId, 0) == 0) {
vars.add(memberUsedVar);
weights.add(pairingProperties.getObjective().getUsedMemberWeight());
}
});
return LinearExpr.weightedSum(vars.toArray(LinearArgument[]::new), return LinearExpr.weightedSum(vars.toArray(LinearArgument[]::new),
weights.stream().mapToLong(Long::longValue).toArray()); weights.stream().mapToLong(Long::longValue).toArray());
} }
@@ -316,11 +260,12 @@ public class PairingSolverService {
return selected; return selected;
} }
private PairingResult toResult(PairingData data, PairingCandidates candidates, private PairingResult toResult(PairingData data, PairingCandidates candidates,
List<AssignmentCandidate> selectedAssignments, String status) { List<AssignmentCandidate> selectedAssignments, String status, Set<String> pairedMemberIds) {
Set<String> assignedCenterIds = selectedAssignments.stream().map(AssignmentCandidate::getCenterId).collect(Collectors.toSet()); Set<String> assignedCenterIds = selectedAssignments.stream().map(AssignmentCandidate::getCenterId).collect(Collectors.toSet());
Set<String> usedMemberIds = selectedAssignments.stream() Set<String> usedMemberIds = selectedAssignments.stream()
.flatMap(candidate -> Stream.of(candidate.getFieldMemberId(), candidate.getExternalMemberId())) .flatMap(candidate -> Stream.of(candidate.getFieldMemberId(), candidate.getExternalMemberId()))
.collect(Collectors.toSet()); .collect(Collectors.toSet());
usedMemberIds.addAll(pairedMemberIds);
Map<String, Member> memberMap = data.getMembers().stream() Map<String, Member> memberMap = data.getMembers().stream()
.collect(Collectors.toMap(Member::getId, Function.identity(), (left, right) -> left)); .collect(Collectors.toMap(Member::getId, Function.identity(), (left, right) -> left));
Map<String, Center> centerMap = data.getCenters().stream() Map<String, Center> centerMap = data.getCenters().stream()
@@ -350,8 +295,9 @@ public class PairingSolverService {
.abPairs(abPairBuildResult.rows()) .abPairs(abPairBuildResult.rows())
.candidateSummaries(createCandidateSummaries(data, candidates, assignments.size(), .candidateSummaries(createCandidateSummaries(data, candidates, assignments.size(),
unassignedCenters.size(), unusedMembers.size(), countABGroups(abPairMatches))) unassignedCenters.size(), unusedMembers.size(), countABGroups(abPairMatches)))
.appliedSettings(createAppliedSettings())
.validationErrors(List.of()) .validationErrors(List.of())
.ruleViolations(createRuleChecks(data, selectedAssignments, abPairMatches)) .ruleViolations(createRuleChecks(data, selectedAssignments, abPairMatches, pairedMemberIds))
.build(); .build();
} }
@@ -367,6 +313,7 @@ public class PairingSolverService {
.summaries(createSummaries(data, candidates, 0, data.getCenters().size(), data.getMembers().size(), 0, reason)) .summaries(createSummaries(data, candidates, 0, data.getCenters().size(), data.getMembers().size(), 0, reason))
.abPairs(List.of()) .abPairs(List.of())
.candidateSummaries(createCandidateSummaries(data, candidates, 0, data.getCenters().size(), data.getMembers().size(), 0)) .candidateSummaries(createCandidateSummaries(data, candidates, 0, data.getCenters().size(), data.getMembers().size(), 0))
.appliedSettings(createAppliedSettings())
.validationErrors(List.of()) .validationErrors(List.of())
.ruleViolations(List.of(new RuleViolationExcelDto("solver feasible 해", "FAIL", reason))) .ruleViolations(List.of(new RuleViolationExcelDto("solver feasible 해", "FAIL", reason)))
.build(); .build();
@@ -395,8 +342,8 @@ public class PairingSolverService {
} }
private UnassignedCenterExcelDto toUnassignedCenter(Center center, Map<String, Set<String>> reasonMap) { private UnassignedCenterExcelDto toUnassignedCenter(Center center, Map<String, Set<String>> reasonMap) {
Set<String> reasons = new LinkedHashSet<>((Collection<String>) (reasonMap == null ? Set.of() Set<String> reasons = new LinkedHashSet<>(reasonMap == null ? Set.of()
: reasonMap.getOrDefault(center.getId(), Set.of()))); : reasonMap.getOrDefault(center.getId(), Set.of()));
reasons.add("solver 최적화에서 선택되지 않음"); reasons.add("solver 최적화에서 선택되지 않음");
return new UnassignedCenterExcelDto(center.getId(), center.getMunicipalityId(), String.join(", ", reasons)); return new UnassignedCenterExcelDto(center.getId(), center.getMunicipalityId(), String.join(", ", reasons));
} }
@@ -521,8 +468,96 @@ public class PairingSolverService {
new CandidateSummaryExcelDto("AB 그룹 수", String.valueOf(abGroupCount), "후처리로 구성된 AB 그룹 수")); 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, private List<RuleViolationExcelDto> createRuleChecks(PairingData data,
List<AssignmentCandidate> selectedAssignments, Map<String, ABPairMatch> abPairMatches) { List<AssignmentCandidate> selectedAssignments, Map<String, ABPairMatch> abPairMatches,
Set<String> pairedMemberIds) {
Map<String, Member> memberMap = data.getMembers().stream() Map<String, Member> memberMap = data.getMembers().stream()
.collect(Collectors.toMap(Member::getId, Function.identity(), (left, right) -> left)); .collect(Collectors.toMap(Member::getId, Function.identity(), (left, right) -> left));
Map<String, Center> centerMap = data.getCenters().stream() Map<String, Center> centerMap = data.getCenters().stream()
@@ -538,8 +573,9 @@ public class PairingSolverService {
checks.add(checkHistoryCenter(selectedAssignments, memberMap)); checks.add(checkHistoryCenter(selectedAssignments, memberMap));
checks.add(checkHoliday(selectedAssignments, commonUnavailableDates(data))); checks.add(checkHoliday(selectedAssignments, commonUnavailableDates(data)));
checks.add(checkABDateOverlap(abPairMatches)); checks.add(checkABDateOverlap(abPairMatches));
checks.add(checkAllMembersUsed(data, selectedAssignments)); checks.add(checkAllMembersUsed(data, selectedAssignments, pairedMemberIds));
checks.add(checkMemberVisitBalance(data, selectedAssignments)); checks.add(checkMemberVisitBalance(data, selectedAssignments));
checks.add(checkMemberVisitUpperBound(data, selectedAssignments));
return checks; return checks;
} }
@@ -638,11 +674,12 @@ public class PairingSolverService {
} }
private RuleViolationExcelDto checkAllMembersUsed(PairingData data, private RuleViolationExcelDto checkAllMembersUsed(PairingData data,
List<AssignmentCandidate> assignments) { List<AssignmentCandidate> assignments, Set<String> pairedMemberIds) {
Set<String> usedMemberIds = assignments.stream() Set<String> usedMemberIds = assignments.stream()
.flatMap(candidate -> Stream.of(candidate.getFieldMemberId(), .flatMap(candidate -> Stream.of(candidate.getFieldMemberId(),
candidate.getExternalMemberId())) candidate.getExternalMemberId()))
.collect(Collectors.toSet()); .collect(Collectors.toSet());
usedMemberIds.addAll(pairedMemberIds);
List<String> unusedMemberIds = data.getMembers().stream() List<String> unusedMemberIds = data.getMembers().stream()
.map(Member::getId) .map(Member::getId)
.filter(memberId -> !usedMemberIds.contains(memberId)) .filter(memberId -> !usedMemberIds.contains(memberId))
@@ -662,10 +699,39 @@ public class PairingSolverService {
long min = visitCounts.values().stream().mapToLong(Long::longValue).min().orElse(0L); long min = visitCounts.values().stream().mapToLong(Long::longValue).min().orElse(0L);
long max = visitCounts.values().stream().mapToLong(Long::longValue).max().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); double average = visitCounts.values().stream().mapToLong(Long::longValue).average().orElse(0.0D);
String detail = "min=" + min + ", max=" + max + ", avg=" + String.format("%.2f", average); long maxAllowed = maxMemberVisitCount(data);
String detail = "min=" + min + ", max=" + max + ", avg=" + String.format("%.2f", average)
+ ", maxAllowed=" + maxAllowed;
return new RuleViolationExcelDto("위원별 방문 센터 수 균등 배분", "PASS", detail); 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) { private String formatDates(Set<LocalDate> dates) {
return dates.stream().sorted().map(LocalDate::toString).collect(Collectors.joining(", ")); return dates.stream().sorted().map(LocalDate::toString).collect(Collectors.joining(", "));
} }

View File

@@ -61,37 +61,44 @@ pairing:
# 한 페어가 하루에 방문할 수 있는 최대 센터 수입니다. (HARD) # 한 페어가 하루에 방문할 수 있는 최대 센터 수입니다. (HARD)
max-centers-per-pair-per-day: 3 max-centers-per-pair-per-day: 3
# 한 위원이 전체 기간 동안 가질 수 있는 최대 상대 파트너 수입니다.(HARD) # 한 위원이 전체 기간 동안 가질 수 있는 최대 상대 파트너 수입니다.(HARD)
max-counterparts-per-member: 2 max-counterparts-per-member: 3
# 위원 1명의 최대 방문 센터 수 상한입니다. 전체 센터가 모두 배정됐을 때 평균 방문 수의 N%를 넘지 못하게 합니다.(HARD)
max-member-visit-average-ratio-percent: 130
preference: preference:
# 선호지역 00(anywhere)을 희망지역 매칭표에서 표현하는 rank 값입니다.(HARD) # 선호지역 00(anywhere)을 희망지역 매칭표에서 표현하는 rank 값입니다.(HARD)
anywhere-rank: 0 anywhere-rank: 0
# 희망지역 매칭표에서 해당 위원의 선호지역을 고려하지 않는 wildcard rank 값입니다.(HARD) # 희망지역 매칭표에서 해당 위원의 선호지역을 고려하지 않는 wildcard rank 값입니다.(HARD)
ignored-rank: 99 ignored-rank: 99
# true면 선호지역 미일치 후보도 99 wildcard 매칭표 규칙을 적극 활용합니다. false로 바꾸면 기존 보수적 점수로 되돌아갑니다.
active-wildcard-fallback-enabled: true
# wildcard 후보가 후보 축소/배정 선택에서 너무 뒤로 밀리지 않도록 더하는 점수입니다. 값이 클수록 미배정 센터 감소를 우선합니다.
wildcard-fallback-score-bonus: 25_000
objective: objective:
# 센터 1개를 배정했을 때 부여하는 최우선 점수입니다. 다른 soft score 총합보다 충분히 커야 합니다. # 센터 1개를 배정했을 때 부여하는 최우선 점수입니다. 다른 soft score 총합보다 충분히 커야 합니다.
assignment-weight: 1_000_000 assignment-weight: 1_000_000
# 최종 배정에 위원 1명이 새로 포함될 때 부여하는 점수입니다. 값이 클수록 미사용 위원을 줄이는 방향으로 탐색합니다.
used-member-weight: 300_000
# 이미 많이 배정된 위원이 추가 배정될 때 차감하는 점수입니다. 값이 클수록 위원별 방문 센터 수를 평균에 가깝게 분산합니다. # 이미 많이 배정된 위원이 추가 배정될 때 차감하는 점수입니다. 값이 클수록 위원별 방문 센터 수를 평균에 가깝게 분산합니다.
member-balance-weight: 100_000 member-balance-weight: 20_000
# 거주지 prefix가 일치하는 페어에 부여하는 점수입니다. 값이 클수록 거주지 유사도를 더 중요하게 봅니다.
residence-match-weight: 30_000
# 희망지역 매칭 순위 점수의 기준값입니다. 값이 클수록 선호지역 품질 영향이 커집니다. # 희망지역 매칭 순위 점수의 기준값입니다. 값이 클수록 선호지역 품질 영향이 커집니다.
preference-base-weight: 1_000 preference-base-weight: 30_000
# 매칭 순위가 1 내려갈 때마다 차감하는 점수입니다. 값이 클수록 낮은 순위를 더 강하게 불리하게 봅니다. # 매칭 순위가 1 내려갈 때마다 차감하는 점수입니다. 값이 클수록 낮은 순위를 더 강하게 불리하게 봅니다.
preference-rank-penalty: 100 preference-rank-penalty: 1_000
# 거주지 prefix가 일치하는 페어에 부여하는 점수입니다. 값이 클수록 거주지 유사도를 더 중요하게 봅니다.
residence-match-weight: 10_000
candidate: candidate:
# 위원 1명당 유지할 상대 위원 후보 수입니다. 0이면 제한하지 않습니다.
# 모든 위원 조편성이 최우선 HARD 룰이므로 기본값은 제한 없음으로 둡니다.
max-pair-candidates-per-member: 0
# 현장+외부 페어 1개가 solver에 넘기기 전에 유지할 최대 파견 권역 후보 수입니다. # 현장+외부 페어 1개가 solver에 넘기기 전에 유지할 최대 파견 권역 후보 수입니다.
max-dispatch-regions-per-pair: 20 max-dispatch-regions-per-pair: 0
# 센터 1개마다 solver에 넘기기 전에 유지할 최대 배정 후보 수입니다. # 센터 1개마다 solver에 넘기기 전에 유지할 최대 배정 후보 수입니다.
max-assignments-per-center: 100 max-assignments-per-center: 1_000
# 위원 1명(현장/외부 모두 포함)이 solver 후보에 등장할 수 있는 최대 횟수입니다. # 위원 1명(현장/외부 모두 포함)이 solver 후보에 등장할 수 있는 최대 횟수입니다.
max-assignments-per-member: 160 max-assignments-per-member: 3_000
# 페어-센터 후보 1개에서 생성할 최대 가능 날짜 수입니다. 값이 클수록 전원 조편성 가능성은 커지지만 solver 후보 수가 늘어납니다. # 페어-센터 후보 1개에서 생성할 최대 가능 날짜 수입니다. 기간 전체에 고르게 분산해 날짜 쏠림을 줄입니다.
max-dates-per-assignment-candidate: 5 max-dates-per-assignment-candidate: 80
solver: solver:
# OR-Tools CP-SAT solver가 한 요청에서 탐색할 최대 시간(초)입니다. # OR-Tools CP-SAT solver가 한 요청에서 탐색할 최대 시간(초)입니다.
max-time-seconds: 120.0 max-time-seconds: 360.0
# OR-Tools CP-SAT 병렬 탐색 worker 수입니다. 서버 CPU 상황에 맞춰 조정합니다. # OR-Tools CP-SAT 병렬 탐색 worker 수입니다. 서버 CPU 상황에 맞춰 조정합니다.
num-search-workers: 15 num-search-workers: 15

View File

@@ -0,0 +1,105 @@
# 배정 규칙 및 완화 검토 자료
이 문서는 개발자가 아닌 업무 담당자와 배정 기준을 논의하기 위한 설명 자료입니다.
현재 프로그램은 "모든 위원을 조편성한 뒤, 가능한 많은 센터를 일정표에 배정"하는 것을 목표로 합니다. 단, 일부 규칙은 반드시 지켜야 하므로 센터가 남을 수 있습니다.
## 용어 설명
| 용어 | 설명 |
| --- | --- |
| 현장위원/외부위원 | 한 조를 구성하는 두 역할입니다. 현재 기본 조는 현장위원 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

@@ -10,9 +10,6 @@ import static com.kri.p6.ncrc.pairing.common.consts.PairingConstant.RESULT_SHEET
import static com.kri.p6.ncrc.pairing.common.consts.PairingConstant.RESULT_SHEET_VALIDATION_ERROR; import static com.kri.p6.ncrc.pairing.common.consts.PairingConstant.RESULT_SHEET_VALIDATION_ERROR;
import com.kri.common.feature.excel.ExcelMapper; import com.kri.common.feature.excel.ExcelMapper;
import com.kri.p6.ncrc.pairing.common.cache.DatagoHolidayCache;
import com.kri.p6.ncrc.pairing.common.external.datago.DatagoExtentionApiClient;
import com.kri.p6.ncrc.pairing.common.external.datago.HolidayDto;
import com.kri.p6.ncrc.pairing.dto.excel.output.RuleViolationExcelDto; import com.kri.p6.ncrc.pairing.dto.excel.output.RuleViolationExcelDto;
import java.io.ByteArrayInputStream; import java.io.ByteArrayInputStream;
import java.io.IOException; import java.io.IOException;
@@ -24,28 +21,35 @@ import org.apache.poi.ss.usermodel.Workbook;
import org.apache.poi.ss.usermodel.WorkbookFactory; import org.apache.poi.ss.usermodel.WorkbookFactory;
import org.assertj.core.api.Assertions; import org.assertj.core.api.Assertions;
import org.junit.jupiter.api.Test; 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.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 { class PairingServiceTest {
private final PairingService pairingService = new PairingService( @Autowired
new PairingExcelService(PairingTestSupport.pairingProperties()), private MockMvc mockMvc;
new PairingNormalizeService(PairingTestSupport.pairingProperties()),
new PairingHolidayService(new DatagoHolidayCache(new StubDatagoExtentionApiClient())),
new PairingValidationService(PairingTestSupport.pairingProperties()),
new PairingScheduleService(
new PairingCandidateService(PairingTestSupport.pairingProperties()),
new PairingSolverService(PairingTestSupport.pairingProperties()),
PairingTestSupport.pairingProperties())
);
@Test @Test
void pairingMemberByCenterCreatesResultWorkbook() throws IOException { void pairingMemberByCenterCreatesResultWorkbook() throws Exception {
try (InputStream inputStream = getClass().getResourceAsStream("/sample/기초 data TEST.xlsx")) { Path sample = Path.of("src/main/resources/sample/기초 data TEST.xlsx");
MockMultipartFile file = new MockMultipartFile("file", "기초 data TEST.xlsx",
try (InputStream inputStream = Files.newInputStream(sample)) {
MockMultipartFile file = new MockMultipartFile("file", sample.getFileName().toString(),
"application/vnd.openxmlformats-officedocument.spreadsheetml.sheet", inputStream); "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet", inputStream);
byte[] result = pairingService.pairingMemberByCenter(file); 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(); Assertions.assertThat(result).isNotEmpty();
Files.createDirectories(Path.of("build")); Files.createDirectories(Path.of("build"));
@@ -63,21 +67,9 @@ class PairingServiceTest {
List<RuleViolationExcelDto> ruleChecks = ExcelMapper.readFromWorkbook(workbook, List<RuleViolationExcelDto> ruleChecks = ExcelMapper.readFromWorkbook(workbook,
RuleViolationExcelDto.class, RESULT_SHEET_RULE_CHECK, 1); RuleViolationExcelDto.class, RESULT_SHEET_RULE_CHECK, 1);
Assertions.assertThat(ruleChecks) Assertions.assertThat(ruleChecks)
.filteredOn(ruleCheck -> !"위원 전원 조편성".equals(ruleCheck.getRuleName()))
.extracting(RuleViolationExcelDto::getResult) .extracting(RuleViolationExcelDto::getResult)
.doesNotContain("FAIL"); .doesNotContain("FAIL");
Assertions.assertThat(ruleChecks)
.extracting(RuleViolationExcelDto::getRuleName)
.contains("위원 전원 조편성", "위원별 방문 센터 수 균등 배분");
} }
} }
} }
private static class StubDatagoExtentionApiClient extends DatagoExtentionApiClient {
@Override
public List<HolidayDto> getHoliDayList(String year) {
return List.of();
}
}
} }

View File

@@ -49,13 +49,13 @@ class PairingSolverServiceTest {
} }
@Test @Test
void solveLimitsCounterpartsPerMemberToTwo() { 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"))); 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(); 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); PairingResult result = service.solve(data, candidates);
Map<String, Long> counterpartCounts = (Map)result.getAssignments().stream().collect(Collectors.groupingBy((assignment) -> assignment.getExternalMemberId(), Collectors.counting())); Map<String, Long> counterpartCounts = (Map)result.getAssignments().stream().collect(Collectors.groupingBy((assignment) -> assignment.getExternalMemberId(), Collectors.counting()));
Assertions.assertThat(result.getAssignments()).hasSize(2); Assertions.assertThat(result.getAssignments()).hasSize(3);
Assertions.assertThat(counterpartCounts).hasSize(2); Assertions.assertThat(counterpartCounts).hasSize(3);
} }
@Test @Test
@@ -65,7 +65,7 @@ class PairingSolverServiceTest {
PairingSolverService.SolveSelection selection = service.select(candidates, PairingSolverService.SolveSelection selection = service.select(candidates,
Map.of("field", Set.of("external1"), "external1", Set.of("field"))); Map.of("field", Set.of("external1"), "external1", Set.of("field")));
Assertions.assertThat(selection.selectedAssignments()).hasSize(2); Assertions.assertThat(selection.selectedAssignments()).hasSize(3);
Assertions.assertThat(selection.selectedAssignments()) Assertions.assertThat(selection.selectedAssignments())
.extracting(AssignmentCandidate::getExternalMemberId) .extracting(AssignmentCandidate::getExternalMemberId)
.contains("external1"); .contains("external1");

View File

@@ -7,6 +7,8 @@ final class PairingTestSupport {
} }
static PairingProperties pairingProperties() { static PairingProperties pairingProperties() {
return new PairingProperties(); PairingProperties properties = new PairingProperties();
properties.getSolver().setMaxTimeSeconds(0.5);
return properties;
} }
} }