260420_01_ENH: split 마감
This commit is contained in:
449
README.md
449
README.md
@@ -1,336 +1,201 @@
|
||||
# ncrc-pairing
|
||||
|
||||
엑셀 파일을 입력받아 위원 페어 후보와 센터 배정 후보를 만들고, Google OR-Tools CP-SAT으로 배정 결과를 계산하는 Spring Boot API입니다.
|
||||
엑셀 파일을 입력받아 위원 조편성 및 센터 방문 일정을 생성하는 Spring Boot API입니다.
|
||||
|
||||
현재 배정 엔진은 Greedy 중심으로 동작합니다. 모든 위원을 먼저 조편성하고, 이후 가능한 많은 센터를 일정표에 배정합니다. OR-Tools CP-SAT 코드는 유지되어 있지만 전체 배정의 중심 경로는 `PairingScheduleService`입니다.
|
||||
|
||||
## 실행 흐름
|
||||
|
||||
1. `PairingController`
|
||||
- `/api/v1/pairing/run`으로 엑셀 파일을 업로드받습니다.
|
||||
- 처리 결과를 엑셀 파일로 반환합니다.
|
||||
- 결과 엑셀 파일을 반환합니다.
|
||||
|
||||
2. `PairingService`
|
||||
- 전체 유스케이스 흐름을 순서대로 호출합니다.
|
||||
- `엑셀 읽기 -> 정규화 -> 공휴일 반영 -> 검증 -> 후보 생성 -> solver 실행 -> 결과 엑셀 생성`
|
||||
- 전체 유스케이스를 순서대로 호출합니다.
|
||||
- `엑셀 읽기 -> 정규화 -> 공휴일/주말 반영 -> 검증 -> 후보 생성 -> 조편성/스케줄링 -> 결과 엑셀 생성`
|
||||
|
||||
3. `PairingExcelService`
|
||||
- 입력 엑셀의 6개 시트를 `dto.excel` DTO로 읽습니다.
|
||||
- 결과 엑셀은 `배정결과`, `미배정센터`, `미사용위원`, `처리요약`, `AB페어목록`, `후보요약`, `검증오류`, `규칙위반검사` 시트로 씁니다.
|
||||
- `/run`에서 입력/검증 오류가 발생하면 오류 내용을 담은 엑셀 파일을 반환합니다.
|
||||
- 입력 엑셀 시트를 DTO로 읽습니다.
|
||||
- 결과 시트는 배정결과, 미배정센터, 미사용위원, 처리요약, AB페어목록, 후보요약, 검증오류, 규칙위반검사를 포함합니다.
|
||||
|
||||
4. `PairingNormalizeService`
|
||||
- 엑셀 문자열을 내부 모델로 변환합니다.
|
||||
- 날짜, CSV, 성별, 경력여부, 현장/외부 구분, 지역코드, 선호지역을 정리합니다.
|
||||
- 날짜, CSV, 성별, 경력, 현장/외부 구분, 지역코드, 희망지역을 정리합니다.
|
||||
|
||||
5. `PairingValidationService`
|
||||
- 필수 데이터, 날짜 범위, 지자체 참조, 희망지역 매칭표 등을 검증합니다.
|
||||
- 실패 시 `BusinessException.badRequest(code, message)`를 사용합니다.
|
||||
5. `PairingHolidayService`
|
||||
- `DatagoHolidayCache`를 통해 공휴일을 조회합니다.
|
||||
- 토/일은 `DatagoHolidayCache#getWeekend`에서 생성해 공통 불가능일로 합칩니다.
|
||||
- 공휴일 API 조회 실패 시 구동되면 안 된다는 정책에 따라 실패 응답을 냅니다.
|
||||
|
||||
6. `PairingHolidayService`
|
||||
- `DatagoExtentionApiClient.getHoliDayList(year)`로 국공휴일을 조회합니다.
|
||||
- 조회된 날짜는 모든 위원/지자체/센터에 공통 적용되는 진행 불가일자로 처리합니다.
|
||||
- 공휴일 목록은 `DatagoHolidayCache`에서 공용 `AbstractListCache` 기반으로 캐싱합니다.
|
||||
6. `PairingValidationService`
|
||||
- 필수 데이터, 날짜 범위, 지자체 참조, 희망지역 매칭표를 검증합니다.
|
||||
- 검증 실패는 `BusinessException.badRequest(code, message)`를 사용합니다.
|
||||
|
||||
7. `PairingCandidateService`
|
||||
- solver가 선택할 수 있는 후보만 생성합니다.
|
||||
- 불가능한 조합은 이 단계에서 제거합니다.
|
||||
- 가능한 조, 파견권역, 센터/날짜 후보를 생성합니다.
|
||||
- 상피제, 여성전용센터, 기방문센터, 날짜 불가, 공휴일/주말 등 명확한 Hard Rule을 후보 단계에서 제거합니다.
|
||||
|
||||
8. `PairingSolverService`
|
||||
- OR-Tools CP-SAT 모델을 만들고 최적 배정을 계산합니다.
|
||||
8. `PairingMemberPairService`
|
||||
- 모든 위원이 최소 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
|
||||
2026-05-01에 fieldMember=100, externalMember=200 페어가 center=300을 방문한다
|
||||
## 현재 Soft Rule 우선순위
|
||||
|
||||
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
|
||||
1 = 이 후보를 선택한다
|
||||
0 = 이 후보를 선택하지 않는다
|
||||
```
|
||||
|
||||
`PairingSolverService`는 이런 boolean 변수들을 놓고 아래를 수행합니다.
|
||||
|
||||
- hard rule: 반드시 지켜야 하는 제약
|
||||
- soft rule: 지키면 점수가 좋아지는 목표
|
||||
|
||||
## 현재 적용된 Hard Rule
|
||||
|
||||
후보 생성 단계와 solver 단계에 나뉘어 적용되어 있습니다.
|
||||
|
||||
### 후보 생성 단계
|
||||
|
||||
위치: `PairingCandidateService`
|
||||
|
||||
- 현장위원 + 외부위원 페어만 생성
|
||||
- 신규 + 신규 페어 제외
|
||||
- 두 위원의 일정 범위가 겹치지 않으면 제외
|
||||
- 파견 권역이 위원의 활동지역과 같으면 제외
|
||||
- 희망지역 매칭표에 없는 선호 조합 제외
|
||||
- 센터 인접지역표를 통해 파견 권역과 센터 연결
|
||||
- 여성 전용 센터는 여성 2명 페어만 허용
|
||||
- 2023년 진행 센터는 해당 위원에게 재배정 금지
|
||||
- 위원/지자체/센터의 시작일, 종료일, 불가일자를 모두 반영
|
||||
- 국공휴일은 모든 배정 후보에서 제외
|
||||
|
||||
현재 후보 수 폭증을 막기 위해 각 페어/센터 조합에서 가장 빠른 feasible 일자 1개만 후보로 만듭니다.
|
||||
|
||||
### Solver 단계
|
||||
|
||||
위치: `PairingSolverService`
|
||||
|
||||
- 한 센터는 최대 1번만 배정
|
||||
- 한 페어는 하루 최대 3개 센터만 방문
|
||||
- 한 위원은 같은 날짜에 하나의 페어로만 활동
|
||||
- 한 페어는 같은 날짜에 하나의 인접지역 분류만 방문
|
||||
- 한 위원은 전체 기간 동안 최대 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` 실패 응답을 사용합니다.
|
||||
현재 프로젝트에서는 전체 후보가 매우 커질 수 있어 CP-SAT만으로는 시간이 오래 걸릴 수 있습니다. 그래서 주 배정은 Greedy가 담당하고, CP-SAT 코드는 향후 부분 최적화나 비교 실험을 위해 유지합니다.
|
||||
|
||||
CP-SAT 관련 수정 위치:
|
||||
|
||||
| 변경 내용 | 수정 위치 |
|
||||
| --- | --- |
|
||||
| 후보 0/1 변수 | `PairingSolverService#createAssignmentVars` |
|
||||
| 센터 중복 금지 | `PairingSolverService#addCenterAssignedAtMostOnce` |
|
||||
| 하루 방문 센터 수 | `PairingSolverService#addPairDailyCapacity` |
|
||||
| 같은 날짜 위원 중복 금지 | `PairingSolverService#addMemberDailyOnePair` |
|
||||
| 인접지역 분류 제한 | `PairingSolverService#addPairDailyOneAdjacentClassification` |
|
||||
| 상대 파트너 수 제한 | `PairingSolverService#addCumulativeBuddyLimit` |
|
||||
| 점수 조정 | `PairingSolverService#createObjective` |
|
||||
|
||||
## 규칙 변경 시 수정 위치
|
||||
|
||||
| 업무 변경 | 수정 위치 |
|
||||
| --- | --- |
|
||||
| 엑셀 시트명 변경 | `PairingConstant` |
|
||||
| 엑셀 컬럼명 변경 | `dto.excel.input`, `dto.excel.output`의 `@ExcelColumn` |
|
||||
| 입력 정규화 변경 | `PairingNormalizeService` |
|
||||
| 공휴일/주말 정책 변경 | `PairingHolidayService`, `DatagoHolidayCache` |
|
||||
| 상피제 변경 | `PairingCandidateService#isConflictRegion`, `hasActivityRegion` |
|
||||
| 여성전용센터 정책 변경 | `PairingCandidateService#findCenterHardRuleReasons` |
|
||||
| 기방문센터 제외 정책 변경 | `PairingCandidateService#findCenterHardRuleReasons` |
|
||||
| 희망지역 00/99 해석 변경 | `PairingCandidateService#findPreferenceRank`, `findPreferenceMatchRule`, `matchesPreferenceRank` |
|
||||
| wildcard 적극 사용 롤백 | `application.yaml`의 `active-wildcard-fallback-enabled: false` |
|
||||
| 위원당 상대 파트너 수 변경 | `application.yaml`의 `max-counterparts-per-member` |
|
||||
| 하루 센터 방문 수 변경 | `application.yaml`의 `max-centers-per-pair-per-day` |
|
||||
| 위원 최대 방문 상한 변경 | `application.yaml`의 `max-member-visit-average-ratio-percent` |
|
||||
| 배정 점수 튜닝 | `application.yaml`의 `objective.*` |
|
||||
| repair 전략 변경 | `PairingScheduleService`의 `repair...` 메서드 |
|
||||
|
||||
## 테스트
|
||||
|
||||
컴파일:
|
||||
|
||||
```powershell
|
||||
.\gradlew.bat compileJava
|
||||
```
|
||||
|
||||
전체 테스트:
|
||||
|
||||
```powershell
|
||||
.\gradlew.bat clean test
|
||||
.\gradlew.bat test
|
||||
```
|
||||
|
||||
샘플 엑셀 전체 흐름 테스트:
|
||||
샘플 엑셀 기반 테스트:
|
||||
|
||||
```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 실행 테스트:
|
||||
|
||||
```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
|
||||
```
|
||||
결과 파일은 테스트 실행 시 `build/pairing-result*.xlsx`로 생성됩니다.
|
||||
|
||||
@@ -68,5 +68,5 @@ dependencies {
|
||||
|
||||
tasks.named('test') {
|
||||
useJUnitPlatform()
|
||||
maxHeapSize = '4g'
|
||||
maxHeapSize = '8g'
|
||||
}
|
||||
|
||||
@@ -18,6 +18,8 @@ public final class PairingConstant {
|
||||
public static final String RESULT_SHEET_VALIDATION_ERROR = "검증오류";
|
||||
public static final String RESULT_SHEET_RULE_CHECK = "규칙위반검사";
|
||||
|
||||
public static final String RESULT_SHEET_APPLIED_SETTING = "적용설정";
|
||||
|
||||
private PairingConstant() {
|
||||
}
|
||||
}
|
||||
|
||||
@@ -36,7 +36,8 @@ public class PairingProperties {
|
||||
@Setter
|
||||
public static class Rule {
|
||||
private int maxCentersPerPairPerDay = 3;
|
||||
private int maxCounterpartsPerMember = 2;
|
||||
private int maxCounterpartsPerMember = 3;
|
||||
private int maxMemberVisitAverageRatioPercent = 130;
|
||||
}
|
||||
|
||||
@Getter
|
||||
@@ -44,26 +45,28 @@ public class PairingProperties {
|
||||
public static class Preference {
|
||||
private int anywhereRank = 0;
|
||||
private int ignoredRank = 99;
|
||||
private boolean activeWildcardFallbackEnabled = false;
|
||||
private long wildcardFallbackScoreBonus = 25_000L;
|
||||
}
|
||||
|
||||
@Getter
|
||||
@Setter
|
||||
public static class Objective {
|
||||
private long assignmentWeight = 1_000_000L;
|
||||
private long preferenceBaseWeight = 10_000L;
|
||||
private long preferenceRankPenalty = 100L;
|
||||
private long residenceMatchWeight = 1_000L;
|
||||
private long usedMemberWeight = 300_000L;
|
||||
private long memberBalanceWeight = 1_000L;
|
||||
private long preferenceBaseWeight = 30_000L;
|
||||
private long preferenceRankPenalty = 1_000L;
|
||||
private long residenceMatchWeight = 10_000L;
|
||||
private long memberBalanceWeight = 20_000L;
|
||||
}
|
||||
|
||||
@Getter
|
||||
@Setter
|
||||
public static class Candidate {
|
||||
private int maxDispatchRegionsPerPair = 5;
|
||||
private int maxAssignmentsPerCenter = 30;
|
||||
private int maxAssignmentsPerMember = 80;
|
||||
private int maxDatesPerAssignmentCandidate = 5;
|
||||
private int maxPairCandidatesPerMember = 0;
|
||||
private int maxDispatchRegionsPerPair = 0;
|
||||
private int maxAssignmentsPerCenter = 1_000;
|
||||
private int maxAssignmentsPerMember = 3_000;
|
||||
private int maxDatesPerAssignmentCandidate = 80;
|
||||
}
|
||||
|
||||
@Getter
|
||||
|
||||
@@ -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;
|
||||
}
|
||||
@@ -1,6 +1,7 @@
|
||||
package com.kri.p6.ncrc.pairing.model;
|
||||
|
||||
import com.kri.p6.ncrc.pairing.dto.excel.output.ABPairExcelDto;
|
||||
import com.kri.p6.ncrc.pairing.dto.excel.output.AppliedSettingExcelDto;
|
||||
import com.kri.p6.ncrc.pairing.dto.excel.output.AssignmentResultExcelDto;
|
||||
import com.kri.p6.ncrc.pairing.dto.excel.output.CandidateSummaryExcelDto;
|
||||
import com.kri.p6.ncrc.pairing.dto.excel.output.PairingSummaryExcelDto;
|
||||
@@ -22,6 +23,7 @@ public class PairingResult {
|
||||
private final List<PairingSummaryExcelDto> summaries;
|
||||
private final List<ABPairExcelDto> abPairs;
|
||||
private final List<CandidateSummaryExcelDto> candidateSummaries;
|
||||
private final List<AppliedSettingExcelDto> appliedSettings;
|
||||
private final List<ValidationErrorExcelDto> validationErrors;
|
||||
private final List<RuleViolationExcelDto> ruleViolations;
|
||||
|
||||
|
||||
@@ -22,6 +22,7 @@ import java.util.LinkedHashSet;
|
||||
import java.util.List;
|
||||
import java.util.Map;
|
||||
import java.util.Optional;
|
||||
import java.util.PriorityQueue;
|
||||
import java.util.Set;
|
||||
import java.util.function.Function;
|
||||
import java.util.stream.Collectors;
|
||||
@@ -35,7 +36,10 @@ public class PairingCandidateService {
|
||||
private final PairingProperties pairingProperties;
|
||||
|
||||
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(
|
||||
createDispatchRegionCandidates(data, pairCandidates));
|
||||
Map<String, Set<String>> unassignedCenterReasons = createInitialCenterReasonMap(data);
|
||||
@@ -53,6 +57,8 @@ public class PairingCandidateService {
|
||||
}
|
||||
|
||||
private List<PairCandidate> createPairCandidates(List<Member> members) {
|
||||
// 현장위원 1명 + 외부위원 1명을 기본 조로 봅니다.
|
||||
// 두 위원의 활동 가능 기간이 전혀 겹치지 않으면 이후 센터 배정이 불가능하므로 제외합니다.
|
||||
List<Member> fieldMembers = members.stream()
|
||||
.filter(member -> member.getRole() == MemberRole.FIELD).toList();
|
||||
List<Member> externalMembers = members.stream()
|
||||
@@ -75,6 +81,8 @@ public class PairingCandidateService {
|
||||
|
||||
private List<DispatchRegionCandidate> createDispatchRegionCandidates(PairingData data,
|
||||
List<PairCandidate> pairCandidates) {
|
||||
// 조가 갈 수 있는 파견 권역 후보를 만듭니다.
|
||||
// 상피제(위원 활동지역과 파견 권역 일치)는 여기서 제거합니다.
|
||||
Map<String, Member> memberMap = toMemberMap(data.getMembers());
|
||||
Set<String> dispatchRegions = data.getCenterAdjacentRegions().stream()
|
||||
.map(CenterAdjacentRegion::getDispatchRegion).collect(Collectors.toSet());
|
||||
@@ -92,6 +100,8 @@ public class PairingCandidateService {
|
||||
Optional<PreferenceMatchRule> matchRule = findPreferenceMatchRule(
|
||||
data.getPreferenceMatchRules(), fieldRank, externalRank);
|
||||
|
||||
// fieldRank/externalRank가 -1이어도 희망지역 매칭표의 99(wildcard) 규칙은 적용될 수 있습니다.
|
||||
// 99는 "해당 위원의 희망지역을 고려하지 않음"이라는 후순위 fallback입니다.
|
||||
candidates.add(DispatchRegionCandidate.builder().fieldMemberId(fieldMember.getId())
|
||||
.externalMemberId(externalMember.getId()).dispatchRegion(dispatchRegion)
|
||||
.preferencePriority(matchRule.map(PreferenceMatchRule::getPriority)
|
||||
@@ -111,6 +121,8 @@ public class PairingCandidateService {
|
||||
List<DispatchRegionCandidate> dispatchRegionCandidates,
|
||||
Map<String, Set<String>> unassignedCenterReasons
|
||||
) {
|
||||
// 파견 권역 후보를 실제 센터와 날짜 후보로 확장합니다.
|
||||
// 여성전용, 기방문센터, 위원/지자체/센터 불가능일, 공휴일/주말은 이 단계에서 제외합니다.
|
||||
Map<String, Member> memberMap = toMemberMap(data.getMembers());
|
||||
Map<String, Municipality> municipalityMap = data.getMunicipalities().stream()
|
||||
.collect(Collectors.toMap(Municipality::getId, Function.identity(), (left, right) -> left));
|
||||
@@ -120,8 +132,13 @@ public class PairingCandidateService {
|
||||
.stream().collect(Collectors.groupingBy(CenterAdjacentRegion::getDispatchRegion,
|
||||
Collectors.mapping(CenterAdjacentRegion::getAdjacentRegionClassification,
|
||||
Collectors.toSet())));
|
||||
Map<String, List<Center>> centersByAdjacentClassification = data.getCenters().stream()
|
||||
.collect(Collectors.groupingBy(Center::getAdjacentRegionClassification,
|
||||
LinkedHashMap::new, Collectors.toList()));
|
||||
Set<LocalDate> commonUnavailableDates = commonUnavailableDates(data);
|
||||
|
||||
List<AssignmentCandidate> candidates = new ArrayList<>();
|
||||
Map<String, PriorityQueue<AssignmentCandidate>> centerCandidateBuckets = new LinkedHashMap<>();
|
||||
Map<String, PriorityQueue<AssignmentCandidate>> memberCandidateBuckets = new LinkedHashMap<>();
|
||||
|
||||
for (DispatchRegionCandidate dispatchCandidate : dispatchRegionCandidates) {
|
||||
Member fieldMember = memberMap.get(dispatchCandidate.getFieldMemberId());
|
||||
@@ -132,7 +149,8 @@ public class PairingCandidateService {
|
||||
Set<String> adjacentClassifications = adjacentClassificationsByDispatchRegion
|
||||
.getOrDefault(dispatchCandidate.getDispatchRegion(), Set.of());
|
||||
|
||||
for (Center center : data.getCenters()) {
|
||||
for (Center center : centersForDispatch(adjacentClassifications,
|
||||
centersByAdjacentClassification)) {
|
||||
if (!adjacentClassifications.contains(center.getAdjacentRegionClassification())) {
|
||||
addReason(unassignedCenterReasons, center.getId(), "파견 권역과 센터 인접지역 분류 불일치");
|
||||
} else {
|
||||
@@ -145,13 +163,14 @@ public class PairingCandidateService {
|
||||
reason -> addReason(unassignedCenterReasons, center.getId(), reason));
|
||||
} else {
|
||||
List<LocalDate> assignableDates = findAssignableDates(fieldMember,
|
||||
externalMember, municipality, center, commonUnavailableDates(data));
|
||||
externalMember, municipality, center, commonUnavailableDates);
|
||||
if (assignableDates.isEmpty()) {
|
||||
addReason(unassignedCenterReasons, center.getId(),
|
||||
"위원/지자체/센터 일정 또는 국공휴일 조건 불일치");
|
||||
} else {
|
||||
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())
|
||||
.municipalityId(center.getMunicipalityId()).date(assignableDate)
|
||||
.dispatchRegion(dispatchCandidate.getDispatchRegion())
|
||||
@@ -168,7 +187,7 @@ public class PairingCandidateService {
|
||||
}
|
||||
}
|
||||
|
||||
return candidates;
|
||||
return mergeAssignmentCandidateBuckets(centerCandidateBuckets, memberCandidateBuckets);
|
||||
}
|
||||
|
||||
private List<AssignmentCandidate> preferResidenceMatchesByCenter(
|
||||
@@ -195,6 +214,116 @@ public class PairingCandidateService {
|
||||
.toList();
|
||||
}
|
||||
|
||||
private List<PairCandidate> trimPairCandidates(List<PairCandidate> candidates,
|
||||
List<Member> members) {
|
||||
int limit = maxPairCandidatesPerMember();
|
||||
if (limit <= 0) {
|
||||
return candidates;
|
||||
}
|
||||
|
||||
Map<String, Member> memberMap = toMemberMap(members);
|
||||
Map<String, Integer> memberUsage = new HashMap<>();
|
||||
List<PairCandidate> selected = new ArrayList<>();
|
||||
Set<String> selectedKeys = new LinkedHashSet<>();
|
||||
|
||||
for (PairCandidate candidate : candidates.stream()
|
||||
.sorted(pairCandidateComparator(memberMap))
|
||||
.toList()) {
|
||||
int fieldCount = memberUsage.getOrDefault(candidate.getFieldMemberId(), 0);
|
||||
int externalCount = memberUsage.getOrDefault(candidate.getExternalMemberId(), 0);
|
||||
if (fieldCount < limit && externalCount < limit) {
|
||||
addPairCandidate(selected, selectedKeys, memberUsage, candidate);
|
||||
}
|
||||
}
|
||||
|
||||
Set<String> missingMemberIds = candidates.stream()
|
||||
.flatMap(candidate -> java.util.stream.Stream.of(candidate.getFieldMemberId(),
|
||||
candidate.getExternalMemberId()))
|
||||
.filter(memberId -> memberUsage.getOrDefault(memberId, 0) == 0)
|
||||
.collect(Collectors.toCollection(LinkedHashSet::new));
|
||||
|
||||
for (PairCandidate candidate : candidates.stream()
|
||||
.sorted(pairCandidateComparator(memberMap))
|
||||
.toList()) {
|
||||
if (missingMemberIds.isEmpty()) {
|
||||
break;
|
||||
}
|
||||
if (selectedKeys.contains(pairKey(candidate))) {
|
||||
continue;
|
||||
}
|
||||
if (!missingMemberIds.contains(candidate.getFieldMemberId())
|
||||
&& !missingMemberIds.contains(candidate.getExternalMemberId())) {
|
||||
continue;
|
||||
}
|
||||
|
||||
addPairCandidate(selected, selectedKeys, memberUsage, candidate);
|
||||
missingMemberIds.remove(candidate.getFieldMemberId());
|
||||
missingMemberIds.remove(candidate.getExternalMemberId());
|
||||
}
|
||||
|
||||
return selected;
|
||||
}
|
||||
|
||||
private void addPairCandidate(List<PairCandidate> selected, Set<String> selectedKeys,
|
||||
Map<String, Integer> memberUsage, PairCandidate candidate) {
|
||||
selected.add(candidate);
|
||||
selectedKeys.add(pairKey(candidate));
|
||||
memberUsage.merge(candidate.getFieldMemberId(), 1, Integer::sum);
|
||||
memberUsage.merge(candidate.getExternalMemberId(), 1, Integer::sum);
|
||||
}
|
||||
|
||||
private List<Center> centersForDispatch(Set<String> adjacentClassifications,
|
||||
Map<String, List<Center>> centersByAdjacentClassification) {
|
||||
return adjacentClassifications.stream()
|
||||
.flatMap(adjacentClassification -> centersByAdjacentClassification
|
||||
.getOrDefault(adjacentClassification, List.of()).stream())
|
||||
.toList();
|
||||
}
|
||||
|
||||
private void addBoundedAssignmentCandidate(
|
||||
Map<String, PriorityQueue<AssignmentCandidate>> centerCandidateBuckets,
|
||||
Map<String, PriorityQueue<AssignmentCandidate>> memberCandidateBuckets,
|
||||
AssignmentCandidate candidate) {
|
||||
// 후보 수가 너무 커지면 처리 시간이 급격히 늘어납니다.
|
||||
// 센터별/위원별 후보 상한을 두되, 0이면 제한하지 않습니다.
|
||||
addBounded(centerCandidateBuckets, candidate.getCenterId(), candidate,
|
||||
maxAssignmentsPerCenter());
|
||||
addBounded(memberCandidateBuckets, candidate.getFieldMemberId(), candidate,
|
||||
maxAssignmentsPerMember());
|
||||
addBounded(memberCandidateBuckets, candidate.getExternalMemberId(), candidate,
|
||||
maxAssignmentsPerMember());
|
||||
}
|
||||
|
||||
private void addBounded(Map<String, PriorityQueue<AssignmentCandidate>> buckets, String key,
|
||||
AssignmentCandidate candidate, int limit) {
|
||||
PriorityQueue<AssignmentCandidate> bucket = buckets.computeIfAbsent(key,
|
||||
ignored -> new PriorityQueue<>(worstAssignmentComparator()));
|
||||
if (limit <= 0 || bucket.size() < limit) {
|
||||
bucket.add(candidate);
|
||||
return;
|
||||
}
|
||||
|
||||
AssignmentCandidate worstCandidate = bucket.peek();
|
||||
if (worstCandidate != null
|
||||
&& assignmentCandidateComparator().compare(candidate, worstCandidate) < 0) {
|
||||
bucket.poll();
|
||||
bucket.add(candidate);
|
||||
}
|
||||
}
|
||||
|
||||
private List<AssignmentCandidate> mergeAssignmentCandidateBuckets(
|
||||
Map<String, PriorityQueue<AssignmentCandidate>> centerCandidateBuckets,
|
||||
Map<String, PriorityQueue<AssignmentCandidate>> memberCandidateBuckets) {
|
||||
Map<String, AssignmentCandidate> merged = new LinkedHashMap<>();
|
||||
centerCandidateBuckets.values().forEach(bucket -> bucket.forEach(candidate ->
|
||||
merged.putIfAbsent(assignmentKey(candidate), candidate)));
|
||||
memberCandidateBuckets.values().forEach(bucket -> bucket.forEach(candidate ->
|
||||
merged.putIfAbsent(assignmentKey(candidate), candidate)));
|
||||
return merged.values().stream()
|
||||
.sorted(assignmentCandidateComparator())
|
||||
.toList();
|
||||
}
|
||||
|
||||
private List<AssignmentCandidate> trimAssignmentCandidates(List<AssignmentCandidate> candidates,
|
||||
List<Center> centers, Map<String, Set<String>> unassignedCenterReasons) {
|
||||
List<AssignmentCandidate> trimmedByCenter = trimAssignmentsPerCenter(candidates);
|
||||
@@ -375,13 +504,14 @@ public class PairingCandidateService {
|
||||
|
||||
private Optional<PreferenceMatchRule> findPreferenceMatchRule(List<PreferenceMatchRule> rules,
|
||||
int fieldRank, int externalRank) {
|
||||
return fieldRank >= 0 && externalRank >= 0 ?
|
||||
rules.stream().filter(
|
||||
// 99 규칙은 wildcard입니다. 예를 들어 fieldRank가 -1이어도
|
||||
// 매칭표에 99/1 규칙이 있으면 "현장위원 선호지역 고려하지 않음 + 외부위원 1순위"로 인정합니다.
|
||||
return rules.stream().filter(
|
||||
rule -> matchesPreferenceRank(rule.getFieldMemberPreferenceRank(), fieldRank)
|
||||
)
|
||||
.filter(rule -> matchesPreferenceRank(rule.getExternalMemberPreferenceRank(),externalRank))
|
||||
.filter(rule -> matchesPreferenceRank(rule.getExternalMemberPreferenceRank(), externalRank))
|
||||
.min(Comparator.comparingInt(PreferenceMatchRule::getPriority))
|
||||
: Optional.empty();
|
||||
;
|
||||
}
|
||||
|
||||
private int fallbackPreferencePriority(List<PreferenceMatchRule> rules) {
|
||||
@@ -425,14 +555,30 @@ public class PairingCandidateService {
|
||||
if (isAvailableOn(date, fieldMember, externalMember, municipality, center,
|
||||
commonUnavailableDates)) {
|
||||
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,
|
||||
@@ -520,10 +666,22 @@ public class PairingCandidateService {
|
||||
return pairingProperties.getCandidate().getMaxAssignmentsPerMember();
|
||||
}
|
||||
|
||||
private int maxPairCandidatesPerMember() {
|
||||
return pairingProperties.getCandidate().getMaxPairCandidatesPerMember();
|
||||
}
|
||||
|
||||
private int maxDatesPerAssignmentCandidate() {
|
||||
return pairingProperties.getCandidate().getMaxDatesPerAssignmentCandidate();
|
||||
}
|
||||
|
||||
private Comparator<PairCandidate> pairCandidateComparator(Map<String, Member> memberMap) {
|
||||
return Comparator.comparingInt((PairCandidate candidate) -> pairCandidateScore(candidate,
|
||||
memberMap))
|
||||
.reversed()
|
||||
.thenComparing(PairCandidate::getFieldMemberId)
|
||||
.thenComparing(PairCandidate::getExternalMemberId);
|
||||
}
|
||||
|
||||
private Comparator<DispatchRegionCandidate> dispatchRegionCandidateComparator() {
|
||||
return Comparator.comparingInt(this::dispatchRegionCandidateScore).reversed()
|
||||
.thenComparing(DispatchRegionCandidate::getDispatchRegion);
|
||||
@@ -537,20 +695,72 @@ public class PairingCandidateService {
|
||||
.thenComparing(AssignmentCandidate::getExternalMemberId);
|
||||
}
|
||||
|
||||
private Comparator<AssignmentCandidate> worstAssignmentComparator() {
|
||||
return Comparator.comparingInt(this::assignmentCandidateScore)
|
||||
.thenComparing(AssignmentCandidate::getDate, Comparator.reverseOrder())
|
||||
.thenComparing(AssignmentCandidate::getCenterId, Comparator.reverseOrder())
|
||||
.thenComparing(AssignmentCandidate::getFieldMemberId, Comparator.reverseOrder())
|
||||
.thenComparing(AssignmentCandidate::getExternalMemberId, Comparator.reverseOrder());
|
||||
}
|
||||
|
||||
private int dispatchRegionCandidateScore(DispatchRegionCandidate candidate) {
|
||||
return preferenceScore(candidate.getPreferencePriority())
|
||||
+ preferenceRankBonus(candidate.getFieldMemberPreferenceRank())
|
||||
+ preferenceRankBonus(candidate.getExternalMemberPreferenceRank());
|
||||
}
|
||||
|
||||
private int pairCandidateScore(PairCandidate candidate, Map<String, Member> memberMap) {
|
||||
Member fieldMember = memberMap.get(candidate.getFieldMemberId());
|
||||
Member externalMember = memberMap.get(candidate.getExternalMemberId());
|
||||
return preferenceIntersectionScore(fieldMember, externalMember)
|
||||
+ candidate.getResidenceMatchScore() * 10;
|
||||
}
|
||||
|
||||
private int preferenceIntersectionScore(Member fieldMember, Member externalMember) {
|
||||
if (fieldMember == null || externalMember == null) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
Set<String> externalPreferences = new LinkedHashSet<>(externalMember.getPreferenceRegions());
|
||||
int score = 0;
|
||||
for (String preference : fieldMember.getPreferenceRegions()) {
|
||||
if (ignoredPreferenceCode(preference)) {
|
||||
continue;
|
||||
}
|
||||
if (anyRegionCode().equals(preference) && externalPreferences.contains(preference)) {
|
||||
score += 10;
|
||||
} else if (externalPreferences.contains(preference)) {
|
||||
score += 100;
|
||||
}
|
||||
}
|
||||
return score;
|
||||
}
|
||||
|
||||
private boolean ignoredPreferenceCode(String preference) {
|
||||
return String.valueOf(ignoredPreferenceRank()).equals(preference);
|
||||
}
|
||||
|
||||
private int assignmentCandidateScore(AssignmentCandidate candidate) {
|
||||
return preferenceScore(candidate.getPreferencePriority())
|
||||
+ preferenceRankBonus(candidate.getFieldMemberPreferenceRank())
|
||||
+ preferenceRankBonus(candidate.getExternalMemberPreferenceRank())
|
||||
+ wildcardFallbackBonus(candidate)
|
||||
+ candidate.getResidenceMatchScore() * (int) pairingProperties.getObjective()
|
||||
.getResidenceMatchWeight();
|
||||
}
|
||||
|
||||
private int wildcardFallbackBonus(AssignmentCandidate candidate) {
|
||||
// wildcard 적극 사용 옵션입니다. true이면 99 규칙으로 살아난 후보가
|
||||
// 후보 축소 단계에서 너무 쉽게 밀려나지 않도록 보너스를 줍니다.
|
||||
if (!activeWildcardFallbackEnabled()) {
|
||||
return 0;
|
||||
}
|
||||
if (!usesWildcardFallback(candidate)) {
|
||||
return 0;
|
||||
}
|
||||
return (int) Math.min(Integer.MAX_VALUE, wildcardFallbackScoreBonus());
|
||||
}
|
||||
|
||||
private int preferenceScore(int priority) {
|
||||
return (int) Math.max(0L, pairingProperties.getObjective().getPreferenceBaseWeight()
|
||||
- priority * pairingProperties.getObjective().getPreferenceRankPenalty());
|
||||
@@ -568,6 +778,19 @@ public class PairingCandidateService {
|
||||
return Math.max(0, 10 - rank);
|
||||
}
|
||||
|
||||
private boolean usesWildcardFallback(AssignmentCandidate candidate) {
|
||||
return candidate.getFieldMemberPreferenceRank() < 0
|
||||
|| candidate.getExternalMemberPreferenceRank() < 0;
|
||||
}
|
||||
|
||||
private boolean activeWildcardFallbackEnabled() {
|
||||
return pairingProperties.getPreference().isActiveWildcardFallbackEnabled();
|
||||
}
|
||||
|
||||
private long wildcardFallbackScoreBonus() {
|
||||
return pairingProperties.getPreference().getWildcardFallbackScoreBonus();
|
||||
}
|
||||
|
||||
private LocalDate max(LocalDate left, LocalDate right) {
|
||||
return left.isAfter(right) ? left : right;
|
||||
}
|
||||
|
||||
@@ -1,6 +1,7 @@
|
||||
package com.kri.p6.ncrc.pairing.service;
|
||||
|
||||
import static com.kri.p6.ncrc.pairing.common.consts.PairingConstant.RESULT_SHEET_AB_PAIR;
|
||||
import static com.kri.p6.ncrc.pairing.common.consts.PairingConstant.RESULT_SHEET_APPLIED_SETTING;
|
||||
import static com.kri.p6.ncrc.pairing.common.consts.PairingConstant.RESULT_SHEET_ASSIGNMENT;
|
||||
import static com.kri.p6.ncrc.pairing.common.consts.PairingConstant.RESULT_SHEET_CANDIDATE_SUMMARY;
|
||||
import static com.kri.p6.ncrc.pairing.common.consts.PairingConstant.RESULT_SHEET_RULE_CHECK;
|
||||
@@ -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.PreferenceMatchExcelDto;
|
||||
import com.kri.p6.ncrc.pairing.dto.excel.output.ABPairExcelDto;
|
||||
import com.kri.p6.ncrc.pairing.dto.excel.output.AppliedSettingExcelDto;
|
||||
import com.kri.p6.ncrc.pairing.dto.excel.output.AssignmentResultExcelDto;
|
||||
import com.kri.p6.ncrc.pairing.dto.excel.output.CandidateSummaryExcelDto;
|
||||
import com.kri.p6.ncrc.pairing.dto.excel.output.PairingSummaryExcelDto;
|
||||
@@ -93,6 +95,8 @@ public class PairingExcelService {
|
||||
RESULT_SHEET_AB_PAIR, headerRowIndex());
|
||||
ExcelMapper.appendSheetToWorkbook(workbook, result.getCandidateSummaries(),
|
||||
CandidateSummaryExcelDto.class, RESULT_SHEET_CANDIDATE_SUMMARY, headerRowIndex());
|
||||
ExcelMapper.appendSheetToWorkbook(workbook, result.getAppliedSettings(),
|
||||
AppliedSettingExcelDto.class, RESULT_SHEET_APPLIED_SETTING, headerRowIndex());
|
||||
ExcelMapper.appendSheetToWorkbook(workbook, result.getValidationErrors(),
|
||||
ValidationErrorExcelDto.class, RESULT_SHEET_VALIDATION_ERROR, headerRowIndex());
|
||||
ExcelMapper.appendSheetToWorkbook(workbook, result.getRuleViolations(),
|
||||
@@ -114,6 +118,7 @@ public class PairingExcelService {
|
||||
.summaries(List.of(new PairingSummaryExcelDto("처리 상태", "검증 실패")))
|
||||
.abPairs(List.of())
|
||||
.candidateSummaries(List.of())
|
||||
.appliedSettings(appliedSettings())
|
||||
.validationErrors(List.of(new ValidationErrorExcelDto(code, message, "ERROR")))
|
||||
.ruleViolations(List.of())
|
||||
.build();
|
||||
@@ -135,6 +140,93 @@ public class PairingExcelService {
|
||||
return pairingProperties.getExcel().getHeaderRowIndex();
|
||||
}
|
||||
|
||||
private List<AppliedSettingExcelDto> appliedSettings() {
|
||||
PairingProperties.Excel excel = pairingProperties.getExcel();
|
||||
PairingProperties.Code code = pairingProperties.getCode();
|
||||
PairingProperties.Rule rule = pairingProperties.getRule();
|
||||
PairingProperties.Preference preference = pairingProperties.getPreference();
|
||||
PairingProperties.Objective objective = pairingProperties.getObjective();
|
||||
PairingProperties.Candidate candidate = pairingProperties.getCandidate();
|
||||
PairingProperties.Solver solver = pairingProperties.getSolver();
|
||||
return List.of(
|
||||
setting("pairing.excel.header-row-index",
|
||||
"엑셀 헤더로 사용할 행 인덱스",
|
||||
excel.getHeaderRowIndex()),
|
||||
setting("pairing.code.region-code-length",
|
||||
"지역코드 정규화 길이", code.getRegionCodeLength()),
|
||||
setting("pairing.code.residence-code-length",
|
||||
"거주지코드 정규화 길이",
|
||||
code.getResidenceCodeLength()),
|
||||
setting("pairing.code.residence-match-prefix-length",
|
||||
"거주지 일치 판단에 사용하는 앞자리 길이",
|
||||
code.getResidenceMatchPrefixLength()),
|
||||
setting("pairing.code.any-region-code",
|
||||
"희망지역 anywhere로 처리하는 코드",
|
||||
code.getAnyRegionCode()),
|
||||
setting("pairing.rule.max-centers-per-pair-per-day",
|
||||
"같은 페어가 하루에 방문할 수 있는 최대 센터 수",
|
||||
rule.getMaxCentersPerPairPerDay()),
|
||||
setting("pairing.rule.max-counterparts-per-member",
|
||||
"위원 1명당 허용되는 상대 위원 최대 수",
|
||||
rule.getMaxCounterpartsPerMember()),
|
||||
setting("pairing.rule.max-member-visit-average-ratio-percent",
|
||||
"위원별 방문 수 상한을 평균 대비 몇 %까지 허용할지",
|
||||
rule.getMaxMemberVisitAverageRatioPercent()),
|
||||
setting("pairing.preference.anywhere-rank",
|
||||
"선호지역 anywhere를 의미하는 순위",
|
||||
preference.getAnywhereRank()),
|
||||
setting("pairing.preference.ignored-rank",
|
||||
"선호지역 고려하지 않음을 의미하는 순위",
|
||||
preference.getIgnoredRank()),
|
||||
setting("pairing.preference.active-wildcard-fallback-enabled",
|
||||
"희망지역 고려하지 않음을 wildcard로 적극 사용할지",
|
||||
preference.isActiveWildcardFallbackEnabled()),
|
||||
setting("pairing.preference.wildcard-fallback-score-bonus",
|
||||
"wildcard 후보에 추가할 점수",
|
||||
preference.getWildcardFallbackScoreBonus()),
|
||||
setting("pairing.objective.assignment-weight",
|
||||
"센터 하나를 더 배정하는 것에 부여하는 기본 점수",
|
||||
objective.getAssignmentWeight()),
|
||||
setting("pairing.objective.preference-base-weight",
|
||||
"희망지역 매칭 품질에 부여하는 기본 점수",
|
||||
objective.getPreferenceBaseWeight()),
|
||||
setting("pairing.objective.preference-rank-penalty",
|
||||
"희망순위가 낮아질 때 감점하는 점수",
|
||||
objective.getPreferenceRankPenalty()),
|
||||
setting("pairing.objective.residence-match-weight",
|
||||
"거주지 유사도 점수에 곱하는 가중치",
|
||||
objective.getResidenceMatchWeight()),
|
||||
setting("pairing.objective.member-balance-weight",
|
||||
"방문 수가 많은 위원을 더 선택하지 않도록 감점하는 가중치",
|
||||
objective.getMemberBalanceWeight()),
|
||||
setting("pairing.candidate.max-pair-candidates-per-member",
|
||||
"위원별 페어 후보 축소 상한, 0이면 무제한",
|
||||
candidate.getMaxPairCandidatesPerMember()),
|
||||
setting("pairing.candidate.max-dispatch-regions-per-pair",
|
||||
"페어별 파견 권역 후보 축소 상한, 0이면 무제한",
|
||||
candidate.getMaxDispatchRegionsPerPair()),
|
||||
setting("pairing.candidate.max-assignments-per-center",
|
||||
"센터별 배정 후보 축소 상한",
|
||||
candidate.getMaxAssignmentsPerCenter()),
|
||||
setting("pairing.candidate.max-assignments-per-member",
|
||||
"위원별 배정 후보 축소 상한",
|
||||
candidate.getMaxAssignmentsPerMember()),
|
||||
setting("pairing.candidate.max-dates-per-assignment-candidate",
|
||||
"하나의 페어-센터 조합에서 확장할 날짜 후보 상한",
|
||||
candidate.getMaxDatesPerAssignmentCandidate()),
|
||||
setting("pairing.solver.max-time-seconds",
|
||||
"CP-SAT 사용 시 허용할 최대 탐색 시간",
|
||||
solver.getMaxTimeSeconds()),
|
||||
setting("pairing.solver.num-search-workers",
|
||||
"CP-SAT 사용 시 사용할 worker 수",
|
||||
solver.getNumSearchWorkers())
|
||||
);
|
||||
}
|
||||
|
||||
private AppliedSettingExcelDto setting(String name, String description, Object value) {
|
||||
return new AppliedSettingExcelDto(name, description, String.valueOf(value));
|
||||
}
|
||||
|
||||
private boolean isBlankRow(Object row) {
|
||||
return Arrays.stream(row.getClass().getDeclaredFields())
|
||||
.allMatch(field -> isBlankField(row, field));
|
||||
|
||||
@@ -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) {
|
||||
}
|
||||
}
|
||||
File diff suppressed because it is too large
Load Diff
@@ -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.config.PairingProperties;
|
||||
import com.kri.p6.ncrc.pairing.dto.excel.output.ABPairExcelDto;
|
||||
import com.kri.p6.ncrc.pairing.dto.excel.output.AppliedSettingExcelDto;
|
||||
import com.kri.p6.ncrc.pairing.dto.excel.output.AssignmentResultExcelDto;
|
||||
import com.kri.p6.ncrc.pairing.dto.excel.output.CandidateSummaryExcelDto;
|
||||
import com.kri.p6.ncrc.pairing.dto.excel.output.PairingSummaryExcelDto;
|
||||
@@ -52,7 +53,7 @@ public class PairingSolverService {
|
||||
if (!selection.hasSolution()) {
|
||||
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) {
|
||||
@@ -61,65 +62,40 @@ public class PairingSolverService {
|
||||
|
||||
public SolveSelection select(PairingCandidates candidates,
|
||||
Map<String, Set<String>> existingCounterpartsByMember) {
|
||||
return select(candidates, existingCounterpartsByMember, Map.of(), Set.of());
|
||||
return select(candidates, existingCounterpartsByMember, Map.of());
|
||||
}
|
||||
|
||||
public SolveSelection select(PairingCandidates candidates,
|
||||
Map<String, Set<String>> existingCounterpartsByMember, Map<String, Integer> visitCountsByMember,
|
||||
Set<String> mandatoryMemberIds) {
|
||||
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) {
|
||||
Map<String, Set<String>> existingCounterpartsByMember,
|
||||
Map<String, Integer> visitCountsByMember) {
|
||||
if (candidates.getAssignmentCandidates().isEmpty()) {
|
||||
return new SolveSelection(false, List.of(), "배정 가능한 후보가 없습니다.");
|
||||
}
|
||||
|
||||
CpModel model = new CpModel();
|
||||
List<AssignmentCandidate> assignmentCandidates = candidates.getAssignmentCandidates();
|
||||
// CP-SAT에서는 각 배정 후보를 0/1 변수로 봅니다.
|
||||
// 1이면 해당 후보 선택, 0이면 미선택입니다.
|
||||
BoolVar[] assignmentVars = createAssignmentVars(model, assignmentCandidates);
|
||||
Map<String, BoolVar> pairUsedVars = createPairUsedVars(model, assignmentCandidates);
|
||||
Map<String, BoolVar> pairDayVars = createPairDayVars(model, assignmentCandidates);
|
||||
Map<String, BoolVar> pairDayAdjacentVars = createPairDayAdjacentVars(model, assignmentCandidates);
|
||||
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);
|
||||
linkMemberUsedVars(model, assignmentCandidates, assignmentVars, memberUsedVars);
|
||||
addMandatoryMemberUsed(model, memberUsedVars, mandatoryMemberIds);
|
||||
addCenterAssignedAtMostOnce(model, assignmentCandidates, assignmentVars);
|
||||
addPairDailyCapacity(model, assignmentCandidates, assignmentVars);
|
||||
addMemberDailyOnePair(model, assignmentCandidates, pairDayVars);
|
||||
addPairDailyOneAdjacentClassification(model, assignmentCandidates, pairDayAdjacentVars);
|
||||
if (enforceCounterpartLimit) {
|
||||
addCumulativeBuddyLimit(model, assignmentCandidates, pairUsedVars,
|
||||
existingCounterpartsByMember);
|
||||
}
|
||||
model.maximize(createObjective(assignmentCandidates, assignmentVars, memberUsedVars,
|
||||
visitCountsByMember));
|
||||
addCumulativeBuddyLimit(model, assignmentCandidates, pairUsedVars,
|
||||
existingCounterpartsByMember);
|
||||
model.maximize(createObjective(assignmentCandidates, assignmentVars, visitCountsByMember));
|
||||
|
||||
CpSolver solver = new CpSolver();
|
||||
solver.getParameters().setMaxTimeInSeconds(pairingProperties.getSolver().getMaxTimeSeconds());
|
||||
solver.getParameters().setNumSearchWorkers(pairingProperties.getSolver().getNumSearchWorkers());
|
||||
CpSolverStatus status = solver.solve(model);
|
||||
if (status != CpSolverStatus.OPTIMAL && status != CpSolverStatus.FEASIBLE) {
|
||||
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(true, collectSelectedAssignments(assignmentCandidates, assignmentVars, solver), status.name());
|
||||
@@ -127,7 +103,12 @@ public class PairingSolverService {
|
||||
|
||||
public PairingResult buildResult(PairingData data, PairingCandidates candidates,
|
||||
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) {
|
||||
@@ -153,16 +134,6 @@ public class PairingSolverService {
|
||||
.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,
|
||||
BoolVar[] assignmentVars, Map<String, BoolVar> pairUsedVars, Map<String, BoolVar> pairDayVars,
|
||||
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,
|
||||
BoolVar[] assignmentVars) {
|
||||
// 하나의 센터는 최대 1번만 배정됩니다.
|
||||
groupIndexes(candidates, AssignmentCandidate::getCenterId).values()
|
||||
.forEach(indexes -> model.addAtMostOne(toLiteralArray(indexes, assignmentVars)));
|
||||
}
|
||||
|
||||
private void addPairDailyCapacity(CpModel model, List<AssignmentCandidate> candidates,
|
||||
BoolVar[] assignmentVars) {
|
||||
// 같은 조가 하루에 방문할 수 있는 센터 수 상한입니다.
|
||||
groupIndexes(candidates, this::pairDayKey).values().forEach(indexes -> model.addLessOrEqual(
|
||||
LinearExpr.sum(toLinearArgumentArray(indexes, assignmentVars)),
|
||||
pairingProperties.getRule().getMaxCentersPerPairPerDay()));
|
||||
@@ -215,6 +162,7 @@ public class PairingSolverService {
|
||||
|
||||
private void addMemberDailyOnePair(CpModel model, List<AssignmentCandidate> candidates,
|
||||
Map<String, BoolVar> pairDayVars) {
|
||||
// 한 위원은 같은 날짜에 여러 조로 동시에 활동할 수 없습니다.
|
||||
Map<String, Set<String>> pairDayKeysByMemberDay = candidates.stream()
|
||||
.collect(Collectors.groupingBy(candidate -> candidate.getFieldMemberId() + "|" + candidate.getDate(),
|
||||
Collectors.mapping(this::pairDayKey, Collectors.toSet())));
|
||||
@@ -231,6 +179,7 @@ public class PairingSolverService {
|
||||
|
||||
private void addPairDailyOneAdjacentClassification(CpModel model,
|
||||
List<AssignmentCandidate> candidates, Map<String, BoolVar> pairDayAdjacentVars) {
|
||||
// 같은 조/같은 날짜에는 하나의 인접지역 분류만 방문합니다.
|
||||
Map<String, Set<String>> adjacentKeysByPairDay = candidates.stream()
|
||||
.collect(Collectors.groupingBy(this::pairDayKey,
|
||||
Collectors.mapping(this::pairDayAdjacentKey, Collectors.toSet())));
|
||||
@@ -240,6 +189,7 @@ public class PairingSolverService {
|
||||
|
||||
private void addCumulativeBuddyLimit(CpModel model, List<AssignmentCandidate> candidates,
|
||||
Map<String, BoolVar> pairUsedVars, Map<String, Set<String>> existingCounterpartsByMember) {
|
||||
// 위원 1명당 누적 상대 위원 수 제한입니다. 현재 업무 기준은 application.yaml의 max-counterparts-per-member입니다.
|
||||
Map<String, Set<String>> pairKeysByMember = candidates.stream()
|
||||
.collect(Collectors.groupingBy(AssignmentCandidate::getFieldMemberId,
|
||||
Collectors.mapping(this::pairKey, Collectors.toSet())));
|
||||
@@ -270,8 +220,9 @@ public class PairingSolverService {
|
||||
}
|
||||
|
||||
private LinearExpr createObjective(List<AssignmentCandidate> candidates,
|
||||
BoolVar[] assignmentVars, Map<String, BoolVar> memberUsedVars,
|
||||
Map<String, Integer> visitCountsByMember) {
|
||||
BoolVar[] assignmentVars, Map<String, Integer> visitCountsByMember) {
|
||||
// soft rule 점수입니다. 센터를 많이 배정하는 점수가 가장 크고,
|
||||
// 희망지역/거주지/방문 균형은 같은 배정 수 안에서 우열을 정하는 보조 점수입니다.
|
||||
List<LinearArgument> vars = new ArrayList<>();
|
||||
List<Long> weights = new ArrayList<>();
|
||||
for (int i = 0; i < assignmentVars.length; i++) {
|
||||
@@ -284,13 +235,6 @@ public class PairingSolverService {
|
||||
- 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),
|
||||
weights.stream().mapToLong(Long::longValue).toArray());
|
||||
}
|
||||
@@ -316,11 +260,12 @@ public class PairingSolverService {
|
||||
return selected;
|
||||
}
|
||||
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> usedMemberIds = selectedAssignments.stream()
|
||||
.flatMap(candidate -> Stream.of(candidate.getFieldMemberId(), candidate.getExternalMemberId()))
|
||||
.collect(Collectors.toSet());
|
||||
usedMemberIds.addAll(pairedMemberIds);
|
||||
Map<String, Member> memberMap = data.getMembers().stream()
|
||||
.collect(Collectors.toMap(Member::getId, Function.identity(), (left, right) -> left));
|
||||
Map<String, Center> centerMap = data.getCenters().stream()
|
||||
@@ -350,8 +295,9 @@ public class PairingSolverService {
|
||||
.abPairs(abPairBuildResult.rows())
|
||||
.candidateSummaries(createCandidateSummaries(data, candidates, assignments.size(),
|
||||
unassignedCenters.size(), unusedMembers.size(), countABGroups(abPairMatches)))
|
||||
.appliedSettings(createAppliedSettings())
|
||||
.validationErrors(List.of())
|
||||
.ruleViolations(createRuleChecks(data, selectedAssignments, abPairMatches))
|
||||
.ruleViolations(createRuleChecks(data, selectedAssignments, abPairMatches, pairedMemberIds))
|
||||
.build();
|
||||
}
|
||||
|
||||
@@ -367,6 +313,7 @@ public class PairingSolverService {
|
||||
.summaries(createSummaries(data, candidates, 0, data.getCenters().size(), data.getMembers().size(), 0, reason))
|
||||
.abPairs(List.of())
|
||||
.candidateSummaries(createCandidateSummaries(data, candidates, 0, data.getCenters().size(), data.getMembers().size(), 0))
|
||||
.appliedSettings(createAppliedSettings())
|
||||
.validationErrors(List.of())
|
||||
.ruleViolations(List.of(new RuleViolationExcelDto("solver feasible 해", "FAIL", reason)))
|
||||
.build();
|
||||
@@ -395,8 +342,8 @@ public class PairingSolverService {
|
||||
}
|
||||
|
||||
private UnassignedCenterExcelDto toUnassignedCenter(Center center, Map<String, Set<String>> reasonMap) {
|
||||
Set<String> reasons = new LinkedHashSet<>((Collection<String>) (reasonMap == null ? Set.of()
|
||||
: reasonMap.getOrDefault(center.getId(), Set.of())));
|
||||
Set<String> reasons = new LinkedHashSet<>(reasonMap == null ? Set.of()
|
||||
: reasonMap.getOrDefault(center.getId(), Set.of()));
|
||||
reasons.add("solver 최적화에서 선택되지 않음");
|
||||
return new UnassignedCenterExcelDto(center.getId(), center.getMunicipalityId(), String.join(", ", reasons));
|
||||
}
|
||||
@@ -521,8 +468,96 @@ public class PairingSolverService {
|
||||
new CandidateSummaryExcelDto("AB 그룹 수", String.valueOf(abGroupCount), "후처리로 구성된 AB 그룹 수"));
|
||||
}
|
||||
|
||||
private List<AppliedSettingExcelDto> createAppliedSettings() {
|
||||
PairingProperties.Excel excel = pairingProperties.getExcel();
|
||||
PairingProperties.Code code = pairingProperties.getCode();
|
||||
PairingProperties.Rule rule = pairingProperties.getRule();
|
||||
PairingProperties.Preference preference = pairingProperties.getPreference();
|
||||
PairingProperties.Objective objective = pairingProperties.getObjective();
|
||||
PairingProperties.Candidate candidate = pairingProperties.getCandidate();
|
||||
PairingProperties.Solver solver = pairingProperties.getSolver();
|
||||
return List.of(
|
||||
setting("pairing.excel.header-row-index",
|
||||
"엑셀 헤더로 사용할 행 인덱스",
|
||||
excel.getHeaderRowIndex()),
|
||||
setting("pairing.code.region-code-length",
|
||||
"지역코드 정규화 길이", code.getRegionCodeLength()),
|
||||
setting("pairing.code.residence-code-length",
|
||||
"거주지코드 정규화 길이",
|
||||
code.getResidenceCodeLength()),
|
||||
setting("pairing.code.residence-match-prefix-length",
|
||||
"거주지 일치 판단에 사용하는 앞자리 길이",
|
||||
code.getResidenceMatchPrefixLength()),
|
||||
setting("pairing.code.any-region-code",
|
||||
"희망지역 anywhere로 처리하는 코드",
|
||||
code.getAnyRegionCode()),
|
||||
setting("pairing.rule.max-centers-per-pair-per-day",
|
||||
"페어가 하루에 방문할 수 있는 최대 센터 수",
|
||||
rule.getMaxCentersPerPairPerDay()),
|
||||
setting("pairing.rule.max-counterparts-per-member",
|
||||
"위원 1명당 허용되는 상대 위원 최대 수",
|
||||
rule.getMaxCounterpartsPerMember()),
|
||||
setting("pairing.rule.max-member-visit-average-ratio-percent",
|
||||
"위원별 방문 수 상한을 평균 대비 몇 %까지 허용할지",
|
||||
rule.getMaxMemberVisitAverageRatioPercent()),
|
||||
setting("pairing.preference.anywhere-rank",
|
||||
"선호지역 anywhere를 의미하는 순위",
|
||||
preference.getAnywhereRank()),
|
||||
setting("pairing.preference.ignored-rank",
|
||||
"선호지역 고려하지 않음을 의미하는 순위",
|
||||
preference.getIgnoredRank()),
|
||||
setting("pairing.preference.active-wildcard-fallback-enabled",
|
||||
"희망지역 고려하지 않음을 wildcard로 적극 사용할지",
|
||||
preference.isActiveWildcardFallbackEnabled()),
|
||||
setting("pairing.preference.wildcard-fallback-score-bonus",
|
||||
"wildcard 후보에 추가할 점수",
|
||||
preference.getWildcardFallbackScoreBonus()),
|
||||
setting("pairing.objective.assignment-weight",
|
||||
"센터 하나를 더 배정하는 것에 부여하는 기본 점수",
|
||||
objective.getAssignmentWeight()),
|
||||
setting("pairing.objective.preference-base-weight",
|
||||
"희망지역 매칭 품질에 부여하는 기본 점수",
|
||||
objective.getPreferenceBaseWeight()),
|
||||
setting("pairing.objective.preference-rank-penalty",
|
||||
"희망순위가 낮아질 때 감점하는 점수",
|
||||
objective.getPreferenceRankPenalty()),
|
||||
setting("pairing.objective.residence-match-weight",
|
||||
"거주지 유사도 점수에 곱하는 가중치",
|
||||
objective.getResidenceMatchWeight()),
|
||||
setting("pairing.objective.member-balance-weight",
|
||||
"방문 수가 많은 위원을 더 선택하지 않도록 감점하는 가중치",
|
||||
objective.getMemberBalanceWeight()),
|
||||
setting("pairing.candidate.max-pair-candidates-per-member",
|
||||
"위원별 페어 후보 축소 상한, 0이면 무제한",
|
||||
candidate.getMaxPairCandidatesPerMember()),
|
||||
setting("pairing.candidate.max-dispatch-regions-per-pair",
|
||||
"페어별 파견 권역 후보 축소 상한, 0이면 무제한",
|
||||
candidate.getMaxDispatchRegionsPerPair()),
|
||||
setting("pairing.candidate.max-assignments-per-center",
|
||||
"센터별 배정 후보 축소 상한",
|
||||
candidate.getMaxAssignmentsPerCenter()),
|
||||
setting("pairing.candidate.max-assignments-per-member",
|
||||
"위원별 배정 후보 축소 상한",
|
||||
candidate.getMaxAssignmentsPerMember()),
|
||||
setting("pairing.candidate.max-dates-per-assignment-candidate",
|
||||
"하나의 페어-센터 조합에서 확장할 날짜 후보 상한",
|
||||
candidate.getMaxDatesPerAssignmentCandidate()),
|
||||
setting("pairing.solver.max-time-seconds",
|
||||
"CP-SAT 사용 시 허용할 최대 탐색 시간",
|
||||
solver.getMaxTimeSeconds()),
|
||||
setting("pairing.solver.num-search-workers",
|
||||
"CP-SAT 사용 시 사용할 worker 수",
|
||||
solver.getNumSearchWorkers())
|
||||
);
|
||||
}
|
||||
|
||||
private AppliedSettingExcelDto setting(String name, String description, Object value) {
|
||||
return new AppliedSettingExcelDto(name, description, String.valueOf(value));
|
||||
}
|
||||
|
||||
private List<RuleViolationExcelDto> createRuleChecks(PairingData data,
|
||||
List<AssignmentCandidate> selectedAssignments, Map<String, ABPairMatch> abPairMatches) {
|
||||
List<AssignmentCandidate> selectedAssignments, Map<String, ABPairMatch> abPairMatches,
|
||||
Set<String> pairedMemberIds) {
|
||||
Map<String, Member> memberMap = data.getMembers().stream()
|
||||
.collect(Collectors.toMap(Member::getId, Function.identity(), (left, right) -> left));
|
||||
Map<String, Center> centerMap = data.getCenters().stream()
|
||||
@@ -538,8 +573,9 @@ public class PairingSolverService {
|
||||
checks.add(checkHistoryCenter(selectedAssignments, memberMap));
|
||||
checks.add(checkHoliday(selectedAssignments, commonUnavailableDates(data)));
|
||||
checks.add(checkABDateOverlap(abPairMatches));
|
||||
checks.add(checkAllMembersUsed(data, selectedAssignments));
|
||||
checks.add(checkAllMembersUsed(data, selectedAssignments, pairedMemberIds));
|
||||
checks.add(checkMemberVisitBalance(data, selectedAssignments));
|
||||
checks.add(checkMemberVisitUpperBound(data, selectedAssignments));
|
||||
return checks;
|
||||
}
|
||||
|
||||
@@ -638,11 +674,12 @@ public class PairingSolverService {
|
||||
}
|
||||
|
||||
private RuleViolationExcelDto checkAllMembersUsed(PairingData data,
|
||||
List<AssignmentCandidate> assignments) {
|
||||
List<AssignmentCandidate> assignments, Set<String> pairedMemberIds) {
|
||||
Set<String> usedMemberIds = assignments.stream()
|
||||
.flatMap(candidate -> Stream.of(candidate.getFieldMemberId(),
|
||||
candidate.getExternalMemberId()))
|
||||
.collect(Collectors.toSet());
|
||||
usedMemberIds.addAll(pairedMemberIds);
|
||||
List<String> unusedMemberIds = data.getMembers().stream()
|
||||
.map(Member::getId)
|
||||
.filter(memberId -> !usedMemberIds.contains(memberId))
|
||||
@@ -662,10 +699,39 @@ public class PairingSolverService {
|
||||
long min = visitCounts.values().stream().mapToLong(Long::longValue).min().orElse(0L);
|
||||
long max = visitCounts.values().stream().mapToLong(Long::longValue).max().orElse(0L);
|
||||
double average = visitCounts.values().stream().mapToLong(Long::longValue).average().orElse(0.0D);
|
||||
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);
|
||||
}
|
||||
|
||||
private long maxMemberVisitCount(PairingData data) {
|
||||
if (data.getMembers().isEmpty()) {
|
||||
return 0L;
|
||||
}
|
||||
double fullAssignmentAverage = (double) data.getCenters().size() * 2D
|
||||
/ data.getMembers().size();
|
||||
return Math.max(1L, (long) Math.ceil(fullAssignmentAverage
|
||||
* pairingProperties.getRule().getMaxMemberVisitAverageRatioPercent() / 100D));
|
||||
}
|
||||
|
||||
private RuleViolationExcelDto checkMemberVisitUpperBound(PairingData data,
|
||||
List<AssignmentCandidate> assignments) {
|
||||
Map<String, Long> visitCounts = data.getMembers().stream()
|
||||
.collect(Collectors.toMap(Member::getId, member -> 0L, (left, right) -> left));
|
||||
assignments.forEach(candidate -> {
|
||||
visitCounts.merge(candidate.getFieldMemberId(), 1L, Long::sum);
|
||||
visitCounts.merge(candidate.getExternalMemberId(), 1L, Long::sum);
|
||||
});
|
||||
long max = visitCounts.values().stream().mapToLong(Long::longValue).max().orElse(0L);
|
||||
long maxAllowed = maxMemberVisitCount(data);
|
||||
String detail = "max=" + max + ", maxAllowed=" + maxAllowed
|
||||
+ ", ratioPercent=" + pairingProperties.getRule()
|
||||
.getMaxMemberVisitAverageRatioPercent();
|
||||
return new RuleViolationExcelDto("위원 최대 방문 센터 수 상한",
|
||||
max <= maxAllowed ? "PASS" : "FAIL", detail);
|
||||
}
|
||||
|
||||
private String formatDates(Set<LocalDate> dates) {
|
||||
return dates.stream().sorted().map(LocalDate::toString).collect(Collectors.joining(", "));
|
||||
}
|
||||
|
||||
@@ -61,37 +61,44 @@ pairing:
|
||||
# 한 페어가 하루에 방문할 수 있는 최대 센터 수입니다. (HARD)
|
||||
max-centers-per-pair-per-day: 3
|
||||
# 한 위원이 전체 기간 동안 가질 수 있는 최대 상대 파트너 수입니다.(HARD)
|
||||
max-counterparts-per-member: 2
|
||||
max-counterparts-per-member: 3
|
||||
# 위원 1명의 최대 방문 센터 수 상한입니다. 전체 센터가 모두 배정됐을 때 평균 방문 수의 N%를 넘지 못하게 합니다.(HARD)
|
||||
max-member-visit-average-ratio-percent: 130
|
||||
preference:
|
||||
# 선호지역 00(anywhere)을 희망지역 매칭표에서 표현하는 rank 값입니다.(HARD)
|
||||
anywhere-rank: 0
|
||||
# 희망지역 매칭표에서 해당 위원의 선호지역을 고려하지 않는 wildcard rank 값입니다.(HARD)
|
||||
ignored-rank: 99
|
||||
# true면 선호지역 미일치 후보도 99 wildcard 매칭표 규칙을 적극 활용합니다. false로 바꾸면 기존 보수적 점수로 되돌아갑니다.
|
||||
active-wildcard-fallback-enabled: true
|
||||
# wildcard 후보가 후보 축소/배정 선택에서 너무 뒤로 밀리지 않도록 더하는 점수입니다. 값이 클수록 미배정 센터 감소를 우선합니다.
|
||||
wildcard-fallback-score-bonus: 25_000
|
||||
objective:
|
||||
# 센터 1개를 배정했을 때 부여하는 최우선 점수입니다. 다른 soft score 총합보다 충분히 커야 합니다.
|
||||
assignment-weight: 1_000_000
|
||||
# 최종 배정에 위원 1명이 새로 포함될 때 부여하는 점수입니다. 값이 클수록 미사용 위원을 줄이는 방향으로 탐색합니다.
|
||||
used-member-weight: 300_000
|
||||
# 이미 많이 배정된 위원이 추가 배정될 때 차감하는 점수입니다. 값이 클수록 위원별 방문 센터 수를 평균에 가깝게 분산합니다.
|
||||
member-balance-weight: 100_000
|
||||
# 거주지 prefix가 일치하는 페어에 부여하는 점수입니다. 값이 클수록 거주지 유사도를 더 중요하게 봅니다.
|
||||
residence-match-weight: 30_000
|
||||
member-balance-weight: 20_000
|
||||
# 희망지역 매칭 순위 점수의 기준값입니다. 값이 클수록 선호지역 품질 영향이 커집니다.
|
||||
preference-base-weight: 1_000
|
||||
preference-base-weight: 30_000
|
||||
# 매칭 순위가 1 내려갈 때마다 차감하는 점수입니다. 값이 클수록 낮은 순위를 더 강하게 불리하게 봅니다.
|
||||
preference-rank-penalty: 100
|
||||
preference-rank-penalty: 1_000
|
||||
# 거주지 prefix가 일치하는 페어에 부여하는 점수입니다. 값이 클수록 거주지 유사도를 더 중요하게 봅니다.
|
||||
residence-match-weight: 10_000
|
||||
|
||||
candidate:
|
||||
# 위원 1명당 유지할 상대 위원 후보 수입니다. 0이면 제한하지 않습니다.
|
||||
# 모든 위원 조편성이 최우선 HARD 룰이므로 기본값은 제한 없음으로 둡니다.
|
||||
max-pair-candidates-per-member: 0
|
||||
# 현장+외부 페어 1개가 solver에 넘기기 전에 유지할 최대 파견 권역 후보 수입니다.
|
||||
max-dispatch-regions-per-pair: 20
|
||||
max-dispatch-regions-per-pair: 0
|
||||
# 센터 1개마다 solver에 넘기기 전에 유지할 최대 배정 후보 수입니다.
|
||||
max-assignments-per-center: 100
|
||||
max-assignments-per-center: 1_000
|
||||
# 위원 1명(현장/외부 모두 포함)이 solver 후보에 등장할 수 있는 최대 횟수입니다.
|
||||
max-assignments-per-member: 160
|
||||
# 페어-센터 후보 1개에서 생성할 최대 가능 날짜 수입니다. 값이 클수록 전원 조편성 가능성은 커지지만 solver 후보 수가 늘어납니다.
|
||||
max-dates-per-assignment-candidate: 5
|
||||
max-assignments-per-member: 3_000
|
||||
# 페어-센터 후보 1개에서 생성할 최대 가능 날짜 수입니다. 기간 전체에 고르게 분산해 날짜 쏠림을 줄입니다.
|
||||
max-dates-per-assignment-candidate: 80
|
||||
solver:
|
||||
# OR-Tools CP-SAT solver가 한 요청에서 탐색할 최대 시간(초)입니다.
|
||||
max-time-seconds: 120.0
|
||||
max-time-seconds: 360.0
|
||||
# OR-Tools CP-SAT 병렬 탐색 worker 수입니다. 서버 CPU 상황에 맞춰 조정합니다.
|
||||
num-search-workers: 15
|
||||
|
||||
105
src/main/resources/sample/배정_규칙_및_완화_검토.md
Normal file
105
src/main/resources/sample/배정_규칙_및_완화_검토.md
Normal 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을 어느 수준까지 완화할 수 있는지"가 배정률 개선의 핵심입니다.
|
||||
@@ -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 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 java.io.ByteArrayInputStream;
|
||||
import java.io.IOException;
|
||||
@@ -24,28 +21,35 @@ import org.apache.poi.ss.usermodel.Workbook;
|
||||
import org.apache.poi.ss.usermodel.WorkbookFactory;
|
||||
import org.assertj.core.api.Assertions;
|
||||
import org.junit.jupiter.api.Test;
|
||||
import org.springframework.beans.factory.annotation.Autowired;
|
||||
import org.springframework.boot.test.autoconfigure.web.servlet.AutoConfigureMockMvc;
|
||||
import org.springframework.boot.test.context.SpringBootTest;
|
||||
import org.springframework.mock.web.MockMultipartFile;
|
||||
import org.springframework.test.web.servlet.MockMvc;
|
||||
import org.springframework.test.web.servlet.MvcResult;
|
||||
import org.springframework.test.web.servlet.request.MockMvcRequestBuilders;
|
||||
import org.springframework.test.web.servlet.result.MockMvcResultMatchers;
|
||||
|
||||
@SpringBootTest
|
||||
@AutoConfigureMockMvc
|
||||
class PairingServiceTest {
|
||||
|
||||
private final PairingService pairingService = new PairingService(
|
||||
new PairingExcelService(PairingTestSupport.pairingProperties()),
|
||||
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())
|
||||
);
|
||||
@Autowired
|
||||
private MockMvc mockMvc;
|
||||
|
||||
@Test
|
||||
void pairingMemberByCenterCreatesResultWorkbook() throws IOException {
|
||||
try (InputStream inputStream = getClass().getResourceAsStream("/sample/기초 data TEST.xlsx")) {
|
||||
MockMultipartFile file = new MockMultipartFile("file", "기초 data TEST.xlsx",
|
||||
void pairingMemberByCenterCreatesResultWorkbook() throws Exception {
|
||||
Path sample = Path.of("src/main/resources/sample/기초 data TEST.xlsx");
|
||||
|
||||
try (InputStream inputStream = Files.newInputStream(sample)) {
|
||||
MockMultipartFile file = new MockMultipartFile("file", sample.getFileName().toString(),
|
||||
"application/vnd.openxmlformats-officedocument.spreadsheetml.sheet", inputStream);
|
||||
|
||||
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();
|
||||
Files.createDirectories(Path.of("build"));
|
||||
@@ -63,21 +67,9 @@ class PairingServiceTest {
|
||||
List<RuleViolationExcelDto> ruleChecks = ExcelMapper.readFromWorkbook(workbook,
|
||||
RuleViolationExcelDto.class, RESULT_SHEET_RULE_CHECK, 1);
|
||||
Assertions.assertThat(ruleChecks)
|
||||
.filteredOn(ruleCheck -> !"위원 전원 조편성".equals(ruleCheck.getRuleName()))
|
||||
.extracting(RuleViolationExcelDto::getResult)
|
||||
.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();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -49,13 +49,13 @@ class PairingSolverServiceTest {
|
||||
}
|
||||
|
||||
@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")));
|
||||
PairingCandidates candidates = PairingCandidates.builder().pairCandidates(List.of(PairCandidate.builder().fieldMemberId("field").externalMemberId("external1").build(), PairCandidate.builder().fieldMemberId("field").externalMemberId("external2").build(), PairCandidate.builder().fieldMemberId("field").externalMemberId("external3").build())).dispatchRegionCandidates(List.of()).assignmentCandidates(List.of(assignment("field", "external1", "c1", "A", LocalDate.of(2026, 5, 1)), assignment("field", "external2", "c2", "A", LocalDate.of(2026, 5, 2)), assignment("field", "external3", "c3", "A", LocalDate.of(2026, 5, 3)))).build();
|
||||
PairingResult result = service.solve(data, candidates);
|
||||
Map<String, Long> counterpartCounts = (Map)result.getAssignments().stream().collect(Collectors.groupingBy((assignment) -> assignment.getExternalMemberId(), Collectors.counting()));
|
||||
Assertions.assertThat(result.getAssignments()).hasSize(2);
|
||||
Assertions.assertThat(counterpartCounts).hasSize(2);
|
||||
Assertions.assertThat(result.getAssignments()).hasSize(3);
|
||||
Assertions.assertThat(counterpartCounts).hasSize(3);
|
||||
}
|
||||
|
||||
@Test
|
||||
@@ -65,7 +65,7 @@ class PairingSolverServiceTest {
|
||||
PairingSolverService.SolveSelection selection = service.select(candidates,
|
||||
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())
|
||||
.extracting(AssignmentCandidate::getExternalMemberId)
|
||||
.contains("external1");
|
||||
|
||||
@@ -7,6 +7,8 @@ final class PairingTestSupport {
|
||||
}
|
||||
|
||||
static PairingProperties pairingProperties() {
|
||||
return new PairingProperties();
|
||||
PairingProperties properties = new PairingProperties();
|
||||
properties.getSolver().setMaxTimeSeconds(0.5);
|
||||
return properties;
|
||||
}
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user