Compare commits
2 Commits
51a2712066
...
feature-04
| Author | SHA1 | Date | |
|---|---|---|---|
| 993c766d6b | |||
| 9e58f5b361 |
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
|
||||
|
||||
@@ -51,4 +51,26 @@ public class PairingController {
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@PostMapping(value = "/run/new1", consumes = MediaType.MULTIPART_FORM_DATA_VALUE)
|
||||
@Operation(
|
||||
summary = "업로드된 파일로 위원과 센터를 매칭"
|
||||
)
|
||||
public ResponseEntity<byte[]> pairingMemberByCenterNew(
|
||||
@RequestParam("file") MultipartFile file
|
||||
) {
|
||||
String fileName = file.getOriginalFilename() == null ? "pairing" : file.getOriginalFilename();
|
||||
|
||||
try {
|
||||
byte[] bytes = pairingService.pairingMemberByCenterNew(file);
|
||||
return ExcelResponseBuilder.buildExcelResponse(fileName + " 결과.xlsx", bytes);
|
||||
} catch (BusinessException e) {
|
||||
if (e.getStatus() != HttpStatus.BAD_REQUEST) {
|
||||
throw e;
|
||||
} else {
|
||||
byte[] bytes = pairingExcelService.writeValidationError(e.getCode(), e.getMessage());
|
||||
return ExcelResponseBuilder.buildExcelResponse(fileName + " 오류.xlsx", bytes);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,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;
|
||||
}
|
||||
@@ -0,0 +1,36 @@
|
||||
package com.kri.p6.ncrc.pairing.dto.excel.output;
|
||||
|
||||
import com.kri.common.feature.excel.ExcelColumn;
|
||||
import lombok.AllArgsConstructor;
|
||||
import lombok.Data;
|
||||
import lombok.NoArgsConstructor;
|
||||
|
||||
@Data
|
||||
@NoArgsConstructor
|
||||
@AllArgsConstructor
|
||||
public class NewAdjacentRegionExcelDto {
|
||||
|
||||
@ExcelColumn(header = "파견 권역", order = 0, width = 12)
|
||||
private String dispatchRegion;
|
||||
|
||||
@ExcelColumn(header = "인접지역 분류", order = 1, width = 18)
|
||||
private String adjacentRegionClassification;
|
||||
|
||||
@ExcelColumn(header = "여성위원만", order = 2, width = 12)
|
||||
private String womenOnly;
|
||||
|
||||
@ExcelColumn(header = "센터 수", order = 3, width = 10)
|
||||
private String centerCount;
|
||||
|
||||
@ExcelColumn(header = "센터 id 목록", order = 4, width = 40)
|
||||
private String centerIds;
|
||||
|
||||
@ExcelColumn(header = "진행 시작일", order = 5, width = 14)
|
||||
private String availableStartDate;
|
||||
|
||||
@ExcelColumn(header = "진행 종료일", order = 6, width = 14)
|
||||
private String availableEndDate;
|
||||
|
||||
@ExcelColumn(header = "진행 불가 일자", order = 7, width = 45)
|
||||
private String unavailableDates;
|
||||
}
|
||||
@@ -0,0 +1,33 @@
|
||||
package com.kri.p6.ncrc.pairing.dto.excel.output;
|
||||
|
||||
import com.kri.common.feature.excel.ExcelColumn;
|
||||
import lombok.AllArgsConstructor;
|
||||
import lombok.Data;
|
||||
import lombok.NoArgsConstructor;
|
||||
|
||||
@Data
|
||||
@NoArgsConstructor
|
||||
@AllArgsConstructor
|
||||
public class NewCenterExcelDto {
|
||||
|
||||
@ExcelColumn(header = "센터 id", order = 0, width = 16)
|
||||
private String id;
|
||||
|
||||
@ExcelColumn(header = "지자체 id", order = 1, width = 16)
|
||||
private String municipalityId;
|
||||
|
||||
@ExcelColumn(header = "인접지역 분류", order = 2, width = 18)
|
||||
private String adjacentRegionClassification;
|
||||
|
||||
@ExcelColumn(header = "여성위원만", order = 3, width = 12)
|
||||
private String womenOnly;
|
||||
|
||||
@ExcelColumn(header = "센터+지자체 시작일", order = 4, width = 18)
|
||||
private String availableStartDate;
|
||||
|
||||
@ExcelColumn(header = "센터+지자체 종료일", order = 5, width = 18)
|
||||
private String availableEndDate;
|
||||
|
||||
@ExcelColumn(header = "센터+지자체 불가일", order = 6, width = 45)
|
||||
private String unavailableDates;
|
||||
}
|
||||
@@ -0,0 +1,30 @@
|
||||
package com.kri.p6.ncrc.pairing.dto.excel.output;
|
||||
|
||||
import com.kri.common.feature.excel.ExcelColumn;
|
||||
import lombok.AllArgsConstructor;
|
||||
import lombok.Data;
|
||||
import lombok.NoArgsConstructor;
|
||||
|
||||
@Data
|
||||
@NoArgsConstructor
|
||||
@AllArgsConstructor
|
||||
public class NewFinalAssignmentExcelDto {
|
||||
|
||||
@ExcelColumn(header = "일자", order = 0, width = 14)
|
||||
private String date;
|
||||
|
||||
@ExcelColumn(header = "페어번호", order = 1, width = 10)
|
||||
private String pairNo;
|
||||
|
||||
@ExcelColumn(header = "현장위원 id", order = 2, width = 18)
|
||||
private String fieldMemberId;
|
||||
|
||||
@ExcelColumn(header = "외부위원 id", order = 3, width = 18)
|
||||
private String externalMemberId;
|
||||
|
||||
@ExcelColumn(header = "희망지역 매칭표 상의 순위", order = 4, width = 24)
|
||||
private String preferenceMatchPriority;
|
||||
|
||||
@ExcelColumn(header = "인접지역 분류", order = 5, width = 18)
|
||||
private String adjacentRegionClassification;
|
||||
}
|
||||
@@ -0,0 +1,51 @@
|
||||
package com.kri.p6.ncrc.pairing.dto.excel.output;
|
||||
|
||||
import com.kri.common.feature.excel.ExcelColumn;
|
||||
import lombok.AllArgsConstructor;
|
||||
import lombok.Data;
|
||||
import lombok.NoArgsConstructor;
|
||||
|
||||
@Data
|
||||
@NoArgsConstructor
|
||||
@AllArgsConstructor
|
||||
public class NewFinalAssignmentWithCenterExcelDto {
|
||||
|
||||
@ExcelColumn(header = "센터 id", order = 0, width = 18)
|
||||
private String centerId;
|
||||
|
||||
@ExcelColumn(header = "지자체 id", order = 1, width = 18)
|
||||
private String municipalityId;
|
||||
|
||||
@ExcelColumn(header = "인접지역 분류", order = 2, width = 18)
|
||||
private String centerAdjacentRegionClassification;
|
||||
|
||||
@ExcelColumn(header = "여성위원만", order = 3, width = 12)
|
||||
private String womenOnly;
|
||||
|
||||
@ExcelColumn(header = "센터+지자체 시작일", order = 4, width = 18)
|
||||
private String availableStartDate;
|
||||
|
||||
@ExcelColumn(header = "센터+지자체 종료일", order = 5, width = 18)
|
||||
private String availableEndDate;
|
||||
|
||||
@ExcelColumn(header = "센터+지자체 불가일", order = 6, width = 45)
|
||||
private String unavailableDates;
|
||||
|
||||
@ExcelColumn(header = "일자", order = 7, width = 14)
|
||||
private String date;
|
||||
|
||||
@ExcelColumn(header = "페어번호", order = 8, width = 10)
|
||||
private String pairNo;
|
||||
|
||||
@ExcelColumn(header = "현장위원 id", order = 9, width = 18)
|
||||
private String fieldMemberId;
|
||||
|
||||
@ExcelColumn(header = "외부위원 id", order = 10, width = 18)
|
||||
private String externalMemberId;
|
||||
|
||||
@ExcelColumn(header = "희망지역 매칭표 상의 순위", order = 11, width = 24)
|
||||
private String preferenceMatchPriority;
|
||||
|
||||
@ExcelColumn(header = "인접지역 분류", order = 12, width = 18)
|
||||
private String assignedAdjacentRegionClassification;
|
||||
}
|
||||
@@ -0,0 +1,75 @@
|
||||
package com.kri.p6.ncrc.pairing.dto.excel.output;
|
||||
|
||||
import com.kri.common.feature.excel.ExcelColumn;
|
||||
import lombok.AllArgsConstructor;
|
||||
import lombok.Data;
|
||||
import lombok.NoArgsConstructor;
|
||||
|
||||
@Data
|
||||
@NoArgsConstructor
|
||||
@AllArgsConstructor
|
||||
public class NewPairResultExcelDto {
|
||||
|
||||
@ExcelColumn(header = "페어번호", order = 0, width = 10)
|
||||
private String pairNo;
|
||||
|
||||
@ExcelColumn(header = "현장위원 id", order = 1, width = 18)
|
||||
private String fieldMemberId;
|
||||
|
||||
@ExcelColumn(header = "현장위원 경력", order = 2, width = 12)
|
||||
private String fieldExperience;
|
||||
|
||||
@ExcelColumn(header = "현장위원 성별", order = 3, width = 10)
|
||||
private String fieldGender;
|
||||
|
||||
@ExcelColumn(header = "현장위원 활동지역", order = 4, width = 18)
|
||||
private String fieldActivityRegion;
|
||||
|
||||
@ExcelColumn(header = "현장위원 거주지", order = 5, width = 14)
|
||||
private String fieldResidenceCode;
|
||||
|
||||
@ExcelColumn(header = "현장위원 23년 센터", order = 6, width = 35)
|
||||
private String fieldHistoryCenters;
|
||||
|
||||
@ExcelColumn(header = "외부위원 id", order = 7, width = 18)
|
||||
private String externalMemberId;
|
||||
|
||||
@ExcelColumn(header = "외부위원 경력", order = 8, width = 12)
|
||||
private String externalExperience;
|
||||
|
||||
@ExcelColumn(header = "외부위원 성별", order = 9, width = 10)
|
||||
private String externalGender;
|
||||
|
||||
@ExcelColumn(header = "외부위원 활동지역", order = 10, width = 18)
|
||||
private String externalActivityRegion;
|
||||
|
||||
@ExcelColumn(header = "외부위원 거주지", order = 11, width = 14)
|
||||
private String externalResidenceCode;
|
||||
|
||||
@ExcelColumn(header = "외부위원 23년 센터", order = 12, width = 35)
|
||||
private String externalHistoryCenters;
|
||||
|
||||
@ExcelColumn(header = "배정 가능 인접지역 수", order = 13, width = 20)
|
||||
private String availableAdjacentRegionCount;
|
||||
|
||||
@ExcelColumn(header = "중복제거 가능 날짜 수", order = 14, width = 20)
|
||||
private String availableAdjacentRegionDateCount;
|
||||
|
||||
@ExcelColumn(header = "총점", order = 15, width = 16)
|
||||
private String score;
|
||||
|
||||
@ExcelColumn(header = "활동지역 겹침 수", order = 16, width = 16)
|
||||
private String activityOverlapCount;
|
||||
|
||||
@ExcelColumn(header = "가능일자 겹침 수", order = 17, width = 16)
|
||||
private String availableDateOverlapCount;
|
||||
|
||||
@ExcelColumn(header = "선호지역 겹침 수", order = 18, width = 16)
|
||||
private String preferenceOverlapCount;
|
||||
|
||||
@ExcelColumn(header = "23년 센터 점수", order = 19, width = 16)
|
||||
private String historyScore;
|
||||
|
||||
@ExcelColumn(header = "거주지 점수", order = 20, width = 14)
|
||||
private String residenceScore;
|
||||
}
|
||||
@@ -0,0 +1,27 @@
|
||||
package com.kri.p6.ncrc.pairing.dto.excel.output;
|
||||
|
||||
import com.kri.common.feature.excel.ExcelColumn;
|
||||
import lombok.AllArgsConstructor;
|
||||
import lombok.Data;
|
||||
import lombok.NoArgsConstructor;
|
||||
|
||||
@Data
|
||||
@NoArgsConstructor
|
||||
@AllArgsConstructor
|
||||
public class NewPairScoreGuideExcelDto {
|
||||
|
||||
@ExcelColumn(header = "순서", order = 0, width = 8)
|
||||
private String order;
|
||||
|
||||
@ExcelColumn(header = "항목", order = 1, width = 28)
|
||||
private String name;
|
||||
|
||||
@ExcelColumn(header = "계산 방식", order = 2, width = 80)
|
||||
private String formula;
|
||||
|
||||
@ExcelColumn(header = "점수 반영", order = 3, width = 35)
|
||||
private String score;
|
||||
|
||||
@ExcelColumn(header = "설명", order = 4, width = 90)
|
||||
private String description;
|
||||
}
|
||||
@@ -0,0 +1,21 @@
|
||||
package com.kri.p6.ncrc.pairing.model;
|
||||
|
||||
import java.time.LocalDate;
|
||||
import java.util.Set;
|
||||
import lombok.Builder;
|
||||
import lombok.EqualsAndHashCode;
|
||||
import lombok.Getter;
|
||||
|
||||
@Getter
|
||||
@Builder
|
||||
@EqualsAndHashCode(of = {"dispatchRegion", "adjacentRegionClassification"})
|
||||
public class NewAdjacentRegion {
|
||||
private final String adjacentRegionClassification;
|
||||
private final String dispatchRegion;
|
||||
private final boolean womenOnly;
|
||||
private final Set<String> centerIds;
|
||||
private final Set<NewCenter> centers;
|
||||
private final LocalDate availableStartDate;
|
||||
private final LocalDate availableEndDate;
|
||||
private final Set<LocalDate> unavailableDates;
|
||||
}
|
||||
26
src/main/java/com/kri/p6/ncrc/pairing/model/NewCenter.java
Normal file
26
src/main/java/com/kri/p6/ncrc/pairing/model/NewCenter.java
Normal file
@@ -0,0 +1,26 @@
|
||||
package com.kri.p6.ncrc.pairing.model;
|
||||
|
||||
import java.time.LocalDate;
|
||||
import java.util.Set;
|
||||
import lombok.Builder;
|
||||
import lombok.EqualsAndHashCode;
|
||||
import lombok.Getter;
|
||||
|
||||
@Getter
|
||||
@Builder
|
||||
@EqualsAndHashCode(of = "id")
|
||||
public class NewCenter {
|
||||
|
||||
private final String id;
|
||||
private final boolean womenOnly;
|
||||
private final String adjacentRegionClassification;
|
||||
private final LocalDate availableStartDate;
|
||||
private final LocalDate availableEndDate;
|
||||
private final Set<LocalDate> unavailableDates;
|
||||
|
||||
private final String municipalityId;
|
||||
private final LocalDate municipalityAvailableStartDate;
|
||||
private final LocalDate municipalityAvailableEndDate;
|
||||
private final Set<LocalDate> municipalityUnavailableDates;
|
||||
|
||||
}
|
||||
@@ -0,0 +1,27 @@
|
||||
package com.kri.p6.ncrc.pairing.model;
|
||||
|
||||
import com.kri.p6.ncrc.pairing.dto.excel.output.CandidateSummaryExcelDto;
|
||||
import com.kri.p6.ncrc.pairing.dto.excel.output.NewAdjacentRegionExcelDto;
|
||||
import com.kri.p6.ncrc.pairing.dto.excel.output.NewCenterExcelDto;
|
||||
import com.kri.p6.ncrc.pairing.dto.excel.output.NewFinalAssignmentExcelDto;
|
||||
import com.kri.p6.ncrc.pairing.dto.excel.output.NewFinalAssignmentWithCenterExcelDto;
|
||||
import com.kri.p6.ncrc.pairing.dto.excel.output.NewPairScoreGuideExcelDto;
|
||||
import com.kri.p6.ncrc.pairing.dto.excel.output.NewPairResultExcelDto;
|
||||
import com.kri.p6.ncrc.pairing.dto.excel.output.RuleViolationExcelDto;
|
||||
import java.util.List;
|
||||
import lombok.Builder;
|
||||
import lombok.Getter;
|
||||
|
||||
@Getter
|
||||
@Builder
|
||||
public class NewPairingResult {
|
||||
|
||||
private final List<NewPairResultExcelDto> pairs;
|
||||
private final List<NewFinalAssignmentExcelDto> finalAssignments;
|
||||
private final List<NewFinalAssignmentWithCenterExcelDto> finalAssignmentsWithCenters;
|
||||
private final List<NewAdjacentRegionExcelDto> adjacentRegions;
|
||||
private final List<NewCenterExcelDto> centers;
|
||||
private final List<CandidateSummaryExcelDto> summaries;
|
||||
private final List<NewPairScoreGuideExcelDto> scoreGuides;
|
||||
private final List<RuleViolationExcelDto> ruleChecks;
|
||||
}
|
||||
@@ -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,13 +27,21 @@ import com.kri.p6.ncrc.pairing.dto.excel.input.MunicipalityExcelDto;
|
||||
import com.kri.p6.ncrc.pairing.dto.excel.input.PairingWorkbookData;
|
||||
import com.kri.p6.ncrc.pairing.dto.excel.input.PreferenceMatchExcelDto;
|
||||
import com.kri.p6.ncrc.pairing.dto.excel.output.ABPairExcelDto;
|
||||
import com.kri.p6.ncrc.pairing.dto.excel.output.AppliedSettingExcelDto;
|
||||
import com.kri.p6.ncrc.pairing.dto.excel.output.AssignmentResultExcelDto;
|
||||
import com.kri.p6.ncrc.pairing.dto.excel.output.CandidateSummaryExcelDto;
|
||||
import com.kri.p6.ncrc.pairing.dto.excel.output.NewAdjacentRegionExcelDto;
|
||||
import com.kri.p6.ncrc.pairing.dto.excel.output.NewCenterExcelDto;
|
||||
import com.kri.p6.ncrc.pairing.dto.excel.output.NewFinalAssignmentExcelDto;
|
||||
import com.kri.p6.ncrc.pairing.dto.excel.output.NewFinalAssignmentWithCenterExcelDto;
|
||||
import com.kri.p6.ncrc.pairing.dto.excel.output.NewPairResultExcelDto;
|
||||
import com.kri.p6.ncrc.pairing.dto.excel.output.NewPairScoreGuideExcelDto;
|
||||
import com.kri.p6.ncrc.pairing.dto.excel.output.PairingSummaryExcelDto;
|
||||
import com.kri.p6.ncrc.pairing.dto.excel.output.RuleViolationExcelDto;
|
||||
import com.kri.p6.ncrc.pairing.dto.excel.output.UnassignedCenterExcelDto;
|
||||
import com.kri.p6.ncrc.pairing.dto.excel.output.UnusedMemberExcelDto;
|
||||
import com.kri.p6.ncrc.pairing.dto.excel.output.ValidationErrorExcelDto;
|
||||
import com.kri.p6.ncrc.pairing.model.NewPairingResult;
|
||||
import com.kri.p6.ncrc.pairing.model.PairingResult;
|
||||
import java.io.ByteArrayOutputStream;
|
||||
import java.io.IOException;
|
||||
@@ -93,6 +102,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(),
|
||||
@@ -106,6 +117,35 @@ public class PairingExcelService {
|
||||
}
|
||||
}
|
||||
|
||||
public byte[] writeNew(NewPairingResult result) {
|
||||
try (Workbook workbook = ExcelMapper.writeToWorkbook(result.getPairs(),
|
||||
NewPairResultExcelDto.class, "페어결과");
|
||||
ByteArrayOutputStream outputStream = new ByteArrayOutputStream()) {
|
||||
|
||||
ExcelMapper.appendSheetToWorkbook(workbook, result.getFinalAssignments(),
|
||||
NewFinalAssignmentExcelDto.class, "최종 배정", headerRowIndex());
|
||||
ExcelMapper.appendSheetToWorkbook(workbook, result.getFinalAssignmentsWithCenters(),
|
||||
NewFinalAssignmentWithCenterExcelDto.class, "최종 배정 with 센터", headerRowIndex());
|
||||
|
||||
ExcelMapper.appendSheetToWorkbook(workbook, result.getAdjacentRegions(),
|
||||
NewAdjacentRegionExcelDto.class, "인접지역목록", headerRowIndex());
|
||||
ExcelMapper.appendSheetToWorkbook(workbook, result.getCenters(),
|
||||
NewCenterExcelDto.class, "센터목록", headerRowIndex());
|
||||
ExcelMapper.appendSheetToWorkbook(workbook, result.getSummaries(),
|
||||
CandidateSummaryExcelDto.class, "페어후보요약", headerRowIndex());
|
||||
ExcelMapper.appendSheetToWorkbook(workbook, result.getScoreGuides(),
|
||||
NewPairScoreGuideExcelDto.class, "페어점수계산", headerRowIndex());
|
||||
ExcelMapper.appendSheetToWorkbook(workbook, result.getRuleChecks(),
|
||||
RuleViolationExcelDto.class, "규칙검사", headerRowIndex());
|
||||
|
||||
workbook.write(outputStream);
|
||||
return outputStream.toByteArray();
|
||||
} catch (IOException e) {
|
||||
throw BusinessException.badRequest("PAIRING_EXCEL_WRITE_FAILED",
|
||||
"결과 엑셀 파일을 생성하는 중 오류가 발생했습니다: " + e.getMessage());
|
||||
}
|
||||
}
|
||||
|
||||
public byte[] writeValidationError(String code, String message) {
|
||||
PairingResult result = PairingResult.builder()
|
||||
.assignments(List.of())
|
||||
@@ -114,6 +154,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 +176,76 @@ public class PairingExcelService {
|
||||
return pairingProperties.getExcel().getHeaderRowIndex();
|
||||
}
|
||||
|
||||
private List<AppliedSettingExcelDto> appliedSettings() {
|
||||
PairingProperties.Excel excel = pairingProperties.getExcel();
|
||||
PairingProperties.Code code = pairingProperties.getCode();
|
||||
PairingProperties.Rule rule = pairingProperties.getRule();
|
||||
PairingProperties.Preference preference = pairingProperties.getPreference();
|
||||
PairingProperties.Objective objective = pairingProperties.getObjective();
|
||||
PairingProperties.Candidate candidate = pairingProperties.getCandidate();
|
||||
PairingProperties.Solver solver = pairingProperties.getSolver();
|
||||
return List.of(
|
||||
setting("pairing.excel.header-row-index", "엑셀 헤더로 사용하는 행 인덱스",
|
||||
excel.getHeaderRowIndex()),
|
||||
setting("pairing.code.region-code-length", "지역코드 정규화 길이",
|
||||
code.getRegionCodeLength()),
|
||||
setting("pairing.code.residence-code-length", "거주지코드 정규화 길이",
|
||||
code.getResidenceCodeLength()),
|
||||
setting("pairing.code.residence-match-prefix-length", "거주지 일치 판단에 사용하는 앞자리 길이",
|
||||
code.getResidenceMatchPrefixLength()),
|
||||
setting("pairing.code.any-region-code", "희망지역 anywhere로 처리하는 코드",
|
||||
code.getAnyRegionCode()),
|
||||
setting("pairing.rule.max-centers-per-pair-per-day", "같은 페어가 하루에 방문할 수 있는 최대 센터 수",
|
||||
rule.getMaxCentersPerPairPerDay()),
|
||||
setting("pairing.rule.max-counterparts-per-member", "위원 1명당 허용하는 상대 위원 최대 수",
|
||||
rule.getMaxCounterpartsPerMember()),
|
||||
setting("pairing.rule.max-member-visit-average-ratio-percent",
|
||||
"위원별 방문 수 상한을 평균 대비 몇 %까지 허용할지",
|
||||
rule.getMaxMemberVisitAverageRatioPercent()),
|
||||
setting("pairing.preference.anywhere-rank", "희망지역 anywhere를 의미하는 순위",
|
||||
preference.getAnywhereRank()),
|
||||
setting("pairing.preference.ignored-rank", "희망지역 고려하지 않음을 의미하는 순위",
|
||||
preference.getIgnoredRank()),
|
||||
setting("pairing.preference.active-wildcard-fallback-enabled",
|
||||
"희망지역 고려하지 않음을 wildcard로 적극 사용할지",
|
||||
preference.isActiveWildcardFallbackEnabled()),
|
||||
setting("pairing.preference.wildcard-fallback-score-bonus", "wildcard 후보에 추가하는 점수",
|
||||
preference.getWildcardFallbackScoreBonus()),
|
||||
setting("pairing.objective.assignment-weight", "센터 하나를 배정하는 것에 부여하는 기본 점수",
|
||||
objective.getAssignmentWeight()),
|
||||
setting("pairing.objective.preference-base-weight", "희망지역 매칭 1건마다 부여하는 기본 점수",
|
||||
objective.getPreferenceBaseWeight()),
|
||||
setting("pairing.objective.preference-rank-penalty", "희망 순위가 낮아질 때 감점하는 점수",
|
||||
objective.getPreferenceRankPenalty()),
|
||||
setting("pairing.objective.residence-match-weight", "거주지 유사도 점수에 곱하는 가중치",
|
||||
objective.getResidenceMatchWeight()),
|
||||
setting("pairing.objective.member-balance-weight",
|
||||
"방문 수가 많은 위원이 계속 선택되지 않도록 감점하는 가중치",
|
||||
objective.getMemberBalanceWeight()),
|
||||
setting("pairing.candidate.max-pair-candidates-per-member",
|
||||
"위원별 페어 후보 축소 상한, 0이면 무제한",
|
||||
candidate.getMaxPairCandidatesPerMember()),
|
||||
setting("pairing.candidate.max-dispatch-regions-per-pair",
|
||||
"페어별 파견 권역 후보 축소 상한, 0이면 무제한",
|
||||
candidate.getMaxDispatchRegionsPerPair()),
|
||||
setting("pairing.candidate.max-assignments-per-center", "센터별 배정 후보 축소 상한",
|
||||
candidate.getMaxAssignmentsPerCenter()),
|
||||
setting("pairing.candidate.max-assignments-per-member", "위원별 배정 후보 축소 상한",
|
||||
candidate.getMaxAssignmentsPerMember()),
|
||||
setting("pairing.candidate.max-dates-per-assignment-candidate",
|
||||
"하나의 페어-센터 조합에서 확장할 날짜 후보 상한",
|
||||
candidate.getMaxDatesPerAssignmentCandidate()),
|
||||
setting("pairing.solver.max-time-seconds", "CP-SAT 사용 시 허용할 최대 탐색 시간",
|
||||
solver.getMaxTimeSeconds()),
|
||||
setting("pairing.solver.num-search-workers", "CP-SAT 사용 시 사용할 worker 수",
|
||||
solver.getNumSearchWorkers())
|
||||
);
|
||||
}
|
||||
|
||||
private AppliedSettingExcelDto setting(String name, String description, Object value) {
|
||||
return new AppliedSettingExcelDto(name, description, String.valueOf(value));
|
||||
}
|
||||
|
||||
private boolean isBlankRow(Object row) {
|
||||
return Arrays.stream(row.getClass().getDeclaredFields())
|
||||
.allMatch(field -> isBlankField(row, field));
|
||||
|
||||
@@ -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) {
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,989 @@
|
||||
package com.kri.p6.ncrc.pairing.service;
|
||||
|
||||
import com.kri.common.feature.web.BusinessException;
|
||||
import com.kri.p6.ncrc.pairing.config.PairingProperties;
|
||||
import com.kri.p6.ncrc.pairing.common.enums.ExperienceType;
|
||||
import com.kri.p6.ncrc.pairing.common.enums.Gender;
|
||||
import com.kri.p6.ncrc.pairing.common.enums.MemberRole;
|
||||
import com.kri.p6.ncrc.pairing.dto.excel.output.CandidateSummaryExcelDto;
|
||||
import com.kri.p6.ncrc.pairing.dto.excel.output.NewAdjacentRegionExcelDto;
|
||||
import com.kri.p6.ncrc.pairing.dto.excel.output.NewCenterExcelDto;
|
||||
import com.kri.p6.ncrc.pairing.dto.excel.output.NewFinalAssignmentExcelDto;
|
||||
import com.kri.p6.ncrc.pairing.dto.excel.output.NewFinalAssignmentWithCenterExcelDto;
|
||||
import com.kri.p6.ncrc.pairing.dto.excel.output.NewPairScoreGuideExcelDto;
|
||||
import com.kri.p6.ncrc.pairing.dto.excel.output.NewPairResultExcelDto;
|
||||
import com.kri.p6.ncrc.pairing.dto.excel.output.RuleViolationExcelDto;
|
||||
import com.kri.p6.ncrc.pairing.model.Center;
|
||||
import com.kri.p6.ncrc.pairing.model.CenterAdjacentRegion;
|
||||
import com.kri.p6.ncrc.pairing.model.Member;
|
||||
import com.kri.p6.ncrc.pairing.model.Municipality;
|
||||
import com.kri.p6.ncrc.pairing.model.NewAdjacentRegion;
|
||||
import com.kri.p6.ncrc.pairing.model.NewCenter;
|
||||
import com.kri.p6.ncrc.pairing.model.NewPairingResult;
|
||||
import com.kri.p6.ncrc.pairing.model.PairingData;
|
||||
import com.kri.p6.ncrc.pairing.model.PreferenceMatchRule;
|
||||
import java.time.LocalDate;
|
||||
import java.util.ArrayDeque;
|
||||
import java.util.ArrayList;
|
||||
import java.util.Comparator;
|
||||
import java.util.HashMap;
|
||||
import java.util.HashSet;
|
||||
import java.util.LinkedHashMap;
|
||||
import java.util.LinkedHashSet;
|
||||
import java.util.List;
|
||||
import java.util.Map;
|
||||
import java.util.Objects;
|
||||
import java.util.Queue;
|
||||
import java.util.Set;
|
||||
import java.util.function.Function;
|
||||
import java.util.stream.Collectors;
|
||||
import lombok.RequiredArgsConstructor;
|
||||
import org.springframework.stereotype.Service;
|
||||
|
||||
@Service
|
||||
@RequiredArgsConstructor
|
||||
public class PairingNewService {
|
||||
|
||||
private static final long ACTIVITY_WEIGHT = 1_000_000_000_000L;
|
||||
private static final long DATE_WEIGHT = 1_000_000_000L;
|
||||
private static final long PREFERENCE_WEIGHT = 1_000_000L;
|
||||
private static final long HISTORY_WEIGHT = 1_000L;
|
||||
private static final boolean USE_AVAILABLE_ADJACENT_REGION_IN_PAIR_SCORE = false;
|
||||
private static final long AVAILABLE_ADJACENT_REGION_WEIGHT = 1_000_000_000_000_000L;
|
||||
|
||||
private final PairingProperties pairingProperties;
|
||||
|
||||
public NewPairingResult pair(PairingData data) {
|
||||
List<NewCenter> newCenters = createNewCenters(data);
|
||||
List<NewAdjacentRegion> newAdjacentRegions = createNewAdjacentRegions(data, newCenters);
|
||||
List<ScoredPair> selectedPairs = sortSelectedPairsByAvailability(
|
||||
matchMembers(data, newAdjacentRegions), newAdjacentRegions, data);
|
||||
NewAssignmentResult assignmentResult = assignAdjacentRegions(selectedPairs, newAdjacentRegions,
|
||||
data);
|
||||
|
||||
return NewPairingResult.builder()
|
||||
.pairs(toPairRows(selectedPairs))
|
||||
.finalAssignments(assignmentResult.assignments())
|
||||
.finalAssignmentsWithCenters(assignmentResult.assignmentsWithCenters())
|
||||
.adjacentRegions(toAdjacentRows(newAdjacentRegions))
|
||||
.centers(toCenterRows(newCenters))
|
||||
.summaries(createSummaries(data, selectedPairs, newCenters, newAdjacentRegions))
|
||||
.scoreGuides(createScoreGuides())
|
||||
.ruleChecks(createRuleChecks(data, selectedPairs, assignmentResult))
|
||||
.build();
|
||||
}
|
||||
|
||||
private List<NewCenter> createNewCenters(PairingData data) {
|
||||
Map<String, Municipality> municipalityMap = data.getMunicipalities().stream()
|
||||
.collect(Collectors.toMap(Municipality::getId, Function.identity(), (left, right) -> left));
|
||||
|
||||
return data.getCenters().stream()
|
||||
.map(center -> toNewCenter(center, municipalityMap))
|
||||
.sorted(Comparator.comparing(NewCenter::getId))
|
||||
.toList();
|
||||
}
|
||||
|
||||
private NewCenter toNewCenter(Center center, Map<String, Municipality> municipalityMap) {
|
||||
Municipality municipality = municipalityMap.get(center.getMunicipalityId());
|
||||
if (municipality == null) {
|
||||
throw BusinessException.badRequest("PAIRING_BROKEN_MUNICIPALITY_REFERENCE",
|
||||
"센터가 존재하지 않는 지자체를 참조합니다. centerId=" + center.getId()
|
||||
+ ", municipalityId=" + center.getMunicipalityId());
|
||||
}
|
||||
|
||||
Set<LocalDate> unavailableDates = new LinkedHashSet<>();
|
||||
unavailableDates.addAll(center.getUnavailableDates());
|
||||
unavailableDates.addAll(municipality.getUnavailableDates());
|
||||
|
||||
return NewCenter.builder()
|
||||
.id(center.getId())
|
||||
.womenOnly(center.isWomenOnly())
|
||||
.adjacentRegionClassification(center.getAdjacentRegionClassification())
|
||||
.availableStartDate(max(center.getAvailableStartDate(),
|
||||
municipality.getAvailableStartDate()))
|
||||
.availableEndDate(min(center.getAvailableEndDate(), municipality.getAvailableEndDate()))
|
||||
.unavailableDates(unavailableDates)
|
||||
.municipalityId(center.getMunicipalityId())
|
||||
.municipalityAvailableStartDate(municipality.getAvailableStartDate())
|
||||
.municipalityAvailableEndDate(municipality.getAvailableEndDate())
|
||||
.municipalityUnavailableDates(municipality.getUnavailableDates())
|
||||
.build();
|
||||
}
|
||||
|
||||
private List<NewAdjacentRegion> createNewAdjacentRegions(PairingData data,
|
||||
List<NewCenter> newCenters) {
|
||||
Map<String, Set<String>> dispatchRegionsByAdjacentClassification = data.getCenterAdjacentRegions()
|
||||
.stream()
|
||||
.collect(Collectors.groupingBy(CenterAdjacentRegion::getAdjacentRegionClassification,
|
||||
Collectors.mapping(CenterAdjacentRegion::getDispatchRegion,
|
||||
Collectors.toCollection(LinkedHashSet::new))));
|
||||
Map<String, List<NewCenter>> centersByAdjacentClassification = newCenters.stream()
|
||||
.collect(Collectors.groupingBy(NewCenter::getAdjacentRegionClassification,
|
||||
LinkedHashMap::new, Collectors.toList()));
|
||||
|
||||
List<NewAdjacentRegion> result = new ArrayList<>();
|
||||
centersByAdjacentClassification.forEach((adjacentClassification, centers) -> {
|
||||
Set<String> dispatchRegions = dispatchRegionsByAdjacentClassification
|
||||
.getOrDefault(adjacentClassification, Set.of());
|
||||
for (String dispatchRegion : dispatchRegions) {
|
||||
result.add(toNewAdjacentRegion(dispatchRegion, adjacentClassification, centers,
|
||||
data.getCommonUnavailableDates()));
|
||||
}
|
||||
});
|
||||
|
||||
result.sort(Comparator.comparing(NewAdjacentRegion::getDispatchRegion)
|
||||
.thenComparing(NewAdjacentRegion::getAdjacentRegionClassification));
|
||||
return result;
|
||||
}
|
||||
|
||||
private NewAdjacentRegion toNewAdjacentRegion(String dispatchRegion,
|
||||
String adjacentClassification, List<NewCenter> centers, Set<LocalDate> commonUnavailableDates) {
|
||||
LocalDate start = centers.stream().map(NewCenter::getAvailableStartDate).max(LocalDate::compareTo)
|
||||
.orElseThrow();
|
||||
LocalDate end = centers.stream().map(NewCenter::getAvailableEndDate).min(LocalDate::compareTo)
|
||||
.orElseThrow();
|
||||
Set<LocalDate> unavailableDates = centers.stream()
|
||||
.flatMap(center -> center.getUnavailableDates().stream())
|
||||
.collect(Collectors.toCollection(LinkedHashSet::new));
|
||||
unavailableDates.addAll(commonUnavailableDates);
|
||||
Set<NewCenter> centerSet = centers.stream()
|
||||
.collect(Collectors.toCollection(LinkedHashSet::new));
|
||||
Set<String> centerIds = centerSet.stream().map(NewCenter::getId)
|
||||
.collect(Collectors.toCollection(LinkedHashSet::new));
|
||||
|
||||
return NewAdjacentRegion.builder()
|
||||
.dispatchRegion(dispatchRegion)
|
||||
.adjacentRegionClassification(adjacentClassification)
|
||||
.womenOnly(centerSet.stream().anyMatch(NewCenter::isWomenOnly))
|
||||
.centers(centerSet)
|
||||
.centerIds(centerIds)
|
||||
.availableStartDate(start)
|
||||
.availableEndDate(end)
|
||||
.unavailableDates(unavailableDates)
|
||||
.build();
|
||||
}
|
||||
|
||||
private List<ScoredPair> matchMembers(PairingData data,
|
||||
List<NewAdjacentRegion> newAdjacentRegions) {
|
||||
List<Member> fieldMembers = data.getMembers().stream()
|
||||
.filter(member -> member.getRole() == MemberRole.FIELD)
|
||||
.sorted(Comparator.comparing(Member::getId))
|
||||
.toList();
|
||||
List<Member> externalMembers = data.getMembers().stream()
|
||||
.filter(member -> member.getRole() == MemberRole.EXTERNAL)
|
||||
.sorted(Comparator.comparing(Member::getId))
|
||||
.toList();
|
||||
|
||||
if (fieldMembers.size() != externalMembers.size()) {
|
||||
throw BusinessException.badRequest("PAIRING_MEMBER_COUNT_MISMATCH",
|
||||
"현장위원 수와 외부위원 수가 다릅니다. field=" + fieldMembers.size()
|
||||
+ ", external=" + externalMembers.size());
|
||||
}
|
||||
|
||||
List<ScoredPair> candidates = createPairCandidates(fieldMembers, externalMembers,
|
||||
data, newAdjacentRegions);
|
||||
MinCostMatcher matcher = new MinCostMatcher(fieldMembers.size(), externalMembers.size());
|
||||
long maxScore = candidates.stream().mapToLong(ScoredPair::score).max().orElse(0L);
|
||||
for (ScoredPair candidate : candidates) {
|
||||
matcher.addEdge(candidate.fieldIndex(), candidate.externalIndex(), maxScore - candidate.score());
|
||||
}
|
||||
|
||||
Map<Integer, Integer> matches = matcher.match(fieldMembers.size());
|
||||
if (matches.size() != fieldMembers.size()) {
|
||||
throw BusinessException.badRequest("PAIRING_NEW_MEMBER_MATCH_FAILED",
|
||||
"신규+신규 금지 조건을 만족하는 1:1 위원 매칭을 만들 수 없습니다.");
|
||||
}
|
||||
|
||||
Map<String, ScoredPair> candidateMap = candidates.stream()
|
||||
.collect(Collectors.toMap(candidate -> candidate.fieldIndex() + "|" + candidate.externalIndex(),
|
||||
Function.identity(), (left, right) -> left));
|
||||
return matches.entrySet().stream()
|
||||
.map(entry -> candidateMap.get(entry.getKey() + "|" + entry.getValue()))
|
||||
.filter(Objects::nonNull)
|
||||
.sorted(Comparator.comparing(pair -> pair.fieldMember().getId()))
|
||||
.toList();
|
||||
}
|
||||
|
||||
private List<ScoredPair> createPairCandidates(List<Member> fieldMembers,
|
||||
List<Member> externalMembers, PairingData data, List<NewAdjacentRegion> newAdjacentRegions) {
|
||||
List<ScoredPair> candidates = new ArrayList<>();
|
||||
for (int fieldIndex = 0; fieldIndex < fieldMembers.size(); fieldIndex++) {
|
||||
Member fieldMember = fieldMembers.get(fieldIndex);
|
||||
for (int externalIndex = 0; externalIndex < externalMembers.size(); externalIndex++) {
|
||||
Member externalMember = externalMembers.get(externalIndex);
|
||||
if (fieldMember.getExperienceType() == ExperienceType.NEW
|
||||
&& externalMember.getExperienceType() == ExperienceType.NEW) {
|
||||
continue;
|
||||
}
|
||||
candidates.add(scorePair(fieldIndex, externalIndex, fieldMember, externalMember,
|
||||
data, newAdjacentRegions));
|
||||
}
|
||||
}
|
||||
return candidates;
|
||||
}
|
||||
|
||||
private ScoredPair scorePair(int fieldIndex, int externalIndex, Member fieldMember,
|
||||
Member externalMember, PairingData data, List<NewAdjacentRegion> newAdjacentRegions) {
|
||||
int activityOverlap = overlapCount(csvSet(fieldMember.getActivityRegion()),
|
||||
csvSet(externalMember.getActivityRegion()));
|
||||
int dateOverlap = availableDateOverlapCount(fieldMember, externalMember,
|
||||
data.getCommonUnavailableDates());
|
||||
int preferenceOverlap = overlapCount(preferenceSet(fieldMember), preferenceSet(externalMember));
|
||||
int historyScore = historyScore(fieldMember, externalMember);
|
||||
int residenceScore = residenceScore(fieldMember, externalMember);
|
||||
AvailableRegionStats availability = USE_AVAILABLE_ADJACENT_REGION_IN_PAIR_SCORE
|
||||
? availableRegionStats(fieldMember, externalMember, newAdjacentRegions, data)
|
||||
: AvailableRegionStats.empty();
|
||||
long score = activityOverlap * ACTIVITY_WEIGHT
|
||||
+ dateOverlap * DATE_WEIGHT
|
||||
+ preferenceOverlap * PREFERENCE_WEIGHT
|
||||
+ historyScore * HISTORY_WEIGHT
|
||||
+ residenceScore
|
||||
+ availability.regionCount() * AVAILABLE_ADJACENT_REGION_WEIGHT;
|
||||
return new ScoredPair(fieldIndex, externalIndex, fieldMember, externalMember, score,
|
||||
activityOverlap, dateOverlap, preferenceOverlap, historyScore, residenceScore,
|
||||
availability.regionCount(), availability.dateCount());
|
||||
}
|
||||
|
||||
private List<ScoredPair> sortSelectedPairsByAvailability(List<ScoredPair> pairs,
|
||||
List<NewAdjacentRegion> newAdjacentRegions, PairingData data) {
|
||||
return pairs.stream()
|
||||
.map(pair -> pair.withAvailability(availableRegionStats(pair.fieldMember(),
|
||||
pair.externalMember(), newAdjacentRegions, data)))
|
||||
.sorted(Comparator.comparingInt(ScoredPair::availableAdjacentRegionCount)
|
||||
.thenComparingInt(ScoredPair::availableAdjacentRegionDateCount)
|
||||
.thenComparing(Comparator.comparingLong(ScoredPair::score).reversed())
|
||||
.thenComparing(pair -> pair.fieldMember().getId())
|
||||
.thenComparing(pair -> pair.externalMember().getId()))
|
||||
.toList();
|
||||
}
|
||||
|
||||
private AvailableRegionStats availableRegionStats(Member fieldMember, Member externalMember,
|
||||
List<NewAdjacentRegion> newAdjacentRegions, PairingData data) {
|
||||
int regionCount = 0;
|
||||
Set<LocalDate> availableDates = new LinkedHashSet<>();
|
||||
for (NewAdjacentRegion region : newAdjacentRegions) {
|
||||
if (region.isWomenOnly() && (fieldMember.getGender() != Gender.FEMALE
|
||||
|| externalMember.getGender() != Gender.FEMALE)) {
|
||||
continue;
|
||||
}
|
||||
if (hasActivityRegion(fieldMember, region.getDispatchRegion())
|
||||
|| hasActivityRegion(externalMember, region.getDispatchRegion())) {
|
||||
continue;
|
||||
}
|
||||
if (hasHistoryConflict(fieldMember, externalMember, region.getCenterIds())) {
|
||||
continue;
|
||||
}
|
||||
if (!isPreferenceAllowed(fieldMember, externalMember, region.getDispatchRegion(),
|
||||
data.getPreferenceMatchRules())) {
|
||||
continue;
|
||||
}
|
||||
|
||||
Set<LocalDate> dates = availableDatesForRegion(fieldMember, externalMember, region);
|
||||
if (!dates.isEmpty()) {
|
||||
regionCount++;
|
||||
availableDates.addAll(dates);
|
||||
}
|
||||
}
|
||||
return new AvailableRegionStats(regionCount, availableDates.size());
|
||||
}
|
||||
|
||||
private Set<LocalDate> availableDatesForRegion(Member fieldMember, Member externalMember,
|
||||
NewAdjacentRegion region) {
|
||||
LocalDate start = max(max(fieldMember.getAvailableStartDate(),
|
||||
externalMember.getAvailableStartDate()), region.getAvailableStartDate());
|
||||
LocalDate end = min(min(fieldMember.getAvailableEndDate(), externalMember.getAvailableEndDate()),
|
||||
region.getAvailableEndDate());
|
||||
Set<LocalDate> dates = new LinkedHashSet<>();
|
||||
if (start.isAfter(end)) {
|
||||
return dates;
|
||||
}
|
||||
for (LocalDate date = start; !date.isAfter(end); date = date.plusDays(1L)) {
|
||||
if (!fieldMember.getUnavailableDates().contains(date)
|
||||
&& !externalMember.getUnavailableDates().contains(date)
|
||||
&& !region.getUnavailableDates().contains(date)) {
|
||||
dates.add(date);
|
||||
}
|
||||
}
|
||||
return dates;
|
||||
}
|
||||
|
||||
private boolean hasHistoryConflict(Member fieldMember, Member externalMember,
|
||||
Set<String> centerIds) {
|
||||
return centerIds.stream().anyMatch(centerId -> fieldMember.getHistoryCenterIds().contains(centerId)
|
||||
|| externalMember.getHistoryCenterIds().contains(centerId));
|
||||
}
|
||||
|
||||
private boolean isPreferenceAllowed(Member fieldMember, Member externalMember,
|
||||
String dispatchRegion, List<PreferenceMatchRule> rules) {
|
||||
return findPreferenceMatchPriority(fieldMember, externalMember, dispatchRegion, rules) != null;
|
||||
}
|
||||
|
||||
private Integer findPreferenceMatchPriority(Member fieldMember, Member externalMember,
|
||||
String dispatchRegion, List<PreferenceMatchRule> rules) {
|
||||
int fieldRank = findPreferenceRank(fieldMember, dispatchRegion);
|
||||
int externalRank = findPreferenceRank(externalMember, dispatchRegion);
|
||||
return rules.stream()
|
||||
.filter(rule -> matchesPreferenceRank(rule.getFieldMemberPreferenceRank(), fieldRank))
|
||||
.filter(rule -> matchesPreferenceRank(rule.getExternalMemberPreferenceRank(),
|
||||
externalRank))
|
||||
.map(PreferenceMatchRule::getPriority)
|
||||
.min(Integer::compareTo)
|
||||
.orElse(null);
|
||||
}
|
||||
|
||||
private int findPreferenceRank(Member member, String dispatchRegion) {
|
||||
List<String> preferences = member.getPreferenceRegions();
|
||||
for (int i = 0; i < preferences.size(); i++) {
|
||||
String preference = preferences.get(i);
|
||||
if (dispatchRegion.equals(preference)) {
|
||||
return i + 1;
|
||||
}
|
||||
if (anyRegionCode().equals(preference)) {
|
||||
return anywherePreferenceRank();
|
||||
}
|
||||
}
|
||||
return -1;
|
||||
}
|
||||
|
||||
private boolean matchesPreferenceRank(int ruleRank, int memberRank) {
|
||||
return ruleRank == ignoredPreferenceRank() || ruleRank == memberRank;
|
||||
}
|
||||
|
||||
private int availableDateOverlapCount(Member fieldMember, Member externalMember,
|
||||
Set<LocalDate> commonUnavailableDates) {
|
||||
LocalDate start = max(fieldMember.getAvailableStartDate(), externalMember.getAvailableStartDate());
|
||||
LocalDate end = min(fieldMember.getAvailableEndDate(), externalMember.getAvailableEndDate());
|
||||
int count = 0;
|
||||
if (start.isAfter(end)) {
|
||||
return 0;
|
||||
}
|
||||
for (LocalDate date = start; !date.isAfter(end); date = date.plusDays(1L)) {
|
||||
if (!fieldMember.getUnavailableDates().contains(date)
|
||||
&& !externalMember.getUnavailableDates().contains(date)
|
||||
&& !commonUnavailableDates.contains(date)) {
|
||||
count++;
|
||||
}
|
||||
}
|
||||
return count;
|
||||
}
|
||||
|
||||
private int historyScore(Member fieldMember, Member externalMember) {
|
||||
Set<String> fieldHistory = fieldMember.getHistoryCenterIds();
|
||||
Set<String> externalHistory = externalMember.getHistoryCenterIds();
|
||||
if (fieldHistory.isEmpty() && externalHistory.isEmpty()) {
|
||||
return 300;
|
||||
}
|
||||
if (!fieldHistory.isEmpty() && !externalHistory.isEmpty()) {
|
||||
int overlap = overlapCount(fieldHistory, externalHistory);
|
||||
return overlap > 0 ? 200 + overlap : 0;
|
||||
}
|
||||
return 100;
|
||||
}
|
||||
|
||||
private int residenceScore(Member fieldMember, Member externalMember) {
|
||||
String fieldResidence = fieldMember.getResidenceCode();
|
||||
String externalResidence = externalMember.getResidenceCode();
|
||||
if (fieldResidence == null || externalResidence == null
|
||||
|| fieldResidence.isBlank() || externalResidence.isBlank()) {
|
||||
return 0;
|
||||
}
|
||||
if (hasSamePrefix(fieldResidence, externalResidence, 3)) {
|
||||
return 3;
|
||||
}
|
||||
return hasSamePrefix(fieldResidence, externalResidence, 2) ? 2 : 0;
|
||||
}
|
||||
|
||||
private boolean hasSamePrefix(String left, String right, int length) {
|
||||
return left.length() >= length && right.length() >= length
|
||||
&& left.substring(0, length).equals(right.substring(0, length));
|
||||
}
|
||||
|
||||
private List<NewPairResultExcelDto> toPairRows(List<ScoredPair> pairs) {
|
||||
List<NewPairResultExcelDto> rows = new ArrayList<>();
|
||||
for (int i = 0; i < pairs.size(); i++) {
|
||||
ScoredPair pair = pairs.get(i);
|
||||
Member field = pair.fieldMember();
|
||||
Member external = pair.externalMember();
|
||||
rows.add(new NewPairResultExcelDto(String.valueOf(i + 1), field.getId(),
|
||||
formatExperience(field.getExperienceType()), formatGender(field.getGender()),
|
||||
field.getActivityRegion(), field.getResidenceCode(),
|
||||
join(field.getHistoryCenterIds()), external.getId(),
|
||||
formatExperience(external.getExperienceType()), formatGender(external.getGender()),
|
||||
external.getActivityRegion(), external.getResidenceCode(),
|
||||
join(external.getHistoryCenterIds()),
|
||||
String.valueOf(pair.availableAdjacentRegionCount()),
|
||||
String.valueOf(pair.availableAdjacentRegionDateCount()), String.valueOf(pair.score()),
|
||||
String.valueOf(pair.activityOverlapCount()),
|
||||
String.valueOf(pair.availableDateOverlapCount()),
|
||||
String.valueOf(pair.preferenceOverlapCount()), String.valueOf(pair.historyScore()),
|
||||
String.valueOf(pair.residenceScore())));
|
||||
}
|
||||
return rows;
|
||||
}
|
||||
|
||||
private NewAssignmentResult assignAdjacentRegions(List<ScoredPair> pairs,
|
||||
List<NewAdjacentRegion> newAdjacentRegions, PairingData data) {
|
||||
Map<ScoredPair, String> pairNoMap = new LinkedHashMap<>();
|
||||
for (int i = 0; i < pairs.size(); i++) {
|
||||
pairNoMap.put(pairs.get(i), String.valueOf(i + 1));
|
||||
}
|
||||
|
||||
Set<String> assignedAdjacentClassifications = new LinkedHashSet<>();
|
||||
Map<ScoredPair, Set<LocalDate>> usedDatesByPair = new LinkedHashMap<>();
|
||||
pairs.forEach(pair -> usedDatesByPair.put(pair, new LinkedHashSet<>()));
|
||||
|
||||
List<NewFinalAssignmentExcelDto> rows = new ArrayList<>();
|
||||
List<NewFinalAssignmentWithCenterExcelDto> centerRows = new ArrayList<>();
|
||||
List<AssignmentAudit> audits = new ArrayList<>();
|
||||
boolean assignedInPass = true;
|
||||
while (assignedInPass) {
|
||||
assignedInPass = false;
|
||||
for (ScoredPair pair : pairs) {
|
||||
AssignmentChoice choice = findBestAssignmentChoice(pair, newAdjacentRegions, data,
|
||||
assignedAdjacentClassifications, usedDatesByPair.get(pair));
|
||||
if (choice == null) {
|
||||
continue;
|
||||
}
|
||||
|
||||
// 한 페어가 같은 날 두 인접지역을 방문하지 않도록 배정 직후 날짜를 잠급니다.
|
||||
assignedAdjacentClassifications.add(choice.region().getAdjacentRegionClassification());
|
||||
usedDatesByPair.get(pair).add(choice.date());
|
||||
String pairNo = pairNoMap.get(pair);
|
||||
rows.add(new NewFinalAssignmentExcelDto(formatDate(choice.date()), pairNo,
|
||||
pair.fieldMember().getId(), pair.externalMember().getId(),
|
||||
String.valueOf(choice.preferencePriority()),
|
||||
choice.region().getAdjacentRegionClassification()));
|
||||
centerRows.addAll(toAssignmentWithCenterRows(choice, pair, pairNo));
|
||||
audits.add(new AssignmentAudit(pairNo, pair, choice));
|
||||
assignedInPass = true;
|
||||
}
|
||||
}
|
||||
return new NewAssignmentResult(rows, centerRows, audits);
|
||||
}
|
||||
|
||||
private List<NewFinalAssignmentWithCenterExcelDto> toAssignmentWithCenterRows(
|
||||
AssignmentChoice choice, ScoredPair pair, String pairNo) {
|
||||
return choice.region().getCenters().stream()
|
||||
.sorted(Comparator.comparing(NewCenter::getId))
|
||||
.map(center -> new NewFinalAssignmentWithCenterExcelDto(center.getId(),
|
||||
center.getMunicipalityId(), center.getAdjacentRegionClassification(),
|
||||
center.isWomenOnly() ? "1" : "0", formatDate(center.getAvailableStartDate()),
|
||||
formatDate(center.getAvailableEndDate()), joinDates(center.getUnavailableDates()),
|
||||
formatDate(choice.date()), pairNo, pair.fieldMember().getId(),
|
||||
pair.externalMember().getId(), String.valueOf(choice.preferencePriority()),
|
||||
choice.region().getAdjacentRegionClassification()))
|
||||
.toList();
|
||||
}
|
||||
|
||||
private AssignmentChoice findBestAssignmentChoice(ScoredPair pair,
|
||||
List<NewAdjacentRegion> newAdjacentRegions, PairingData data,
|
||||
Set<String> assignedAdjacentClassifications, Set<LocalDate> usedDates) {
|
||||
AssignmentChoice bestChoice = null;
|
||||
for (NewAdjacentRegion region : newAdjacentRegions) {
|
||||
if (assignedAdjacentClassifications.contains(region.getAdjacentRegionClassification())) {
|
||||
continue;
|
||||
}
|
||||
if (region.isWomenOnly() && (pair.fieldMember().getGender() != Gender.FEMALE
|
||||
|| pair.externalMember().getGender() != Gender.FEMALE)) {
|
||||
continue;
|
||||
}
|
||||
if (hasActivityRegion(pair.fieldMember(), region.getDispatchRegion())
|
||||
|| hasActivityRegion(pair.externalMember(), region.getDispatchRegion())) {
|
||||
continue;
|
||||
}
|
||||
if (hasHistoryConflict(pair.fieldMember(), pair.externalMember(), region.getCenterIds())) {
|
||||
continue;
|
||||
}
|
||||
|
||||
Integer preferencePriority = findPreferenceMatchPriority(pair.fieldMember(),
|
||||
pair.externalMember(), region.getDispatchRegion(), data.getPreferenceMatchRules());
|
||||
if (preferencePriority == null) {
|
||||
continue;
|
||||
}
|
||||
|
||||
LocalDate date = firstAvailableDateForRegion(pair.fieldMember(), pair.externalMember(),
|
||||
region, usedDates);
|
||||
if (date == null) {
|
||||
continue;
|
||||
}
|
||||
|
||||
AssignmentChoice choice = new AssignmentChoice(region, date, preferencePriority);
|
||||
if (isBetterAssignmentChoice(choice, bestChoice)) {
|
||||
bestChoice = choice;
|
||||
}
|
||||
}
|
||||
return bestChoice;
|
||||
}
|
||||
|
||||
private boolean isBetterAssignmentChoice(AssignmentChoice current, AssignmentChoice best) {
|
||||
if (best == null) {
|
||||
return true;
|
||||
}
|
||||
return Comparator.comparingInt(AssignmentChoice::preferencePriority)
|
||||
.thenComparing(AssignmentChoice::date)
|
||||
.thenComparing(choice -> choice.region().getAdjacentRegionClassification())
|
||||
.thenComparing(choice -> choice.region().getDispatchRegion())
|
||||
.compare(current, best) < 0;
|
||||
}
|
||||
|
||||
private LocalDate firstAvailableDateForRegion(Member fieldMember, Member externalMember,
|
||||
NewAdjacentRegion region, Set<LocalDate> usedDates) {
|
||||
LocalDate start = max(max(fieldMember.getAvailableStartDate(),
|
||||
externalMember.getAvailableStartDate()), region.getAvailableStartDate());
|
||||
LocalDate end = min(min(fieldMember.getAvailableEndDate(), externalMember.getAvailableEndDate()),
|
||||
region.getAvailableEndDate());
|
||||
if (start.isAfter(end)) {
|
||||
return null;
|
||||
}
|
||||
for (LocalDate date = start; !date.isAfter(end); date = date.plusDays(1L)) {
|
||||
if (!usedDates.contains(date)
|
||||
&& !fieldMember.getUnavailableDates().contains(date)
|
||||
&& !externalMember.getUnavailableDates().contains(date)
|
||||
&& !region.getUnavailableDates().contains(date)) {
|
||||
return date;
|
||||
}
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
private List<NewAdjacentRegionExcelDto> toAdjacentRows(List<NewAdjacentRegion> regions) {
|
||||
return regions.stream()
|
||||
.map(region -> new NewAdjacentRegionExcelDto(region.getDispatchRegion(),
|
||||
region.getAdjacentRegionClassification(), region.isWomenOnly() ? "1" : "0",
|
||||
String.valueOf(region.getCenters().size()), join(region.getCenterIds()),
|
||||
formatDate(region.getAvailableStartDate()), formatDate(region.getAvailableEndDate()),
|
||||
joinDates(region.getUnavailableDates())))
|
||||
.toList();
|
||||
}
|
||||
|
||||
private List<NewCenterExcelDto> toCenterRows(List<NewCenter> centers) {
|
||||
return centers.stream()
|
||||
.map(center -> new NewCenterExcelDto(center.getId(), center.getMunicipalityId(),
|
||||
center.getAdjacentRegionClassification(), center.isWomenOnly() ? "1" : "0",
|
||||
formatDate(center.getAvailableStartDate()), formatDate(center.getAvailableEndDate()),
|
||||
joinDates(center.getUnavailableDates())))
|
||||
.toList();
|
||||
}
|
||||
|
||||
private List<CandidateSummaryExcelDto> createSummaries(PairingData data,
|
||||
List<ScoredPair> selectedPairs, List<NewCenter> newCenters,
|
||||
List<NewAdjacentRegion> newAdjacentRegions) {
|
||||
long fieldCount = data.getMembers().stream()
|
||||
.filter(member -> member.getRole() == MemberRole.FIELD)
|
||||
.count();
|
||||
long externalCount = data.getMembers().stream()
|
||||
.filter(member -> member.getRole() == MemberRole.EXTERNAL)
|
||||
.count();
|
||||
return List.of(
|
||||
new CandidateSummaryExcelDto("현장위원 수", String.valueOf(fieldCount), "입력 현장위원 수"),
|
||||
new CandidateSummaryExcelDto("외부위원 수", String.valueOf(externalCount), "입력 외부위원 수"),
|
||||
new CandidateSummaryExcelDto("생성 페어 수", String.valueOf(selectedPairs.size()),
|
||||
"현장 1명 + 외부 1명으로 확정된 1:1 페어 수"),
|
||||
new CandidateSummaryExcelDto("신규센터 수", String.valueOf(newCenters.size()),
|
||||
"센터와 지자체 일정을 합친 센터 수"),
|
||||
new CandidateSummaryExcelDto("신규인접지역 수", String.valueOf(newAdjacentRegions.size()),
|
||||
"파견 권역 + 인접지역 분류 기준 방문 묶음 수"),
|
||||
new CandidateSummaryExcelDto("공통 불가일 수", String.valueOf(data.getCommonUnavailableDates().size()),
|
||||
"토/일/공휴일 등 공통 제외 일자 수"));
|
||||
}
|
||||
|
||||
private List<RuleViolationExcelDto> createRuleChecks(PairingData data,
|
||||
List<ScoredPair> selectedPairs, NewAssignmentResult assignmentResult) {
|
||||
Set<String> fieldIds = selectedPairs.stream().map(pair -> pair.fieldMember().getId())
|
||||
.collect(Collectors.toCollection(LinkedHashSet::new));
|
||||
Set<String> externalIds = selectedPairs.stream().map(pair -> pair.externalMember().getId())
|
||||
.collect(Collectors.toCollection(LinkedHashSet::new));
|
||||
long inputFieldCount = data.getMembers().stream()
|
||||
.filter(member -> member.getRole() == MemberRole.FIELD)
|
||||
.count();
|
||||
long inputExternalCount = data.getMembers().stream()
|
||||
.filter(member -> member.getRole() == MemberRole.EXTERNAL)
|
||||
.count();
|
||||
boolean hasNewNewPair = selectedPairs.stream()
|
||||
.anyMatch(pair -> pair.fieldMember().getExperienceType() == ExperienceType.NEW
|
||||
&& pair.externalMember().getExperienceType() == ExperienceType.NEW);
|
||||
|
||||
List<RuleViolationExcelDto> checks = new ArrayList<>();
|
||||
checks.add(new RuleViolationExcelDto("현장위원 전체 사용",
|
||||
passFail(fieldIds.size() == inputFieldCount),
|
||||
"입력=" + inputFieldCount + ", 사용=" + fieldIds.size()));
|
||||
checks.add(new RuleViolationExcelDto("외부위원 전체 사용",
|
||||
passFail(externalIds.size() == inputExternalCount),
|
||||
"입력=" + inputExternalCount + ", 사용=" + externalIds.size()));
|
||||
checks.add(new RuleViolationExcelDto("1:1 페어 수",
|
||||
passFail(selectedPairs.size() == inputFieldCount && inputFieldCount == inputExternalCount),
|
||||
"페어=" + selectedPairs.size()));
|
||||
checks.add(new RuleViolationExcelDto("신규+신규 페어 금지",
|
||||
passFail(!hasNewNewPair),
|
||||
hasNewNewPair ? "신규+신규 페어가 존재합니다." : "위반 없음"));
|
||||
checks.addAll(createAssignmentRuleChecks(assignmentResult));
|
||||
return checks;
|
||||
}
|
||||
|
||||
private List<RuleViolationExcelDto> createAssignmentRuleChecks(
|
||||
NewAssignmentResult assignmentResult) {
|
||||
List<AssignmentAudit> audits = assignmentResult.audits();
|
||||
List<RuleViolationExcelDto> checks = new ArrayList<>();
|
||||
|
||||
List<String> duplicatePairDate = duplicateKeys(audits.stream()
|
||||
.map(audit -> audit.pairNo() + "|" + audit.choice().date())
|
||||
.toList());
|
||||
checks.add(new RuleViolationExcelDto("페어별 하루 하나의 인접지역",
|
||||
passFail(duplicatePairDate.isEmpty()),
|
||||
duplicatePairDate.isEmpty() ? "위반 없음" : "중복=" + limitDetail(duplicatePairDate)));
|
||||
|
||||
List<String> duplicateAdjacentClassifications = duplicateKeys(audits.stream()
|
||||
.map(audit -> audit.choice().region().getAdjacentRegionClassification())
|
||||
.toList());
|
||||
checks.add(new RuleViolationExcelDto("인접지역 분류 중복 배정 금지",
|
||||
passFail(duplicateAdjacentClassifications.isEmpty()),
|
||||
duplicateAdjacentClassifications.isEmpty() ? "위반 없음"
|
||||
: "중복=" + limitDetail(duplicateAdjacentClassifications)));
|
||||
|
||||
List<String> unavailableDateViolations = audits.stream()
|
||||
.filter(audit -> !isAssignmentDateAllowed(audit))
|
||||
.map(this::assignmentDetail)
|
||||
.toList();
|
||||
checks.add(new RuleViolationExcelDto("가능 날짜/불가일 준수",
|
||||
passFail(unavailableDateViolations.isEmpty()),
|
||||
unavailableDateViolations.isEmpty() ? "위반 없음"
|
||||
: "위반=" + limitDetail(unavailableDateViolations)));
|
||||
|
||||
List<String> conflictRegionViolations = audits.stream()
|
||||
.filter(audit -> hasActivityRegion(audit.pair().fieldMember(),
|
||||
audit.choice().region().getDispatchRegion())
|
||||
|| hasActivityRegion(audit.pair().externalMember(),
|
||||
audit.choice().region().getDispatchRegion()))
|
||||
.map(this::assignmentDetail)
|
||||
.toList();
|
||||
checks.add(new RuleViolationExcelDto("상피제 준수",
|
||||
passFail(conflictRegionViolations.isEmpty()),
|
||||
conflictRegionViolations.isEmpty() ? "위반 없음"
|
||||
: "위반=" + limitDetail(conflictRegionViolations)));
|
||||
|
||||
List<String> womenOnlyViolations = audits.stream()
|
||||
.filter(audit -> audit.choice().region().isWomenOnly()
|
||||
&& (audit.pair().fieldMember().getGender() != Gender.FEMALE
|
||||
|| audit.pair().externalMember().getGender() != Gender.FEMALE))
|
||||
.map(this::assignmentDetail)
|
||||
.toList();
|
||||
checks.add(new RuleViolationExcelDto("여성위원만 조건 준수",
|
||||
passFail(womenOnlyViolations.isEmpty()),
|
||||
womenOnlyViolations.isEmpty() ? "위반 없음"
|
||||
: "위반=" + limitDetail(womenOnlyViolations)));
|
||||
|
||||
List<String> historyViolations = audits.stream()
|
||||
.filter(audit -> hasHistoryConflict(audit.pair().fieldMember(),
|
||||
audit.pair().externalMember(), audit.choice().region().getCenterIds()))
|
||||
.map(this::assignmentDetail)
|
||||
.toList();
|
||||
checks.add(new RuleViolationExcelDto("2023년 진행 센터 재배정 제외",
|
||||
passFail(historyViolations.isEmpty()),
|
||||
historyViolations.isEmpty() ? "위반 없음" : "위반=" + limitDetail(historyViolations)));
|
||||
|
||||
List<String> preferenceRuleViolations = audits.stream()
|
||||
.filter(audit -> audit.choice().preferencePriority() <= 0)
|
||||
.map(this::assignmentDetail)
|
||||
.toList();
|
||||
checks.add(new RuleViolationExcelDto("희망지역 매칭표 조합 준수",
|
||||
passFail(preferenceRuleViolations.isEmpty()),
|
||||
preferenceRuleViolations.isEmpty() ? "위반 없음"
|
||||
: "위반=" + limitDetail(preferenceRuleViolations)));
|
||||
|
||||
return checks;
|
||||
}
|
||||
|
||||
private boolean isAssignmentDateAllowed(AssignmentAudit audit) {
|
||||
LocalDate date = audit.choice().date();
|
||||
NewAdjacentRegion region = audit.choice().region();
|
||||
Member fieldMember = audit.pair().fieldMember();
|
||||
Member externalMember = audit.pair().externalMember();
|
||||
return !date.isBefore(fieldMember.getAvailableStartDate())
|
||||
&& !date.isAfter(fieldMember.getAvailableEndDate())
|
||||
&& !date.isBefore(externalMember.getAvailableStartDate())
|
||||
&& !date.isAfter(externalMember.getAvailableEndDate())
|
||||
&& !date.isBefore(region.getAvailableStartDate())
|
||||
&& !date.isAfter(region.getAvailableEndDate())
|
||||
&& !fieldMember.getUnavailableDates().contains(date)
|
||||
&& !externalMember.getUnavailableDates().contains(date)
|
||||
&& !region.getUnavailableDates().contains(date);
|
||||
}
|
||||
|
||||
private List<String> duplicateKeys(List<String> keys) {
|
||||
Set<String> seen = new HashSet<>();
|
||||
Set<String> duplicated = new LinkedHashSet<>();
|
||||
for (String key : keys) {
|
||||
if (!seen.add(key)) {
|
||||
duplicated.add(key);
|
||||
}
|
||||
}
|
||||
return new ArrayList<>(duplicated);
|
||||
}
|
||||
|
||||
private String assignmentDetail(AssignmentAudit audit) {
|
||||
return "페어=" + audit.pairNo()
|
||||
+ ", 일자=" + audit.choice().date()
|
||||
+ ", 파견권역=" + audit.choice().region().getDispatchRegion()
|
||||
+ ", 인접지역분류=" + audit.choice().region().getAdjacentRegionClassification();
|
||||
}
|
||||
|
||||
private String limitDetail(List<String> details) {
|
||||
int limit = Math.min(details.size(), 10);
|
||||
String value = details.subList(0, limit).stream().collect(Collectors.joining(" / "));
|
||||
if (details.size() > limit) {
|
||||
value += " / 외 " + (details.size() - limit) + "건";
|
||||
}
|
||||
return value;
|
||||
}
|
||||
|
||||
private String passFail(boolean passed) {
|
||||
return passed ? "PASS" : "FAIL";
|
||||
}
|
||||
|
||||
private List<NewPairScoreGuideExcelDto> createScoreGuides() {
|
||||
return List.of(
|
||||
new NewPairScoreGuideExcelDto("0", "신규+신규 금지",
|
||||
"현장위원과 외부위원이 모두 신규이면 후보에서 제외",
|
||||
"HARD RULE",
|
||||
"이 조건을 만족하지 못하는 조합은 점수 계산 전에 제거됩니다."),
|
||||
new NewPairScoreGuideExcelDto("1", "활동지역 겹침 수",
|
||||
"현장위원 활동지역 코드와 외부위원 활동지역 코드의 교집합 개수",
|
||||
"겹침 수 * 1,000,000,000,000",
|
||||
"현재 1순위 soft rule입니다. 값이 클수록 두 위원이 같은 활동지역 경험을 공유합니다."),
|
||||
new NewPairScoreGuideExcelDto("2", "가능일자 겹침 수",
|
||||
"두 위원의 공통 가능 기간 중 위원별 불가일과 공통 불가일을 제외하고 함께 가능한 날짜 수",
|
||||
"겹침 수 * 1,000,000,000",
|
||||
"같이 움직일 수 있는 날짜가 많은 페어를 우선합니다."),
|
||||
new NewPairScoreGuideExcelDto("3", "선호지역 겹침 수",
|
||||
"두 위원의 선호지역 코드 교집합 개수",
|
||||
"겹침 수 * 1,000,000",
|
||||
"희망지역이 많이 겹치는 페어를 우선합니다."),
|
||||
new NewPairScoreGuideExcelDto("4", "23년 진행 센터 점수",
|
||||
"둘 다 비어 있음=300, 둘 다 있고 겹침 있음=200+겹침 수, 한쪽만 있음=100, 둘 다 있고 겹침 없음=0",
|
||||
"점수 * 1,000",
|
||||
"두 위원의 기방문 센터 제외 풀을 줄여 이후 방문 가능한 센터 묶음을 넓히기 위한 점수입니다."),
|
||||
new NewPairScoreGuideExcelDto("5", "거주지 유사도",
|
||||
"거주지 코드 앞 3자리 동일=3, 앞 2자리 동일=2, 그 외=0",
|
||||
"점수 그대로 더함",
|
||||
"동점에 가까운 후보 사이에서 거주지가 비슷한 페어를 우선합니다."),
|
||||
new NewPairScoreGuideExcelDto("6", "배정 가능 인접지역 수",
|
||||
"선택된 페어가 여성전용, 상피제, 23년 진행 센터, 선호지역, 날짜 조건을 만족하며 방문할 수 있는 인접지역 수",
|
||||
"현재 결과 정렬에만 사용",
|
||||
"배정 가능한 인접지역이 적은 페어가 먼저 센터를 선택할 수 있도록 결과 순서를 앞쪽으로 정렬합니다. 점수 직접 반영은 비활성 상태입니다."),
|
||||
new NewPairScoreGuideExcelDto("7", "총점",
|
||||
"활동지역점수 + 가능일자점수 + 선호지역점수 + 23년센터점수 + 거주지점수",
|
||||
"값이 큰 조합 우선",
|
||||
"전체 현장위원과 외부위원이 정확히 1:1로 매칭되도록 총점 합이 큰 조합을 선택합니다.")
|
||||
);
|
||||
}
|
||||
|
||||
private Set<String> csvSet(String value) {
|
||||
if (value == null || value.isBlank()) {
|
||||
return Set.of();
|
||||
}
|
||||
return java.util.Arrays.stream(value.split(","))
|
||||
.map(String::trim)
|
||||
.filter(token -> !token.isBlank())
|
||||
.collect(Collectors.toCollection(LinkedHashSet::new));
|
||||
}
|
||||
|
||||
private boolean hasActivityRegion(Member member, String dispatchRegion) {
|
||||
return csvSet(member.getActivityRegion()).contains(dispatchRegion);
|
||||
}
|
||||
|
||||
private Set<String> preferenceSet(Member member) {
|
||||
return member.getPreferenceRegions().stream()
|
||||
.filter(value -> value != null && !value.isBlank())
|
||||
.collect(Collectors.toCollection(LinkedHashSet::new));
|
||||
}
|
||||
|
||||
private int overlapCount(Set<String> left, Set<String> right) {
|
||||
Set<String> copied = new HashSet<>(left);
|
||||
copied.retainAll(right);
|
||||
return copied.size();
|
||||
}
|
||||
|
||||
private String formatExperience(ExperienceType experienceType) {
|
||||
return experienceType == ExperienceType.EXPERIENCED ? "경력" : "신규";
|
||||
}
|
||||
|
||||
private String formatGender(Gender gender) {
|
||||
return gender == Gender.FEMALE ? "여성" : "남성";
|
||||
}
|
||||
|
||||
private String formatDate(LocalDate date) {
|
||||
return date == null ? "" : date.toString();
|
||||
}
|
||||
|
||||
private String join(Set<String> values) {
|
||||
return values.stream().sorted().collect(Collectors.joining(","));
|
||||
}
|
||||
|
||||
private String joinDates(Set<LocalDate> dates) {
|
||||
return dates.stream().sorted().map(LocalDate::toString).collect(Collectors.joining(","));
|
||||
}
|
||||
|
||||
private String anyRegionCode() {
|
||||
return pairingProperties.getCode().getAnyRegionCode();
|
||||
}
|
||||
|
||||
private int anywherePreferenceRank() {
|
||||
return pairingProperties.getPreference().getAnywhereRank();
|
||||
}
|
||||
|
||||
private int ignoredPreferenceRank() {
|
||||
return pairingProperties.getPreference().getIgnoredRank();
|
||||
}
|
||||
|
||||
private LocalDate max(LocalDate left, LocalDate right) {
|
||||
return left.isAfter(right) ? left : right;
|
||||
}
|
||||
|
||||
private LocalDate min(LocalDate left, LocalDate right) {
|
||||
return left.isBefore(right) ? left : right;
|
||||
}
|
||||
|
||||
private record ScoredPair(int fieldIndex, int externalIndex, Member fieldMember,
|
||||
Member externalMember, long score, int activityOverlapCount,
|
||||
int availableDateOverlapCount, int preferenceOverlapCount,
|
||||
int historyScore, int residenceScore,
|
||||
int availableAdjacentRegionCount,
|
||||
int availableAdjacentRegionDateCount) {
|
||||
|
||||
private ScoredPair withAvailability(AvailableRegionStats availability) {
|
||||
return new ScoredPair(fieldIndex, externalIndex, fieldMember, externalMember, score,
|
||||
activityOverlapCount, availableDateOverlapCount, preferenceOverlapCount, historyScore,
|
||||
residenceScore, availability.regionCount(), availability.dateCount());
|
||||
}
|
||||
}
|
||||
|
||||
private record AvailableRegionStats(int regionCount, int dateCount) {
|
||||
|
||||
private static AvailableRegionStats empty() {
|
||||
return new AvailableRegionStats(0, 0);
|
||||
}
|
||||
}
|
||||
|
||||
private record AssignmentChoice(NewAdjacentRegion region, LocalDate date,
|
||||
int preferencePriority) {
|
||||
}
|
||||
|
||||
private record AssignmentAudit(String pairNo, ScoredPair pair, AssignmentChoice choice) {
|
||||
}
|
||||
|
||||
private record NewAssignmentResult(List<NewFinalAssignmentExcelDto> assignments,
|
||||
List<NewFinalAssignmentWithCenterExcelDto> assignmentsWithCenters,
|
||||
List<AssignmentAudit> audits) {
|
||||
}
|
||||
|
||||
private static class MinCostMatcher {
|
||||
|
||||
private final int source;
|
||||
private final int sink;
|
||||
private final int leftSize;
|
||||
private final int rightSize;
|
||||
private final List<List<Edge>> graph;
|
||||
|
||||
private MinCostMatcher(int leftSize, int rightSize) {
|
||||
this.leftSize = leftSize;
|
||||
this.rightSize = rightSize;
|
||||
source = leftSize + rightSize;
|
||||
sink = source + 1;
|
||||
graph = new ArrayList<>();
|
||||
for (int i = 0; i <= sink; i++) {
|
||||
graph.add(new ArrayList<>());
|
||||
}
|
||||
for (int i = 0; i < leftSize; i++) {
|
||||
addFlowEdge(source, i, 1, 0L);
|
||||
}
|
||||
for (int i = 0; i < rightSize; i++) {
|
||||
addFlowEdge(leftSize + i, sink, 1, 0L);
|
||||
}
|
||||
}
|
||||
|
||||
private void addEdge(int leftIndex, int rightIndex, long cost) {
|
||||
int rightNode = leftSize + rightIndex;
|
||||
addFlowEdge(leftIndex, rightNode, 1, cost);
|
||||
}
|
||||
|
||||
private Map<Integer, Integer> match(int targetFlow) {
|
||||
int flow = 0;
|
||||
while (flow < targetFlow && augment()) {
|
||||
flow++;
|
||||
}
|
||||
Map<Integer, Integer> matches = new LinkedHashMap<>();
|
||||
int rightOffset = leftSize;
|
||||
for (int left = 0; left < leftSize; left++) {
|
||||
for (Edge edge : graph.get(left)) {
|
||||
if (edge.to >= rightOffset && edge.to < rightOffset + rightSize
|
||||
&& edge.capacity == 0) {
|
||||
matches.put(left, edge.to - rightOffset);
|
||||
}
|
||||
}
|
||||
}
|
||||
return matches;
|
||||
}
|
||||
|
||||
private boolean augment() {
|
||||
long[] distance = new long[graph.size()];
|
||||
Edge[] previousEdge = new Edge[graph.size()];
|
||||
int[] previousNode = new int[graph.size()];
|
||||
java.util.Arrays.fill(distance, Long.MAX_VALUE / 4);
|
||||
boolean[] inQueue = new boolean[graph.size()];
|
||||
Queue<Integer> queue = new ArrayDeque<>();
|
||||
distance[source] = 0L;
|
||||
queue.add(source);
|
||||
inQueue[source] = true;
|
||||
|
||||
while (!queue.isEmpty()) {
|
||||
int node = queue.poll();
|
||||
inQueue[node] = false;
|
||||
for (Edge edge : graph.get(node)) {
|
||||
if (edge.capacity <= 0 || distance[edge.to] <= distance[node] + edge.cost) {
|
||||
continue;
|
||||
}
|
||||
distance[edge.to] = distance[node] + edge.cost;
|
||||
previousNode[edge.to] = node;
|
||||
previousEdge[edge.to] = edge;
|
||||
if (!inQueue[edge.to]) {
|
||||
queue.add(edge.to);
|
||||
inQueue[edge.to] = true;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (previousEdge[sink] == null) {
|
||||
return false;
|
||||
}
|
||||
for (int node = sink; node != source; node = previousNode[node]) {
|
||||
Edge edge = previousEdge[node];
|
||||
edge.capacity--;
|
||||
graph.get(edge.to).get(edge.reverseIndex).capacity++;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
private void addFlowEdge(int from, int to, int capacity, long cost) {
|
||||
Edge forward = new Edge(to, graph.get(to).size(), capacity, cost);
|
||||
Edge reverse = new Edge(from, graph.get(from).size(), 0, -cost);
|
||||
graph.get(from).add(forward);
|
||||
graph.get(to).add(reverse);
|
||||
}
|
||||
}
|
||||
|
||||
private static class Edge {
|
||||
|
||||
private final int to;
|
||||
private final int reverseIndex;
|
||||
private int capacity;
|
||||
private final long cost;
|
||||
|
||||
private Edge(int to, int reverseIndex, int capacity, long cost) {
|
||||
this.to = to;
|
||||
this.reverseIndex = reverseIndex;
|
||||
this.capacity = capacity;
|
||||
this.cost = cost;
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -52,6 +52,8 @@ public class PairingNormalizeService {
|
||||
.toList()).commonUnavailableDates(Set.of()).build();
|
||||
}
|
||||
|
||||
|
||||
|
||||
private Member toMember(MemberExcelDto row) {
|
||||
return Member.builder().id(required(row.getId(), "위원 id"))
|
||||
.gender(parseGender(row.getGender()))
|
||||
@@ -61,7 +63,7 @@ public class PairingNormalizeService {
|
||||
.availableEndDate(parseDate(row.getAvailableEndDate(), "위원 진행 종료일"))
|
||||
.unavailableDates(parseDateSet(row.getUnavailableDates(), "위원 진행 불가 일자"))
|
||||
.activityRegion(normalizeCsvCodes(row.getActivityRegion(), regionCodeLength(), "위원 활동지역"))
|
||||
.historyCenterIds(parseCsv(row.getHistoryCenters())).residenceCode(
|
||||
.historyCenterIds(parseHistoryCenterIds(row.getHistoryCenters())).residenceCode(
|
||||
normalizeOptionalCode(row.getResidenceCode(), residenceCodeLength(), "위원 거주지"))
|
||||
.preferenceRegions(normalizePreferenceRegions(row)).build();
|
||||
}
|
||||
@@ -208,6 +210,20 @@ public class PairingNormalizeService {
|
||||
.collect(Collectors.toCollection(LinkedHashSet::new)));
|
||||
}
|
||||
|
||||
private Set<String> parseHistoryCenterIds(String value) {
|
||||
return parseCsv(value).stream()
|
||||
.map(this::normalizeExcelIdText)
|
||||
.collect(Collectors.toCollection(LinkedHashSet::new));
|
||||
}
|
||||
|
||||
private String normalizeExcelIdText(String value) {
|
||||
String cleaned = clean(value);
|
||||
if (cleaned.matches("\\d+\\.0+")) {
|
||||
return cleaned.substring(0, cleaned.indexOf('.'));
|
||||
}
|
||||
return cleaned;
|
||||
}
|
||||
|
||||
private int parseInt(String value, String fieldName) {
|
||||
String cleaned = required(value, fieldName);
|
||||
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
@@ -1,6 +1,7 @@
|
||||
package com.kri.p6.ncrc.pairing.service;
|
||||
|
||||
import com.kri.p6.ncrc.pairing.dto.excel.input.PairingWorkbookData;
|
||||
import com.kri.p6.ncrc.pairing.model.NewPairingResult;
|
||||
import com.kri.p6.ncrc.pairing.model.PairingData;
|
||||
import com.kri.p6.ncrc.pairing.model.PairingResult;
|
||||
import lombok.RequiredArgsConstructor;
|
||||
@@ -16,6 +17,7 @@ public class PairingService {
|
||||
private final PairingHolidayService pairingHolidayService;
|
||||
private final PairingValidationService pairingValidationService;
|
||||
private final PairingScheduleService pairingScheduleService;
|
||||
private final PairingNewService pairingNewService;
|
||||
|
||||
public byte[] pairingMemberByCenter(MultipartFile file) {
|
||||
PairingWorkbookData workbookData = pairingExcelService.read(file);
|
||||
@@ -25,4 +27,13 @@ public class PairingService {
|
||||
PairingResult result = pairingScheduleService.schedule(pairingData);
|
||||
return pairingExcelService.write(result);
|
||||
}
|
||||
|
||||
public byte[] pairingMemberByCenterNew(MultipartFile file) {
|
||||
PairingWorkbookData workbookData = pairingExcelService.read(file);
|
||||
PairingData pairingData = pairingNormalizeService.normalize(workbookData);
|
||||
pairingData = pairingHolidayService.applyHolidayUnavailableDates(pairingData);
|
||||
pairingValidationService.validate(pairingData);
|
||||
NewPairingResult result = pairingNewService.pair(pairingData);
|
||||
return pairingExcelService.writeNew(result);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -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