18 Commits

Author SHA1 Message Date
6497a12a46 260422_01_ENH: 복수 권역을 가지는 인접지역 상피제 버그 수정 2026-04-22 17:47:34 +09:00
23172d2aa1 260421_13_ENH: swagger 전체 ip 허용 제거 2026-04-21 12:10:50 +09:00
96e3ff2757 260421_12_ENH: 바뀐 공용 라이브러리로 적용 테스트를 위한 swagger 허용 ip에 전체 ip 추가 2026-04-21 12:05:26 +09:00
67204d894e 260421_11_ENH: 바뀐 공용 라이브러리로 적용 및 cidrs 설정 제거 2026-04-21 12:03:01 +09:00
1148c7ce2b 260421_10_ENH: cidrs에서 전체 제거 2026-04-21 11:40:48 +09:00
7156124e59 260421_09_ENH: cidrs에 재우, 전체 허용 추가 2026-04-21 11:37:54 +09:00
6290d1c62d 260421_08_ENH: 석오 재우만 허용 2026-04-21 11:15:02 +09:00
45b5e1702a 260421_07_ENH: Swagger 전체 IP허용 2026-04-21 11:05:48 +09:00
a4ff24eac5 260421_06_ENH: Swagger 석오만 허용 2026-04-21 10:46:49 +09:00
d2cdfd5f0d 260421_05_ENH: Swagger 모든 IP 허용 2026-04-21 10:34:59 +09:00
d5160a50f0 260421_04_DOC: 사용된 샘플 데이터 추가 2026-04-21 10:07:48 +09:00
6a31fedc64 260421_03_ENH: README.md 파일 갱신 및 필요없어진 md 파일 제거 2026-04-21 10:07:12 +09:00
af92f18574 260421_03_ENH: 인접지역에 복수개의 권역 허용 2026-04-21 10:06:39 +09:00
4c11636588 260421_02_ENH: swagger 허용 ip추가 2026-04-21 09:32:37 +09:00
9d9736451f 260421_01_ENH: 결과 파일명 및 시트명 조정 페어링시 배정가능 인접지역 고려 적용 2026-04-21 09:21:03 +09:00
27a5fceb0a 260420_03_ENH: 기존 내용 제거 2026-04-20 19:12:08 +09:00
993c766d6b 260420_02_ENH: 로직 단순화 구현 완료 2026-04-20 18:54:50 +09:00
9e58f5b361 260420_01_ENH: split 마감 2026-04-20 16:58:35 +09:00
49 changed files with 1823 additions and 2994 deletions

548
README.md
View File

@@ -1,159 +1,262 @@
# ncrc-pairing # ncrc-pairing
엑셀 파일을 입력받아 위원 페어 후보와 센터 배정 후보를 만들고, Google OR-Tools CP-SAT으로 배정 결과를 계산하는 Spring Boot API입니다. 엑셀 파일을 입력받아 위원 1:1 페어를 만들고, 인접지역분류 단위의 방문 배정표를 생성하는 Spring Boot API입니다.
## 실행 흐름 ## 개요
처리는 크게 2단계입니다.
1. 현장위원 100명과 외부위원 100명을 1:1 페어로 매칭
2. 생성된 페어를 사용해 인접지역분류 단위로 최종 배정
배정 결과는 엑셀로 반환합니다.
## 실행 환경
- Java 17
- Spring Boot 3.5.x
- Gradle
기본 포트:
```yaml
server:
port: 6111
```
## API
엔드포인트:
```text
POST /api/v1/pairing/run/new
Content-Type: multipart/form-data
file=<xlsx 파일>
```
정상 처리 시 결과 엑셀을 반환합니다.
검증 실패 시에도 공통 `BusinessException` 내용을 담은 오류 엑셀을 반환합니다.
## 전체 처리 흐름
현재 실제 구동 순서는 아래와 같습니다.
1. `PairingController` 1. `PairingController`
- `/api/v1/pairing/run`으로 엑셀 파일을 업로드받습니다. 2. `PairingService#pairingMemberByCenterNew`
- 처리 결과를 엑셀 파일로 반환합니다. 3. `PairingExcelService#read`
4. `PairingNormalizeService#normalize`
5. `PairingHolidayService#applyHolidayUnavailableDates`
6. `PairingValidationService#validate`
7. `PairingNewService#pair`
8. `PairingExcelService#writeNew`
2. `PairingService` ## 입력 엑셀 시트
- 전체 유스케이스 흐름을 순서대로 호출합니다.
- `엑셀 읽기 -> 정규화 -> 공휴일 반영 -> 검증 -> 후보 생성 -> solver 실행 -> 결과 엑셀 생성`
3. `PairingExcelService` 현재 필수 시트는 5개입니다.
- 입력 엑셀의 6개 시트를 `dto.excel` DTO로 읽습니다.
- 결과 엑셀은 `배정결과`, `미배정센터`, `미사용위원`, `처리요약`, `AB페어목록`, `후보요약`, `검증오류`, `규칙위반검사` 시트로 씁니다.
- `/run`에서 입력/검증 오류가 발생하면 오류 내용을 담은 엑셀 파일을 반환합니다.
4. `PairingNormalizeService` 1. `위원정보`
- 엑셀 문자열을 내부 모델로 변환합니다. 2. `지자체 정보`
- 날짜, CSV, 성별, 경력여부, 현장/외부 구분, 지역코드, 선호지역을 정리합니다. 3. `센터정보`
4. `센터 인접지역표`
5. `희망지역 매칭표`
5. `PairingValidationService` 더 이상 사용하지 않는 시트:
- 필수 데이터, 날짜 범위, 지자체 참조, 희망지역 매칭표 등을 검증합니다.
- 실패 시 `BusinessException.badRequest(code, message)`를 사용합니다.
6. `PairingHolidayService` - `위원 지역코드표`
- `DatagoExtentionApiClient.getHoliDayList(year)`로 국공휴일을 조회합니다.
- 조회된 날짜는 모든 위원/지자체/센터에 공통 적용되는 진행 불가일자로 처리합니다.
- 공휴일 목록은 `DatagoHolidayCache`에서 공용 `AbstractListCache` 기반으로 캐싱합니다.
7. `PairingCandidateService` 현재 코드에서는 읽지 않습니다.
- solver가 선택할 수 있는 후보만 생성합니다.
- 불가능한 조합은 이 단계에서 제거합니다.
8. `PairingSolverService` ## 핵심 모델
- OR-Tools CP-SAT 모델을 만들고 최적 배정을 계산합니다.
## OR-Tools 사용 개요 ### Member
현재 사용하는 라이브러리는 `com.google.ortools:ortools-java`입니다. 위원 기본 정보입니다.
OR-Tools CP-SAT은 "조건을 만족하는 조합 중 점수가 가장 좋은 조합"을 찾는 최적화 solver입니다. 이 프로젝트에서는 각 배정 후보를 boolean 변수로 만듭니다. - 성별
- 경력
- 역할(현장 / 외부)
- 가능 시작일 / 종료일
- 불가일
- 활동지역
- 2023년 진행 센터 이력
- 거주지
- 선호지역 1~4
예를 들어 어떤 후보가 다음 의미를 가진다고 하면: ### NewCenter
```text 센터와 지자체 정보를 합쳐 만든 센터 단위 모델입니다.
2026-05-01에 fieldMember=100, externalMember=200 페어가 center=300을 방문한다
- `availableStartDate`: 센터 시작일과 지자체 시작일 중 더 늦은 값
- `availableEndDate`: 센터 종료일과 지자체 종료일 중 더 이른 값
- `unavailableDates`: 센터 불가일 + 지자체 불가일
### NewAdjacentRegion
실제 배정의 기본 단위입니다.
- 기준: `dispatchRegion + adjacentRegionClassification`
- 포함 센터: 같은 `adjacentRegionClassification`을 가진 센터 묶음
- `womenOnly`: 포함 센터 중 하나라도 여성전용이면 `true`
- `availableStartDate`: 포함 센터들의 시작일 중 가장 늦은 값
- `availableEndDate`: 포함 센터들의 종료일 중 가장 이른 값
- `unavailableDates`: 포함 센터들의 불가일 합집합 + 공통 제외일(토/일/공휴일)
주의:
- `센터 인접지역표`의 `dispatchRegion` 셀에는 `12,15,16`처럼 여러 코드가 들어올 수 있습니다.
- 현재는 정규화 단계에서 이 값을 행확장합니다.
- 예: `dispatchRegion=12,15,16`, `adjacentRegionClassification=A001`
- `(12, A001)`
- `(15, A001)`
- `(16, A001)`
## 페어 생성 규칙
페어 생성은 `PairingNewService`에서 처리합니다.
### 하드룰
1. 현장위원 수와 외부위원 수는 같아야 함
2. 모든 현장위원과 모든 외부위원이 정확히 1:1로 사용되어야 함
3. `신규 + 신규` 페어는 금지
### 페어 점수 기준
현재 페어 점수는 아래 항목으로 계산합니다.
1. 활동지역 겹침 수
2. 공통 가능일 수
3. 선호지역 겹침 수
4. 2023년 진행 센터 이력 점수
5. 거주지 유사도
6. 배정 가능한 인접지역 수
현재 코드 기준:
```java
private static final boolean USE_AVAILABLE_ADJACENT_REGION_IN_PAIR_SCORE = true;
``` ```
solver 안에서는 이 후보가 하나의 `BoolVar`가 됩니다. 즉, `배정 가능한 인접지역 수가 많은 페어`가 페어 생성 단계의 점수에도 반영됩니다.
```text 추가로 생성된 페어는 아래 기준으로 다시 정렬됩니다.
1 = 이 후보를 선택한다
0 = 이 후보를 선택하지 않는다
```
`PairingSolverService`는 이런 boolean 변수들을 놓고 아래를 수행합니다. 1. 배정 가능 인접지역 수 오름차순
2. 중복제거 가능 날짜 수 오름차순
3. 페어 점수 내림차순
4. 현장위원 id
5. 외부위원 id
- hard rule: 반드시 지켜야 하는 제약 이 정렬 순서는 이후 최종 배정 순서에도 영향을 줍니다.
- soft rule: 지키면 점수가 좋아지는 목표
## 현재 적용된 Hard Rule ## 최종 배정 규칙
후보 생성 단계와 solver 단계에 나뉘어 적용되어 있습니다. 최종 배정은 `PairingNewService#assignAdjacentRegions`에서 처리합니다.
### 후보 생성 단계 기본 개념은 단순 그리디입니다.
위치: `PairingCandidateService` 1. 정렬된 페어를 앞에서부터 순회
2. 각 페어가 갈 수 있는 인접지역분류 후보를 찾음
3. `희망지역 매칭표` 순위가 가장 높은 후보부터 선택
4. 배정 직후 그 페어의 해당 날짜를 사용 처리
5. 이미 배정된 인접지역분류는 다시 배정하지 않음
6. 더 이상 배정할 수 없을 때까지 반복
- 현장위원 + 외부위원 페어만 생성 ### 최종 배정 하드룰
- 신규 + 신규 페어 제외
- 두 위원의 일정 범위가 겹치지 않으면 제외
- 파견 권역이 위원의 활동지역과 같으면 제외
- 희망지역 매칭표에 없는 선호 조합 제외
- 센터 인접지역표를 통해 파견 권역과 센터 연결
- 여성 전용 센터는 여성 2명 페어만 허용
- 2023년 진행 센터는 해당 위원에게 재배정 금지
- 위원/지자체/센터의 시작일, 종료일, 불가일자를 모두 반영
- 국공휴일은 모든 배정 후보에서 제외
현재 후보 수 폭증을 막기 위해 각 페어/센터 조합에서 가장 빠른 feasible 일자 1개만 후보로 만듭니다. 현재 코드에서 적용되는 하드룰은 아래와 같습니다.
### Solver 단계 1. 같은 페어는 같은 날짜에 하나의 인접지역분류만 방문 가능
2. 같은 인접지역분류는 한 번만 배정 가능
3. 위원 가능일 / 지자체 가능일 / 센터 가능일 범위를 만족해야 함
4. 위원 불가일 / 센터 불가일 / 지자체 불가일 / 토요일 / 일요일 / 공휴일은 제외
5. 상피제 적용
- 현장위원 또는 외부위원의 활동지역에 해당 `dispatchRegion`이 있으면 배정 불가
6. 여성전용 인접지역은 여성 + 여성 페어만 가능
7. 2023년 진행 센터 이력이 포함된 인접지역은 배정 불가
8. 희망지역 매칭표 조합에 맞는 경우만 후보 인정
위치: `PairingSolverService` ## 규칙검사 시트
- 한 센터는 최대 1번만 배정 결과 엑셀의 `규칙검사` 시트에는 현재 아래 항목을 검사합니다.
- 한 페어는 하루 최대 3개 센터만 방문
- 한 위원은 같은 날짜에 하나의 페어로만 활동
- 한 페어는 같은 날짜에 하나의 인접지역 분류만 방문
- 한 위원은 전체 기간 동안 최대 2명의 상대 파트너만 가짐
## 현재 적용된 Soft Rule 1. 현장위원 전체 사용
2. 외부위원 전체 사용
3. 1:1 페어 수
4. 신규+신규 페어 금지
5. 페어별 하루 하나의 인접지역
6. 인접지역 분류 중복 배정 금지
7. 가능 날짜/불가일 준수
8. 상피제 준수
9. 여성위원만 조건 준수
10. 2023년 진행 센터 재배정 제외
11. 희망지역 매칭표 조합 준수
위치: `PairingSolverService#createObjective` 위반 시 `FAIL`과 상세 내역을 기록합니다.
현재 목적함수는 아래 순서가 강하게 반영되도록 가중치를 둡니다.
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 보완 페어 정보 1. `페어결과`
- `미배정센터`: 최종 배정되지 않은 센터와 누적 미배정 사유 2. `최종 배정`
- `미사용위원`: 최종 배정에 포함되지 않은 위원 3. `최종 배정 with 센터`
- `처리요약`: 전체 입력/후보/배정/AB 그룹 요약 4. `인접지역목록`
- `AB페어목록`: 후처리로 묶인 AB 페어 그룹 목록 5. `센터목록`
- `후보요약`: 후보 생성 및 solver 입력 규모 6. `페어후보요약`
- `검증오류`: 정상 처리 시 빈 시트, 입력/검증 오류 엑셀에서는 오류 내용 7. `페어점수계산`
- `규칙위반검사`: 결과가 hard rule을 위반하지 않았는지 PASS/FAIL 검사 8. `규칙검사`
`/run`에서 엑셀 파싱이나 입력 검증 오류가 발생하면 HTTP 200으로 오류 엑셀을 반환합니다. 공휴일 API 실패 같은 시스템 오류는 숨기지 않고 실패 응답으로 처리합니다. ### 1. 페어결과
## 업무 조건 변경 시 수정 위치 생성된 1:1 페어 목록입니다.
### 자주 조정될 수 있는 값 포함 정보:
아래 값들은 `application.yaml`의 `pairing.*` 설정으로 관리합니다. - 페어번호
- 현장위원 / 외부위원 id
- 성별 / 경력 / 활동지역 / 거주지
- 2023년 진행 센터
- 배정 가능 인접지역 수
- 중복제거 가능 날짜 수
- 총점 및 각 점수 항목
### 2. 최종 배정
인접지역분류 단위 배정 결과입니다.
포함 정보:
- 일자
- 페어번호
- 현장위원 id
- 외부위원 id
- 희망지역 매칭표 상의 순위
- 인접지역 분류
### 3. 최종 배정 with 센터
최종 배정을 센터 단위로 펼친 시트입니다.
포함 정보:
- 센터 id
- 지자체 id
- 인접지역 분류
- 여성위원만
- 센터+지자체 시작일
- 센터+지자체 종료일
- 센터+지자체 불가일
- 일자
- 페어번호
- 현장위원 id
- 외부위원 id
- 희망지역 매칭표 상의 순위
- 인접지역 분류
## 설정값
현재 사용 중인 설정은 아래뿐입니다.
```yaml ```yaml
pairing: pairing:
@@ -162,175 +265,110 @@ pairing:
code: code:
region-code-length: 2 region-code-length: 2
residence-code-length: 5 residence-code-length: 5
residence-match-prefix-length: 3
any-region-code: "00" any-region-code: "00"
rule:
max-centers-per-pair-per-day: 3
max-counterparts-per-member: 2
preference: preference:
anywhere-rank: 0 anywhere-rank: 0
ignored-rank: 99 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의 최대 합보다 충분히 커야 합니다. 설명:
### 엑셀 시트명 또는 컬럼명이 바뀌는 경우 - `header-row-index`
- 엑셀 헤더 행 번호
- `region-code-length`
- 활동지역 / 선호지역 / 파견권역 코드 정규화 길이
- `residence-code-length`
- 거주지 코드 정규화 길이
- `any-region-code`
- 선호지역의 `어디든 가능` 코드
- `anywhere-rank`
- `00`이 희망지역 매칭표에서 의미하는 순위
- `ignored-rank`
- 선호지역을 고려하지 않음을 의미하는 wildcard 순위
수정 위치: ## 공휴일 / 주말 처리
- `PairingConstant` `PairingHolidayService`에서 공통 제외일을 만듭니다.
- `dto.excel.*`
- `PairingExcelService`
시트명이 바뀌면 `PairingConstant`의 `SHEET_*` 값을 수정합니다. 컬럼명이 바뀌면 해당 `dto.excel` 클래스의 `@ExcelColumn(header = "...")` 값을 수정합니다. 데이터 소스:
### 결과 엑셀 시트를 바꾸는 경우 - `DatagoHolidayCache`
- `DatagoExtentionApiClient`
수정 위치: 포함 범위:
- `PairingConstant` - 공휴일
- `dto.*ExcelDto` - 토요일
- `PairingExcelService#write` - 일요일
- `PairingSolverService#toResult`
### 지역 코드 자리수가 바뀌는 경우 이 값들은 `PairingData.commonUnavailableDates`로 들어가고, 이후 `NewAdjacentRegion.unavailableDates`에 합쳐집니다.
수정 위치: ## 주요 클래스
- `PairingConstant` ### Controller
- `PairingNormalizeService`
- `PairingCandidateService`
현재 활동지역/선호지역은 2자리, 거주지는 5자리, 거주지 비교는 앞 3자리 기준입니다. - [PairingController.java](D:/___Project/260414_아동권리보장원/DEV/ncrc-pairing/src/main/java/com/kri/p6/ncrc/pairing/controller/PairingController.java)
### 선호지역 `00` 규칙이 바뀌는 경우 ### Service
수정 위치: - [PairingService.java](D:/___Project/260414_아동권리보장원/DEV/ncrc-pairing/src/main/java/com/kri/p6/ncrc/pairing/service/PairingService.java)
- [PairingExcelService.java](D:/___Project/260414_아동권리보장원/DEV/ncrc-pairing/src/main/java/com/kri/p6/ncrc/pairing/service/PairingExcelService.java)
- [PairingNormalizeService.java](D:/___Project/260414_아동권리보장원/DEV/ncrc-pairing/src/main/java/com/kri/p6/ncrc/pairing/service/PairingNormalizeService.java)
- [PairingHolidayService.java](D:/___Project/260414_아동권리보장원/DEV/ncrc-pairing/src/main/java/com/kri/p6/ncrc/pairing/service/PairingHolidayService.java)
- [PairingValidationService.java](D:/___Project/260414_아동권리보장원/DEV/ncrc-pairing/src/main/java/com/kri/p6/ncrc/pairing/service/PairingValidationService.java)
- [PairingNewService.java](D:/___Project/260414_아동권리보장원/DEV/ncrc-pairing/src/main/java/com/kri/p6/ncrc/pairing/service/PairingNewService.java)
- `PairingNormalizeService#normalizePreferenceRegions` ### Config
- `PairingCandidateService#findPreferenceRank`
현재는 `00`이 나오면 그 위치와 뒤쪽 선호지역을 모두 `00`으로 처리합니다. - [PairingProperties.java](D:/___Project/260414_아동권리보장원/DEV/ncrc-pairing/src/main/java/com/kri/p6/ncrc/pairing/config/PairingProperties.java)
- [application.yaml](D:/___Project/260414_아동권리보장원/DEV/ncrc-pairing/src/main/resources/application.yaml)
### 희망지역 매칭표 해석이 바뀌는 경우 ## 빌드 / 테스트
수정 위치: 컴파일:
- `PairingCandidateService#findPreferenceRank`
- `PairingCandidateService#findPreferenceMatchRule`
- `PairingSolverService#createObjective`
현재는 현장위원 rank와 외부위원 rank를 구한 뒤, 엑셀의 `희망지역 매칭표`에서 매칭 순위를 찾습니다.
현재 rank 해석:
- `0`: 위원이 선호지역에 `00`을 입력한 anywhere 응답
- `99`: 해당 위원의 선호지역을 고려하지 않는 wildcard 조건
### 하루 최대 센터 수가 바뀌는 경우
수정 위치:
- `application.yaml`의 `pairing.rule.max-centers-per-pair-per-day`
- `PairingSolverService#addPairDailyCapacity`
### 한 위원의 상대 파트너 수 제한이 바뀌는 경우
수정 위치:
- `application.yaml`의 `pairing.rule.max-counterparts-per-member`
- `PairingSolverService#addBuddyLimit`
### 하루 1개 지역 제한 기준이 바뀌는 경우
수정 위치:
- `AssignmentCandidate`
- `PairingCandidateService#createAssignmentCandidates`
- `PairingSolverService#addPairDailyOneAdjacentClassification`
현재는 `인접지역 분류` 기준입니다. 나중에 권역 단위로 바뀌면 `pairDayAdjacentKey`가 사용하는 값을 바꿔야 합니다.
### 불가일자 또는 일정 조건이 바뀌는 경우
수정 위치:
- `PairingNormalizeService#parseDateSet`
- `PairingHolidayService`
- `PairingCandidateService#findFirstAssignableDate`
- `PairingCandidateService#isAvailableOn`
국공휴일 조회 방식이 바뀌면 `PairingHolidayService`와 `DatagoExtentionApiClient`를 함께 확인해야 합니다.
캐시 동작을 바꾸려면 `DatagoHolidayCache`를 확인합니다.
### 여성 전용 센터 규칙이 바뀌는 경우
수정 위치:
- `PairingNormalizeService#parseBooleanFlag`
- `PairingCandidateService#isAssignableCenter`
### 2023년 진행 센터 제외 규칙이 바뀌는 경우
수정 위치:
- `PairingNormalizeService#parseCsv`
- `PairingCandidateService#isAssignableCenter`
### A/B pair 운영 로직을 추가하는 경우
수정 위치:
- `PairingCandidateService`
- `PairingSolverService`
- 필요 시 `model`에 `ABPairCandidate` 추가
현재 A/B pair는 solver 결과 후처리로 구성합니다. 같은 파견 권역과 같은 인접지역 분류를 공유하고, 배정 날짜가 겹치지 않는 페어끼리 `AB 그룹`으로 묶습니다. 이는 A/B가 완전 대체 전담 관계가 아니라, 각자 배정은 유지하되 유사시에 서로 공백을 보완할 수 있는 관계라는 업무 해석을 따른 것입니다.
### 인접지역 분류 랜덤 선택을 엄격하게 적용하는 경우
수정 위치:
- `PairingCandidateService#createAssignmentCandidates`
- `PairingSolverService`
- 별도 후처리 서비스 추가 가능
현재 solver는 랜덤 없이 최적 선택을 하며, 같은 날짜/페어에 대해 하나의 인접지역 분류만 선택하도록 hard rule을 걸고 있습니다. 따라서 한 팀이 여러 인접지역 분류 그룹을 갈 수 있는 경우에도 solver가 objective에 가장 유리한 하나의 그룹만 선택합니다.
## 현재 구현상 주의점
- 모든 가능한 날짜를 후보로 만들지 않고, 각 페어/센터 조합의 가장 빠른 feasible 일자만 후보로 만듭니다.
- 이 방식은 후보 수를 줄여 빠르게 동작하지만, 날짜 선택 자유도가 낮아 실제 최적 배정률이 떨어질 수 있습니다.
- 배정률이 부족하면 `PairingCandidateService#findFirstAssignableDate`를 확장해 feasible 일자 여러 개를 후보로 생성해야 합니다.
- A/B pair는 현재 후처리 방식입니다. 배정 자체를 막는 hard constraint가 아니며, 결과 엑셀의 `AB 그룹`, `보완 현장위원 id`, `보완 외부위원 id` 컬럼으로 표시합니다.
- 결과 엑셀은 성공 시 파일로 반환합니다. 입력/검증 오류는 오류 엑셀로 반환하고, 시스템 오류는 공통 `BusinessException` 실패 응답을 사용합니다.
## 테스트
전체 테스트:
```powershell ```powershell
.\gradlew.bat clean test .\gradlew.bat compileJava compileTestJava
``` ```
샘플 엑셀 전체 흐름 테스트: 테스트:
```powershell ```powershell
.\gradlew.bat test --tests "com.kri.p6.ncrc.pairing.service.PairingServiceTest.pairingMemberByCenterCreatesResultWorkbook" .\gradlew.bat test
``` ```
실제 API 실행 테스트: 현재 테스트는 최소 Spring Boot 컨텍스트 테스트만 남아 있습니다.
```powershell ## 유지보수 포인트
.\gradlew.bat bootJar
java -jar build/libs/ncrc-pairing-0.0.1-SNAPSHOT.jar ### 1. 새 시트가 추가될 때
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
``` - 입력 시트라면 `PairingExcelService#read`
- 정규화가 필요하면 `PairingNormalizeService`
- 검증이 필요하면 `PairingValidationService`
### 2. 최종 배정 규칙이 바뀔 때
- 대부분 [PairingNewService.java](D:/___Project/260414_아동권리보장원/DEV/ncrc-pairing/src/main/java/com/kri/p6/ncrc/pairing/service/PairingNewService.java) 수정
- 페어 생성 규칙 변경
- `matchMembers`
- `createPairCandidates`
- `scorePair`
- 최종 배정 규칙 변경
- `assignAdjacentRegions`
- `findBestAssignmentChoice`
- `firstAvailableDateForRegion`
### 3. 규칙검사 기준이 바뀔 때
- `createRuleChecks`
- `createAssignmentRuleChecks`
### 4. dispatchRegion 복수 입력 형식이 바뀔 때
- 현재는 `PairingNormalizeService#toCenterAdjacentRegions`에서 행확장
- 이 형식이 바뀌면 여기부터 수정하는 것이 맞습니다
## 비고
- 현재 결과는 “최대한 단순한 방향의 그리디 배정”을 목표로 합니다.

View File

@@ -45,28 +45,23 @@ repositories {
} }
} }
dependencies { dependencies {
implementation "com.kri.common:starter:beta.1.1.15" implementation "com.kri.common:starter:beta.1.1.17"
implementation "org.apache.poi:poi-ooxml:5.5.1" implementation "org.apache.poi:poi-ooxml:5.5.1"
implementation 'org.springframework.boot:spring-boot-starter-web' implementation 'org.springframework.boot:spring-boot-starter-web'
implementation 'org.springframework.boot:spring-boot-starter-security' implementation 'org.springframework.boot:spring-boot-starter-security'
implementation 'org.springframework.boot:spring-boot-starter-validation'
implementation "org.springdoc:springdoc-openapi-starter-webmvc-ui:2.8.11" implementation "org.springdoc:springdoc-openapi-starter-webmvc-ui:2.8.11"
//ortools-java CP-SAT Solver를 사용하기 위함
implementation "com.google.ortools:ortools-java:9.15.6755"
compileOnly 'org.projectlombok:lombok' compileOnly 'org.projectlombok:lombok'
annotationProcessor 'org.projectlombok:lombok' annotationProcessor 'org.projectlombok:lombok'
developmentOnly 'org.springframework.boot:spring-boot-devtools' developmentOnly 'org.springframework.boot:spring-boot-devtools'
testImplementation 'org.springframework.boot:spring-boot-starter-test' testImplementation 'org.springframework.boot:spring-boot-starter-test'
testImplementation 'org.springframework.security:spring-security-test'
testRuntimeOnly 'org.junit.platform:junit-platform-launcher' testRuntimeOnly 'org.junit.platform:junit-platform-launcher'
} }
tasks.named('test') { tasks.named('test') {
useJUnitPlatform() useJUnitPlatform()
maxHeapSize = '4g' maxHeapSize = '8g'
} }

View File

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

View File

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

View File

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

View File

@@ -11,11 +11,7 @@ public class PairingProperties {
private Excel excel = new Excel(); private Excel excel = new Excel();
private Code code = new Code(); private Code code = new Code();
private Rule rule = new Rule();
private Preference preference = new Preference(); private Preference preference = new Preference();
private Objective objective = new Objective();
private Candidate candidate = new Candidate();
private Solver solver = new Solver();
@Getter @Getter
@Setter @Setter
@@ -28,48 +24,13 @@ public class PairingProperties {
public static class Code { public static class Code {
private int regionCodeLength = 2; private int regionCodeLength = 2;
private int residenceCodeLength = 5; private int residenceCodeLength = 5;
private int residenceMatchPrefixLength = 3;
private String anyRegionCode = "00"; private String anyRegionCode = "00";
} }
@Getter
@Setter
public static class Rule {
private int maxCentersPerPairPerDay = 3;
private int maxCounterpartsPerMember = 2;
}
@Getter @Getter
@Setter @Setter
public static class Preference { public static class Preference {
private int anywhereRank = 0; private int anywhereRank = 0;
private int ignoredRank = 99; private int ignoredRank = 99;
} }
@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;
}
@Getter
@Setter
public static class Candidate {
private int maxDispatchRegionsPerPair = 5;
private int maxAssignmentsPerCenter = 30;
private int maxAssignmentsPerMember = 80;
private int maxDatesPerAssignmentCandidate = 5;
}
@Getter
@Setter
public static class Solver {
private double maxTimeSeconds = 30.0;
private int numSearchWorkers = Math.max(1, Runtime.getRuntime().availableProcessors() - 1);
}
} }

View File

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

View File

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

View File

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

View File

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

View File

@@ -1,39 +0,0 @@
package com.kri.p6.ncrc.pairing.dto.excel.output;
import com.kri.common.feature.excel.ExcelColumn;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
@Data
@NoArgsConstructor
@AllArgsConstructor
public class ABPairExcelDto {
@ExcelColumn(header = "AB 그룹", order = 0, width = 12)
private String groupId;
@ExcelColumn(header = "A 현장위원 id", order = 1, width = 18)
private String aFieldMemberId;
@ExcelColumn(header = "A 외부위원 id", order = 2, width = 18)
private String aExternalMemberId;
@ExcelColumn(header = "B 현장위원 id", order = 3, width = 18)
private String bFieldMemberId;
@ExcelColumn(header = "B 외부위원 id", order = 4, width = 18)
private String bExternalMemberId;
@ExcelColumn(header = "공유 파견 권역", order = 5, width = 15)
private String sharedDispatchRegion;
@ExcelColumn(header = "A 배정일", order = 6, width = 25)
private String aAssignmentDates;
@ExcelColumn(header = "B 배정일", order = 7, width = 25)
private String bAssignmentDates;
@ExcelColumn(header = "날짜 겹침 여부", order = 8, width = 15)
private String dateOverlapped;
}

View File

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

View File

@@ -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;
}

View File

@@ -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;
}

View File

@@ -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;
}

View File

@@ -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;
}

View File

@@ -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;
}

View File

@@ -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;
}

View File

@@ -1,18 +0,0 @@
package com.kri.p6.ncrc.pairing.dto.excel.output;
import com.kri.common.feature.excel.ExcelColumn;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
@Data
@NoArgsConstructor
@AllArgsConstructor
public class PairingSummaryExcelDto {
@ExcelColumn(header = "항목", order = 0, width = 25)
private String name;
@ExcelColumn(header = "값", order = 1, width = 20)
private String value;
}

View File

@@ -1,21 +0,0 @@
package com.kri.p6.ncrc.pairing.dto.excel.output;
import com.kri.common.feature.excel.ExcelColumn;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
@Data
@NoArgsConstructor
@AllArgsConstructor
public class UnassignedCenterExcelDto {
@ExcelColumn(header = "센터 id", order = 0, width = 15)
private String centerId;
@ExcelColumn(header = "지자체 id", order = 1, width = 15)
private String municipalityId;
@ExcelColumn(header = "사유", order = 2, width = 40)
private String reason;
}

View File

@@ -1,21 +0,0 @@
package com.kri.p6.ncrc.pairing.dto.excel.output;
import com.kri.common.feature.excel.ExcelColumn;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
@Data
@NoArgsConstructor
@AllArgsConstructor
public class UnusedMemberExcelDto {
@ExcelColumn(header = "위원 id", order = 0, width = 15)
private String memberId;
@ExcelColumn(header = "현장/외부 구분", order = 1, width = 15)
private String role;
@ExcelColumn(header = "사유", order = 2, width = 40)
private String reason;
}

View File

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

View File

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

View File

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

View File

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

View File

@@ -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;
}

View 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;
}

View File

@@ -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;
}

View File

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

View File

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

View File

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

View File

@@ -1,28 +0,0 @@
package com.kri.p6.ncrc.pairing.model;
import com.kri.p6.ncrc.pairing.dto.excel.output.ABPairExcelDto;
import com.kri.p6.ncrc.pairing.dto.excel.output.AssignmentResultExcelDto;
import com.kri.p6.ncrc.pairing.dto.excel.output.CandidateSummaryExcelDto;
import com.kri.p6.ncrc.pairing.dto.excel.output.PairingSummaryExcelDto;
import com.kri.p6.ncrc.pairing.dto.excel.output.RuleViolationExcelDto;
import com.kri.p6.ncrc.pairing.dto.excel.output.UnassignedCenterExcelDto;
import com.kri.p6.ncrc.pairing.dto.excel.output.UnusedMemberExcelDto;
import com.kri.p6.ncrc.pairing.dto.excel.output.ValidationErrorExcelDto;
import java.util.List;
import lombok.Builder;
import lombok.Getter;
@Getter
@Builder
public class PairingResult {
private final List<AssignmentResultExcelDto> assignments;
private final List<UnassignedCenterExcelDto> unassignedCenters;
private final List<UnusedMemberExcelDto> unusedMembers;
private final List<PairingSummaryExcelDto> summaries;
private final List<ABPairExcelDto> abPairs;
private final List<CandidateSummaryExcelDto> candidateSummaries;
private final List<ValidationErrorExcelDto> validationErrors;
private final List<RuleViolationExcelDto> ruleViolations;
}

View File

@@ -1,578 +0,0 @@
package com.kri.p6.ncrc.pairing.service;
import com.kri.p6.ncrc.pairing.common.enums.Gender;
import com.kri.p6.ncrc.pairing.common.enums.MemberRole;
import com.kri.p6.ncrc.pairing.config.PairingProperties;
import com.kri.p6.ncrc.pairing.model.AssignmentCandidate;
import com.kri.p6.ncrc.pairing.model.Center;
import com.kri.p6.ncrc.pairing.model.CenterAdjacentRegion;
import com.kri.p6.ncrc.pairing.model.DispatchRegionCandidate;
import com.kri.p6.ncrc.pairing.model.Member;
import com.kri.p6.ncrc.pairing.model.Municipality;
import com.kri.p6.ncrc.pairing.model.PairCandidate;
import com.kri.p6.ncrc.pairing.model.PairingCandidates;
import com.kri.p6.ncrc.pairing.model.PairingData;
import com.kri.p6.ncrc.pairing.model.PreferenceMatchRule;
import java.time.LocalDate;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.Set;
import java.util.function.Function;
import java.util.stream.Collectors;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Service;
@Service
@RequiredArgsConstructor
public class PairingCandidateService {
private final PairingProperties pairingProperties;
public PairingCandidates generate(PairingData data) {
List<PairCandidate> pairCandidates = createPairCandidates(data.getMembers());
List<DispatchRegionCandidate> dispatchRegionCandidates = trimDispatchRegionCandidates(
createDispatchRegionCandidates(data, pairCandidates));
Map<String, Set<String>> unassignedCenterReasons = createInitialCenterReasonMap(data);
List<AssignmentCandidate> rawAssignmentCandidates = createAssignmentCandidates(data,
pairCandidates, dispatchRegionCandidates, unassignedCenterReasons);
List<AssignmentCandidate> residencePreferredCandidates = preferResidenceMatchesByCenter(
rawAssignmentCandidates, unassignedCenterReasons);
List<AssignmentCandidate> assignmentCandidates = trimAssignmentCandidates(
residencePreferredCandidates,
data.getCenters(), unassignedCenterReasons);
return PairingCandidates.builder().pairCandidates(pairCandidates)
.dispatchRegionCandidates(dispatchRegionCandidates)
.assignmentCandidates(assignmentCandidates).unassignedCenterReasons(unassignedCenterReasons)
.build();
}
private List<PairCandidate> createPairCandidates(List<Member> members) {
List<Member> fieldMembers = members.stream()
.filter(member -> member.getRole() == MemberRole.FIELD).toList();
List<Member> externalMembers = members.stream()
.filter(member -> member.getRole() == MemberRole.EXTERNAL).toList();
List<PairCandidate> candidates = new ArrayList<>();
for (Member fieldMember : fieldMembers) {
for (Member externalMember : externalMembers) {
if (hasDateOverlap(fieldMember, externalMember)) {
candidates.add(PairCandidate.builder().fieldMemberId(fieldMember.getId())
.externalMemberId(externalMember.getId())
.residenceMatchScore(calculateResidenceMatchScore(fieldMember, externalMember))
.build());
}
}
}
return candidates;
}
private List<DispatchRegionCandidate> createDispatchRegionCandidates(PairingData data,
List<PairCandidate> pairCandidates) {
Map<String, Member> memberMap = toMemberMap(data.getMembers());
Set<String> dispatchRegions = data.getCenterAdjacentRegions().stream()
.map(CenterAdjacentRegion::getDispatchRegion).collect(Collectors.toSet());
List<DispatchRegionCandidate> candidates = new ArrayList<>();
for (PairCandidate pairCandidate : pairCandidates) {
Member fieldMember = memberMap.get(pairCandidate.getFieldMemberId());
Member externalMember = memberMap.get(pairCandidate.getExternalMemberId());
for (String dispatchRegion : dispatchRegions) {
if (!isConflictRegion(fieldMember, externalMember, dispatchRegion)) {
int fieldRank = findPreferenceRank(fieldMember, dispatchRegion);
int externalRank = findPreferenceRank(externalMember, dispatchRegion);
Optional<PreferenceMatchRule> matchRule = findPreferenceMatchRule(
data.getPreferenceMatchRules(), fieldRank, externalRank);
candidates.add(DispatchRegionCandidate.builder().fieldMemberId(fieldMember.getId())
.externalMemberId(externalMember.getId()).dispatchRegion(dispatchRegion)
.preferencePriority(matchRule.map(PreferenceMatchRule::getPriority)
.orElse(fallbackPreferencePriority(data.getPreferenceMatchRules())))
.fieldMemberPreferenceRank(fieldRank).externalMemberPreferenceRank(externalRank)
.build());
}
}
}
return candidates;
}
private List<AssignmentCandidate> createAssignmentCandidates(
PairingData data,
List<PairCandidate> pairCandidates,
List<DispatchRegionCandidate> dispatchRegionCandidates,
Map<String, Set<String>> unassignedCenterReasons
) {
Map<String, Member> memberMap = toMemberMap(data.getMembers());
Map<String, Municipality> municipalityMap = data.getMunicipalities().stream()
.collect(Collectors.toMap(Municipality::getId, Function.identity(), (left, right) -> left));
Map<String, PairCandidate> pairMap = pairCandidates.stream()
.collect(Collectors.toMap(this::pairKey, Function.identity(), (left, right) -> left));
Map<String, Set<String>> adjacentClassificationsByDispatchRegion = data.getCenterAdjacentRegions()
.stream().collect(Collectors.groupingBy(CenterAdjacentRegion::getDispatchRegion,
Collectors.mapping(CenterAdjacentRegion::getAdjacentRegionClassification,
Collectors.toSet())));
List<AssignmentCandidate> candidates = new ArrayList<>();
for (DispatchRegionCandidate dispatchCandidate : dispatchRegionCandidates) {
Member fieldMember = memberMap.get(dispatchCandidate.getFieldMemberId());
Member externalMember = memberMap.get(dispatchCandidate.getExternalMemberId());
PairCandidate pairCandidate = pairMap.get(
pairKey(dispatchCandidate.getFieldMemberId(),
dispatchCandidate.getExternalMemberId()));
Set<String> adjacentClassifications = adjacentClassificationsByDispatchRegion
.getOrDefault(dispatchCandidate.getDispatchRegion(), Set.of());
for (Center center : data.getCenters()) {
if (!adjacentClassifications.contains(center.getAdjacentRegionClassification())) {
addReason(unassignedCenterReasons, center.getId(), "파견 권역과 센터 인접지역 분류 불일치");
} else {
Municipality municipality = municipalityMap.get(
center.getMunicipalityId());
List<String> centerReasons = findCenterHardRuleReasons(fieldMember, externalMember,
center);
if (!centerReasons.isEmpty()) {
centerReasons.forEach(
reason -> addReason(unassignedCenterReasons, center.getId(), reason));
} else {
List<LocalDate> assignableDates = findAssignableDates(fieldMember,
externalMember, municipality, center, commonUnavailableDates(data));
if (assignableDates.isEmpty()) {
addReason(unassignedCenterReasons, center.getId(),
"위원/지자체/센터 일정 또는 국공휴일 조건 불일치");
} else {
for (LocalDate assignableDate : assignableDates) {
candidates.add(AssignmentCandidate.builder().fieldMemberId(fieldMember.getId())
.externalMemberId(externalMember.getId()).centerId(center.getId())
.municipalityId(center.getMunicipalityId()).date(assignableDate)
.dispatchRegion(dispatchCandidate.getDispatchRegion())
.adjacentRegionClassification(center.getAdjacentRegionClassification())
.preferencePriority(dispatchCandidate.getPreferencePriority())
.fieldMemberPreferenceRank(dispatchCandidate.getFieldMemberPreferenceRank())
.externalMemberPreferenceRank(dispatchCandidate.getExternalMemberPreferenceRank())
.residenceMatchScore(
pairCandidate == null ? 0 : pairCandidate.getResidenceMatchScore()).build());
}
}
}
}
}
}
return candidates;
}
private List<AssignmentCandidate> preferResidenceMatchesByCenter(
List<AssignmentCandidate> candidates, Map<String, Set<String>> unassignedCenterReasons) {
// 위원 전원 조편성이 0순위 HARD 룰이므로 거주지 유사도는 후보 제거 조건으로 쓰지 않습니다.
// 거주지 3자리/2자리 일치 여부는 solver 점수로만 반영합니다.
return candidates;
}
private List<DispatchRegionCandidate> trimDispatchRegionCandidates(
List<DispatchRegionCandidate> candidates) {
int limit = maxDispatchRegionsPerPair();
if (limit <= 0) {
return candidates;
}
return candidates.stream()
.collect(Collectors.groupingBy(this::pairKey, LinkedHashMap::new, Collectors.toList()))
.values()
.stream()
.flatMap(group -> group.stream()
.sorted(dispatchRegionCandidateComparator())
.limit(limit))
.toList();
}
private List<AssignmentCandidate> trimAssignmentCandidates(List<AssignmentCandidate> candidates,
List<Center> centers, Map<String, Set<String>> unassignedCenterReasons) {
List<AssignmentCandidate> trimmedByCenter = trimAssignmentsPerCenter(candidates);
List<AssignmentCandidate> trimmedByMember = trimAssignmentsPerMember(trimmedByCenter);
List<AssignmentCandidate> memberPreservedCandidates = preserveMinimumMemberCandidates(
candidates, new ArrayList<>(trimmedByMember), memberUsage(trimmedByMember),
maxAssignmentsPerMember());
addTrimmedCenterReasons(candidates, memberPreservedCandidates, centers, unassignedCenterReasons);
return memberPreservedCandidates;
}
private List<AssignmentCandidate> trimAssignmentsPerCenter(List<AssignmentCandidate> candidates) {
int limit = maxAssignmentsPerCenter();
if (limit <= 0) {
return candidates;
}
return candidates.stream()
.collect(Collectors.groupingBy(AssignmentCandidate::getCenterId, LinkedHashMap::new,
Collectors.toList()))
.values()
.stream()
.flatMap(group -> group.stream()
.sorted(assignmentCandidateComparator())
.limit(limit))
.toList();
}
private List<AssignmentCandidate> trimAssignmentsPerMember(List<AssignmentCandidate> candidates) {
int limit = maxAssignmentsPerMember();
if (limit <= 0) {
return candidates;
}
Map<String, Integer> memberUsage = new HashMap<>();
List<AssignmentCandidate> selected = new ArrayList<>();
for (AssignmentCandidate candidate : candidates.stream()
.sorted(assignmentCandidateComparator())
.toList()) {
int fieldCount = memberUsage.getOrDefault(candidate.getFieldMemberId(), 0);
int externalCount = memberUsage.getOrDefault(candidate.getExternalMemberId(), 0);
if (fieldCount < limit && externalCount < limit) {
addAssignmentCandidate(selected, memberUsage, candidate);
}
}
return preserveMinimumMemberCandidates(candidates, selected, memberUsage, limit);
}
private List<AssignmentCandidate> preserveMinimumMemberCandidates(
List<AssignmentCandidate> candidates, List<AssignmentCandidate> selected,
Map<String, Integer> memberUsage, int limit) {
Set<String> selectedKeys = selected.stream()
.map(this::assignmentKey)
.collect(Collectors.toSet());
Set<String> missingMemberIds = candidates.stream()
.flatMap(candidate -> java.util.stream.Stream.of(candidate.getFieldMemberId(),
candidate.getExternalMemberId()))
.filter(memberId -> memberUsage.getOrDefault(memberId, 0) == 0)
.collect(Collectors.toCollection(LinkedHashSet::new));
for (AssignmentCandidate candidate : candidates.stream()
.sorted(assignmentCandidateComparator())
.toList()) {
if (missingMemberIds.isEmpty()) {
break;
}
if (selectedKeys.contains(assignmentKey(candidate))) {
continue;
}
if (!missingMemberIds.contains(candidate.getFieldMemberId())
&& !missingMemberIds.contains(candidate.getExternalMemberId())) {
continue;
}
int fieldCount = memberUsage.getOrDefault(candidate.getFieldMemberId(), 0);
int externalCount = memberUsage.getOrDefault(candidate.getExternalMemberId(), 0);
if (fieldCount < limit && externalCount < limit) {
addAssignmentCandidate(selected, memberUsage, candidate);
selectedKeys.add(assignmentKey(candidate));
missingMemberIds.remove(candidate.getFieldMemberId());
missingMemberIds.remove(candidate.getExternalMemberId());
}
}
return selected;
}
private void addAssignmentCandidate(List<AssignmentCandidate> selected,
Map<String, Integer> memberUsage, AssignmentCandidate candidate) {
selected.add(candidate);
memberUsage.merge(candidate.getFieldMemberId(), 1, Integer::sum);
memberUsage.merge(candidate.getExternalMemberId(), 1, Integer::sum);
}
private Map<String, Integer> memberUsage(List<AssignmentCandidate> candidates) {
Map<String, Integer> memberUsage = new HashMap<>();
candidates.forEach(candidate -> {
memberUsage.merge(candidate.getFieldMemberId(), 1, Integer::sum);
memberUsage.merge(candidate.getExternalMemberId(), 1, Integer::sum);
});
return memberUsage;
}
private void addTrimmedCenterReasons(List<AssignmentCandidate> originalCandidates,
List<AssignmentCandidate> trimmedCandidates, List<Center> centers,
Map<String, Set<String>> unassignedCenterReasons) {
Set<String> originalCenterIds = originalCandidates.stream()
.map(AssignmentCandidate::getCenterId)
.collect(Collectors.toSet());
Set<String> trimmedCenterIds = trimmedCandidates.stream()
.map(AssignmentCandidate::getCenterId)
.collect(Collectors.toSet());
for (Center center : centers) {
if (originalCenterIds.contains(center.getId()) && !trimmedCenterIds.contains(center.getId())) {
addReason(unassignedCenterReasons, center.getId(),
"후보 축소 과정에서 상위 후보에 들지 못함");
}
}
}
private boolean hasDateOverlap(Member fieldMember, Member externalMember) {
LocalDate latestStart = max(fieldMember.getAvailableStartDate(),
externalMember.getAvailableStartDate());
LocalDate earliestEnd = min(fieldMember.getAvailableEndDate(),
externalMember.getAvailableEndDate());
return !latestStart.isAfter(earliestEnd);
}
private int calculateResidenceMatchScore(Member fieldMember, Member externalMember) {
if (isSameResidencePrefix(fieldMember, externalMember, residenceMatchPrefixLength())) {
return 2;
}
if (isSameResidencePrefix(fieldMember, externalMember, secondaryResidenceMatchPrefixLength())) {
return 1;
}
return 0;
}
private boolean isSameResidencePrefix(Member fieldMember, Member externalMember, int length) {
String fieldPrefix = prefix(fieldMember.getResidenceCode(), length);
String externalPrefix = prefix(externalMember.getResidenceCode(), length);
return !fieldPrefix.isBlank() && fieldPrefix.equals(externalPrefix);
}
private boolean isConflictRegion(Member fieldMember, Member externalMember,
String dispatchRegion) {
return hasActivityRegion(fieldMember, dispatchRegion) || hasActivityRegion(externalMember,
dispatchRegion);
}
private boolean hasActivityRegion(Member member, String dispatchRegion) {
return java.util.Arrays.stream(member.getActivityRegion().split(","))
.map(String::trim)
.anyMatch(dispatchRegion::equals);
}
private int findPreferenceRank(Member member, String dispatchRegion) {
List<String> preferences = member.getPreferenceRegions();
for (int i = 0; i < preferences.size(); ++i) {
String preference = preferences.get(i);
if (dispatchRegion.equals(preference)) {
return i + 1;
}
if (anyRegionCode().equals(preference)) {
return anywherePreferenceRank();
}
}
return -1;
}
private Optional<PreferenceMatchRule> findPreferenceMatchRule(List<PreferenceMatchRule> rules,
int fieldRank, int externalRank) {
return fieldRank >= 0 && externalRank >= 0 ?
rules.stream().filter(
rule -> matchesPreferenceRank(rule.getFieldMemberPreferenceRank(), fieldRank)
)
.filter(rule -> matchesPreferenceRank(rule.getExternalMemberPreferenceRank(),externalRank))
.min(Comparator.comparingInt(PreferenceMatchRule::getPriority))
: Optional.empty();
}
private int fallbackPreferencePriority(List<PreferenceMatchRule> rules) {
return rules.stream()
.mapToInt(PreferenceMatchRule::getPriority)
.max()
.orElse(0) + 1000;
}
private boolean matchesPreferenceRank(int ruleRank, int memberRank) {
return ruleRank == ignoredPreferenceRank() || ruleRank == memberRank;
}
private List<String> findCenterHardRuleReasons(Member fieldMember, Member externalMember,
Center center) {
List<String> reasons = new ArrayList<>();
if (center.isWomenOnly() && (fieldMember.getGender() != Gender.FEMALE
|| externalMember.getGender() != Gender.FEMALE)) {
reasons.add("여성 전용 센터 조건 불충족");
}
if (fieldMember.getHistoryCenterIds().contains(center.getId())
|| externalMember.getHistoryCenterIds().contains(center.getId())) {
reasons.add("2023년 진행 센터 재배정 제외");
}
return reasons;
}
private List<LocalDate> findAssignableDates(Member fieldMember, Member externalMember,
Municipality municipality, Center center, Set<LocalDate> commonUnavailableDates) {
List<LocalDate> dates = new ArrayList<>();
LocalDate start = max(
max(fieldMember.getAvailableStartDate(), externalMember.getAvailableStartDate()),
max(municipality.getAvailableStartDate(), center.getAvailableStartDate()));
LocalDate end = min(
min(fieldMember.getAvailableEndDate(), externalMember.getAvailableEndDate()),
min(municipality.getAvailableEndDate(), center.getAvailableEndDate()));
if (!start.isAfter(end)) {
for (LocalDate date = start; !date.isAfter(end); date = date.plusDays(1L)) {
if (isAvailableOn(date, fieldMember, externalMember, municipality, center,
commonUnavailableDates)) {
dates.add(date);
if (dates.size() >= maxDatesPerAssignmentCandidate()) {
break;
}
}
}
}
return dates;
}
private boolean isAvailableOn(LocalDate date, Member fieldMember, Member externalMember,
Municipality municipality, Center center, Set<LocalDate> commonUnavailableDates) {
return !fieldMember.getUnavailableDates().contains(date)
&& !externalMember.getUnavailableDates().contains(date)
&& !municipality.getUnavailableDates().contains(date) && !center.getUnavailableDates()
.contains(date) && !commonUnavailableDates.contains(date);
}
private Map<String, Set<String>> createInitialCenterReasonMap(PairingData data) {
Map<String, Set<String>> reasons = new HashMap<>();
data.getCenters().forEach(center -> reasons.put(center.getId(), new LinkedHashSet<>()));
return reasons;
}
private void addReason(Map<String, Set<String>> reasons, String centerId, String reason) {
reasons.computeIfAbsent(centerId, key -> new LinkedHashSet<>()).add(reason);
}
private Set<LocalDate> commonUnavailableDates(PairingData data) {
return data.getCommonUnavailableDates() == null ? Set.of() : data.getCommonUnavailableDates();
}
private Map<String, Member> toMemberMap(List<Member> members) {
return members.stream()
.collect(Collectors.toMap(Member::getId, Function.identity(), (left, right) -> left));
}
private String pairKey(PairCandidate pairCandidate) {
return pairKey(pairCandidate.getFieldMemberId(), pairCandidate.getExternalMemberId());
}
private String pairKey(DispatchRegionCandidate dispatchRegionCandidate) {
return pairKey(dispatchRegionCandidate.getFieldMemberId(),
dispatchRegionCandidate.getExternalMemberId());
}
private String pairKey(String fieldMemberId, String externalMemberId) {
return fieldMemberId + "|" + externalMemberId;
}
private String assignmentKey(AssignmentCandidate candidate) {
return candidate.getFieldMemberId() + "|" + candidate.getExternalMemberId() + "|"
+ candidate.getCenterId() + "|" + candidate.getDate();
}
private String prefix(String value) {
return prefix(value, residenceMatchPrefixLength());
}
private String prefix(String value, int length) {
return value.substring(0, Math.min(length, value.length()));
}
private String anyRegionCode() {
return pairingProperties.getCode().getAnyRegionCode();
}
private int anywherePreferenceRank() {
return pairingProperties.getPreference().getAnywhereRank();
}
private int ignoredPreferenceRank() {
return pairingProperties.getPreference().getIgnoredRank();
}
private int residenceMatchPrefixLength() {
return pairingProperties.getCode().getResidenceMatchPrefixLength();
}
private int secondaryResidenceMatchPrefixLength() {
return Math.max(1, residenceMatchPrefixLength() - 1);
}
private int maxDispatchRegionsPerPair() {
return pairingProperties.getCandidate().getMaxDispatchRegionsPerPair();
}
private int maxAssignmentsPerCenter() {
return pairingProperties.getCandidate().getMaxAssignmentsPerCenter();
}
private int maxAssignmentsPerMember() {
return pairingProperties.getCandidate().getMaxAssignmentsPerMember();
}
private int maxDatesPerAssignmentCandidate() {
return pairingProperties.getCandidate().getMaxDatesPerAssignmentCandidate();
}
private Comparator<DispatchRegionCandidate> dispatchRegionCandidateComparator() {
return Comparator.comparingInt(this::dispatchRegionCandidateScore).reversed()
.thenComparing(DispatchRegionCandidate::getDispatchRegion);
}
private Comparator<AssignmentCandidate> assignmentCandidateComparator() {
return Comparator.comparingInt(this::assignmentCandidateScore).reversed()
.thenComparing(AssignmentCandidate::getDate)
.thenComparing(AssignmentCandidate::getCenterId)
.thenComparing(AssignmentCandidate::getFieldMemberId)
.thenComparing(AssignmentCandidate::getExternalMemberId);
}
private int dispatchRegionCandidateScore(DispatchRegionCandidate candidate) {
return preferenceScore(candidate.getPreferencePriority())
+ preferenceRankBonus(candidate.getFieldMemberPreferenceRank())
+ preferenceRankBonus(candidate.getExternalMemberPreferenceRank());
}
private int assignmentCandidateScore(AssignmentCandidate candidate) {
return preferenceScore(candidate.getPreferencePriority())
+ preferenceRankBonus(candidate.getFieldMemberPreferenceRank())
+ preferenceRankBonus(candidate.getExternalMemberPreferenceRank())
+ candidate.getResidenceMatchScore() * (int) pairingProperties.getObjective()
.getResidenceMatchWeight();
}
private int preferenceScore(int priority) {
return (int) Math.max(0L, pairingProperties.getObjective().getPreferenceBaseWeight()
- priority * pairingProperties.getObjective().getPreferenceRankPenalty());
}
private int preferenceRankBonus(int rank) {
if (rank == anywherePreferenceRank()) {
return 1;
}
if (rank <= 0 || rank == ignoredPreferenceRank()) {
return 0;
}
return Math.max(0, 10 - rank);
}
private LocalDate max(LocalDate left, LocalDate right) {
return left.isAfter(right) ? left : right;
}
private LocalDate min(LocalDate left, LocalDate right) {
return left.isBefore(right) ? left : right;
}
}

View File

@@ -1,17 +1,8 @@
package com.kri.p6.ncrc.pairing.service; package com.kri.p6.ncrc.pairing.service;
import static com.kri.p6.ncrc.pairing.common.consts.PairingConstant.RESULT_SHEET_AB_PAIR;
import static com.kri.p6.ncrc.pairing.common.consts.PairingConstant.RESULT_SHEET_ASSIGNMENT;
import static com.kri.p6.ncrc.pairing.common.consts.PairingConstant.RESULT_SHEET_CANDIDATE_SUMMARY;
import static com.kri.p6.ncrc.pairing.common.consts.PairingConstant.RESULT_SHEET_RULE_CHECK;
import static com.kri.p6.ncrc.pairing.common.consts.PairingConstant.RESULT_SHEET_SUMMARY;
import static com.kri.p6.ncrc.pairing.common.consts.PairingConstant.RESULT_SHEET_UNASSIGNED_CENTER;
import static com.kri.p6.ncrc.pairing.common.consts.PairingConstant.RESULT_SHEET_UNUSED_MEMBER;
import static com.kri.p6.ncrc.pairing.common.consts.PairingConstant.RESULT_SHEET_VALIDATION_ERROR;
import static com.kri.p6.ncrc.pairing.common.consts.PairingConstant.SHEET_CENTER; import static com.kri.p6.ncrc.pairing.common.consts.PairingConstant.SHEET_CENTER;
import static com.kri.p6.ncrc.pairing.common.consts.PairingConstant.SHEET_CENTER_ADJACENT_REGION; import static com.kri.p6.ncrc.pairing.common.consts.PairingConstant.SHEET_CENTER_ADJACENT_REGION;
import static com.kri.p6.ncrc.pairing.common.consts.PairingConstant.SHEET_MEMBER; import static com.kri.p6.ncrc.pairing.common.consts.PairingConstant.SHEET_MEMBER;
import static com.kri.p6.ncrc.pairing.common.consts.PairingConstant.SHEET_MEMBER_REGION_CODE;
import static com.kri.p6.ncrc.pairing.common.consts.PairingConstant.SHEET_MUNICIPALITY; import static com.kri.p6.ncrc.pairing.common.consts.PairingConstant.SHEET_MUNICIPALITY;
import static com.kri.p6.ncrc.pairing.common.consts.PairingConstant.SHEET_PREFERENCE_MATCH; import static com.kri.p6.ncrc.pairing.common.consts.PairingConstant.SHEET_PREFERENCE_MATCH;
@@ -21,19 +12,19 @@ import com.kri.p6.ncrc.pairing.config.PairingProperties;
import com.kri.p6.ncrc.pairing.dto.excel.input.CenterAdjacentRegionExcelDto; import com.kri.p6.ncrc.pairing.dto.excel.input.CenterAdjacentRegionExcelDto;
import com.kri.p6.ncrc.pairing.dto.excel.input.CenterExcelDto; import com.kri.p6.ncrc.pairing.dto.excel.input.CenterExcelDto;
import com.kri.p6.ncrc.pairing.dto.excel.input.MemberExcelDto; import com.kri.p6.ncrc.pairing.dto.excel.input.MemberExcelDto;
import com.kri.p6.ncrc.pairing.dto.excel.input.MemberRegionCodeExcelDto;
import com.kri.p6.ncrc.pairing.dto.excel.input.MunicipalityExcelDto; import com.kri.p6.ncrc.pairing.dto.excel.input.MunicipalityExcelDto;
import com.kri.p6.ncrc.pairing.dto.excel.input.PairingWorkbookData; import com.kri.p6.ncrc.pairing.dto.excel.input.PairingWorkbookData;
import com.kri.p6.ncrc.pairing.dto.excel.input.PreferenceMatchExcelDto; import com.kri.p6.ncrc.pairing.dto.excel.input.PreferenceMatchExcelDto;
import com.kri.p6.ncrc.pairing.dto.excel.output.ABPairExcelDto;
import com.kri.p6.ncrc.pairing.dto.excel.output.AssignmentResultExcelDto;
import com.kri.p6.ncrc.pairing.dto.excel.output.CandidateSummaryExcelDto; import com.kri.p6.ncrc.pairing.dto.excel.output.CandidateSummaryExcelDto;
import com.kri.p6.ncrc.pairing.dto.excel.output.PairingSummaryExcelDto; import com.kri.p6.ncrc.pairing.dto.excel.output.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.RuleViolationExcelDto; 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.dto.excel.output.ValidationErrorExcelDto;
import com.kri.p6.ncrc.pairing.model.PairingResult; import com.kri.p6.ncrc.pairing.model.NewPairingResult;
import java.io.ByteArrayOutputStream; import java.io.ByteArrayOutputStream;
import java.io.IOException; import java.io.IOException;
import java.io.InputStream; import java.io.InputStream;
@@ -63,8 +54,6 @@ public class PairingExcelService {
.members(readSheet(workbook, MemberExcelDto.class, SHEET_MEMBER)) .members(readSheet(workbook, MemberExcelDto.class, SHEET_MEMBER))
.municipalities(readSheet(workbook, MunicipalityExcelDto.class, SHEET_MUNICIPALITY)) .municipalities(readSheet(workbook, MunicipalityExcelDto.class, SHEET_MUNICIPALITY))
.centers(readSheet(workbook, CenterExcelDto.class, SHEET_CENTER)) .centers(readSheet(workbook, CenterExcelDto.class, SHEET_CENTER))
.memberRegionCodes(readSheet(workbook, MemberRegionCodeExcelDto.class,
SHEET_MEMBER_REGION_CODE))
.centerAdjacentRegions(readSheet(workbook, CenterAdjacentRegionExcelDto.class, .centerAdjacentRegions(readSheet(workbook, CenterAdjacentRegionExcelDto.class,
SHEET_CENTER_ADJACENT_REGION)) SHEET_CENTER_ADJACENT_REGION))
.preferenceMatchRules(readSheet(workbook, PreferenceMatchExcelDto.class, .preferenceMatchRules(readSheet(workbook, PreferenceMatchExcelDto.class,
@@ -78,25 +67,25 @@ public class PairingExcelService {
} }
} }
public byte[] write(PairingResult result) { public byte[] writeNew(NewPairingResult result) {
try (Workbook workbook = ExcelMapper.writeToWorkbook(result.getAssignments(), try (Workbook workbook = ExcelMapper.writeToWorkbook(result.getPairs(),
AssignmentResultExcelDto.class, RESULT_SHEET_ASSIGNMENT); NewPairResultExcelDto.class, "페어결과");
ByteArrayOutputStream outputStream = new ByteArrayOutputStream()) { ByteArrayOutputStream outputStream = new ByteArrayOutputStream()) {
ExcelMapper.appendSheetToWorkbook(workbook, result.getUnassignedCenters(), ExcelMapper.appendSheetToWorkbook(workbook, result.getFinalAssignments(),
UnassignedCenterExcelDto.class, RESULT_SHEET_UNASSIGNED_CENTER, headerRowIndex()); NewFinalAssignmentExcelDto.class, "최종 배정 with 인접지역", headerRowIndex());
ExcelMapper.appendSheetToWorkbook(workbook, result.getUnusedMembers(), ExcelMapper.appendSheetToWorkbook(workbook, result.getFinalAssignmentsWithCenters(),
UnusedMemberExcelDto.class, RESULT_SHEET_UNUSED_MEMBER, headerRowIndex()); 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(), ExcelMapper.appendSheetToWorkbook(workbook, result.getSummaries(),
PairingSummaryExcelDto.class, RESULT_SHEET_SUMMARY, headerRowIndex()); CandidateSummaryExcelDto.class, "페어후보요약", headerRowIndex());
ExcelMapper.appendSheetToWorkbook(workbook, result.getAbPairs(), ABPairExcelDto.class, ExcelMapper.appendSheetToWorkbook(workbook, result.getScoreGuides(),
RESULT_SHEET_AB_PAIR, headerRowIndex()); NewPairScoreGuideExcelDto.class, "페어점수계산", headerRowIndex());
ExcelMapper.appendSheetToWorkbook(workbook, result.getCandidateSummaries(), ExcelMapper.appendSheetToWorkbook(workbook, result.getRuleChecks(),
CandidateSummaryExcelDto.class, RESULT_SHEET_CANDIDATE_SUMMARY, headerRowIndex()); RuleViolationExcelDto.class, "규칙검사", headerRowIndex());
ExcelMapper.appendSheetToWorkbook(workbook, result.getValidationErrors(),
ValidationErrorExcelDto.class, RESULT_SHEET_VALIDATION_ERROR, headerRowIndex());
ExcelMapper.appendSheetToWorkbook(workbook, result.getRuleViolations(),
RuleViolationExcelDto.class, RESULT_SHEET_RULE_CHECK, headerRowIndex());
workbook.write(outputStream); workbook.write(outputStream);
return outputStream.toByteArray(); return outputStream.toByteArray();
@@ -107,17 +96,16 @@ public class PairingExcelService {
} }
public byte[] writeValidationError(String code, String message) { public byte[] writeValidationError(String code, String message) {
PairingResult result = PairingResult.builder() try (Workbook workbook = ExcelMapper.writeToWorkbook(
.assignments(List.of()) List.of(new ValidationErrorExcelDto(code, message, "ERROR")),
.unassignedCenters(List.of()) ValidationErrorExcelDto.class, "검증오류");
.unusedMembers(List.of()) ByteArrayOutputStream outputStream = new ByteArrayOutputStream()) {
.summaries(List.of(new PairingSummaryExcelDto("처리 상태", "검증 실패"))) workbook.write(outputStream);
.abPairs(List.of()) return outputStream.toByteArray();
.candidateSummaries(List.of()) } catch (IOException e) {
.validationErrors(List.of(new ValidationErrorExcelDto(code, message, "ERROR"))) throw BusinessException.badRequest("PAIRING_EXCEL_WRITE_FAILED",
.ruleViolations(List.of()) "오류 엑셀 파일을 생성하는 중 오류가 발생했습니다: " + e.getMessage());
.build(); }
return write(result);
} }
private <T> List<T> readSheet(Workbook workbook, Class<T> type, String sheetName) { private <T> List<T> readSheet(Workbook workbook, Class<T> type, String sheetName) {

View File

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

File diff suppressed because it is too large Load Diff

View File

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

View File

@@ -1,290 +0,0 @@
package com.kri.p6.ncrc.pairing.service;
import com.kri.p6.ncrc.pairing.dto.excel.output.CandidateSummaryExcelDto;
import com.kri.p6.ncrc.pairing.dto.excel.output.PairingSummaryExcelDto;
import com.kri.p6.ncrc.pairing.config.PairingProperties;
import com.kri.p6.ncrc.pairing.model.AssignmentCandidate;
import com.kri.p6.ncrc.pairing.model.Center;
import com.kri.p6.ncrc.pairing.model.Member;
import com.kri.p6.ncrc.pairing.model.PairCandidate;
import com.kri.p6.ncrc.pairing.model.PairingCandidates;
import com.kri.p6.ncrc.pairing.model.PairingData;
import com.kri.p6.ncrc.pairing.model.PairingResult;
import java.time.LocalDate;
import java.util.ArrayList;
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.Set;
import java.util.function.Function;
import java.util.stream.Collectors;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Service;
@Service
@RequiredArgsConstructor
public class PairingScheduleService {
private final PairingCandidateService pairingCandidateService;
private final PairingSolverService pairingSolverService;
private final PairingProperties pairingProperties;
public PairingResult schedule(PairingData originData) {
List<Center> remainingCenters = new ArrayList<>(originData.getCenters());
List<Member> currentMembers = originData.getMembers();
List<AssignmentCandidate> scheduledAssignments = new ArrayList<>();
List<PairingCandidates> roundCandidates = new ArrayList<>();
Map<String, Set<String>> counterpartsByMember = new HashMap<>();
Map<String, Integer> visitCountsByMember = createInitialVisitCounts(originData.getMembers());
int round = 0;
String stopReason = "센터를 모두 배정했습니다.";
while (!remainingCenters.isEmpty() && round < originData.getCenters().size()) {
round++;
PairingData roundData = copyData(originData, currentMembers, remainingCenters);
PairingCandidates candidates = filterByCounterpartLimit(
pairingCandidateService.generate(roundData), counterpartsByMember);
roundCandidates.add(candidates);
PairingSolverService.SolveSelection selection = pairingSolverService.select(candidates,
counterpartsByMember, visitCountsByMember,
mandatoryUnusedMemberIds(candidates, visitCountsByMember));
if (!selection.hasSolution() || selection.selectedAssignments().isEmpty()) {
stopReason = selection.status();
break;
}
List<AssignmentCandidate> selected = selection.selectedAssignments();
scheduledAssignments.addAll(selected);
addCounterparts(counterpartsByMember, selected);
addVisitCounts(visitCountsByMember, selected);
Set<String> assignedCenterIds = selected.stream()
.map(AssignmentCandidate::getCenterId)
.collect(Collectors.toSet());
remainingCenters = remainingCenters.stream()
.filter(center -> !assignedCenterIds.contains(center.getId()))
.toList();
currentMembers = blockAssignedDates(currentMembers, selected);
}
PairingCandidates mergedCandidates = mergeCandidates(roundCandidates);
PairingResult result = pairingSolverService.buildResult(originData, mergedCandidates,
scheduledAssignments, stopReason(round, remainingCenters, stopReason));
return appendScheduleSummaries(result, round, originData.getCenters().size(),
remainingCenters.size());
}
private PairingData copyData(PairingData originData, List<Member> members, List<Center> centers) {
return PairingData.builder()
.members(members)
.municipalities(originData.getMunicipalities())
.centers(centers)
.memberRegionCodes(originData.getMemberRegionCodes())
.centerAdjacentRegions(originData.getCenterAdjacentRegions())
.preferenceMatchRules(originData.getPreferenceMatchRules())
.commonUnavailableDates(originData.getCommonUnavailableDates())
.build();
}
private List<Member> blockAssignedDates(List<Member> members,
List<AssignmentCandidate> assignments) {
Map<String, Set<LocalDate>> datesByMemberId = new HashMap<>();
for (AssignmentCandidate assignment : assignments) {
datesByMemberId.computeIfAbsent(assignment.getFieldMemberId(), key -> new HashSet<>())
.add(assignment.getDate());
datesByMemberId.computeIfAbsent(assignment.getExternalMemberId(), key -> new HashSet<>())
.add(assignment.getDate());
}
return members.stream()
.map(member -> copyMemberWithBlockedDates(member,
datesByMemberId.getOrDefault(member.getId(), Set.of())))
.toList();
}
private PairingCandidates filterByCounterpartLimit(PairingCandidates candidates,
Map<String, Set<String>> counterpartsByMember) {
Set<String> allowedPairKeys = candidates.getPairCandidates().stream()
.filter(pair -> isAllowedPair(pair.getFieldMemberId(), pair.getExternalMemberId(),
counterpartsByMember))
.map(pair -> pairKey(pair.getFieldMemberId(), pair.getExternalMemberId()))
.collect(Collectors.toSet());
return PairingCandidates.builder()
.pairCandidates(candidates.getPairCandidates().stream()
.filter(pair -> allowedPairKeys.contains(
pairKey(pair.getFieldMemberId(), pair.getExternalMemberId())))
.toList())
.dispatchRegionCandidates(candidates.getDispatchRegionCandidates().stream()
.filter(candidate -> allowedPairKeys.contains(
pairKey(candidate.getFieldMemberId(), candidate.getExternalMemberId())))
.toList())
.assignmentCandidates(candidates.getAssignmentCandidates().stream()
.filter(candidate -> allowedPairKeys.contains(
pairKey(candidate.getFieldMemberId(), candidate.getExternalMemberId())))
.toList())
.unassignedCenterReasons(candidates.getUnassignedCenterReasons())
.build();
}
private boolean isAllowedPair(String fieldMemberId, String externalMemberId,
Map<String, Set<String>> counterpartsByMember) {
return isAllowedCounterpart(fieldMemberId, externalMemberId, counterpartsByMember)
&& isAllowedCounterpart(externalMemberId, fieldMemberId, counterpartsByMember);
}
private boolean isAllowedCounterpart(String memberId, String counterpartId,
Map<String, Set<String>> counterpartsByMember) {
Set<String> counterparts = counterpartsByMember.getOrDefault(memberId, Set.of());
return counterparts.contains(counterpartId)
|| counterparts.size() < maxCounterpartsPerMember();
}
private void addCounterparts(Map<String, Set<String>> counterpartsByMember,
List<AssignmentCandidate> assignments) {
for (AssignmentCandidate assignment : assignments) {
counterpartsByMember.computeIfAbsent(assignment.getFieldMemberId(), key -> new HashSet<>())
.add(assignment.getExternalMemberId());
counterpartsByMember.computeIfAbsent(assignment.getExternalMemberId(), key -> new HashSet<>())
.add(assignment.getFieldMemberId());
}
}
private Map<String, Integer> createInitialVisitCounts(List<Member> members) {
return members.stream()
.collect(Collectors.toMap(Member::getId, member -> 0, (left, right) -> left));
}
private Set<String> mandatoryUnusedMemberIds(PairingCandidates candidates,
Map<String, Integer> visitCountsByMember) {
return visitCountsByMember.entrySet().stream()
.filter(entry -> entry.getValue() == 0)
.map(Map.Entry::getKey)
.collect(Collectors.toSet());
}
private void addVisitCounts(Map<String, Integer> visitCountsByMember,
List<AssignmentCandidate> assignments) {
for (AssignmentCandidate assignment : assignments) {
visitCountsByMember.merge(assignment.getFieldMemberId(), 1, Integer::sum);
visitCountsByMember.merge(assignment.getExternalMemberId(), 1, Integer::sum);
}
}
private List<AssignmentCandidate> filterSelectedByCounterpartLimit(
List<AssignmentCandidate> selectedAssignments,
Map<String, Set<String>> counterpartsByMember) {
Map<String, Set<String>> simulatedCounterparts = copyCounterparts(counterpartsByMember);
List<AssignmentCandidate> allowedAssignments = new ArrayList<>();
for (AssignmentCandidate assignment : selectedAssignments) {
if (isAllowedPair(assignment.getFieldMemberId(), assignment.getExternalMemberId(),
simulatedCounterparts)) {
allowedAssignments.add(assignment);
simulatedCounterparts.computeIfAbsent(assignment.getFieldMemberId(), key -> new HashSet<>())
.add(assignment.getExternalMemberId());
simulatedCounterparts.computeIfAbsent(assignment.getExternalMemberId(), key -> new HashSet<>())
.add(assignment.getFieldMemberId());
}
}
return allowedAssignments;
}
private Map<String, Set<String>> copyCounterparts(Map<String, Set<String>> source) {
Map<String, Set<String>> copied = new HashMap<>();
source.forEach((memberId, counterparts) -> copied.put(memberId, new HashSet<>(counterparts)));
return copied;
}
private String pairKey(PairCandidate pairCandidate) {
return pairKey(pairCandidate.getFieldMemberId(), pairCandidate.getExternalMemberId());
}
private String pairKey(String fieldMemberId, String externalMemberId) {
return fieldMemberId + "|" + externalMemberId;
}
private int maxCounterpartsPerMember() {
return pairingProperties.getRule().getMaxCounterpartsPerMember();
}
private Member copyMemberWithBlockedDates(Member member, Set<LocalDate> additionalDates) {
if (additionalDates.isEmpty()) {
return member;
}
Set<LocalDate> unavailableDates = new LinkedHashSet<>(member.getUnavailableDates());
unavailableDates.addAll(additionalDates);
return Member.builder()
.id(member.getId())
.gender(member.getGender())
.experienceType(member.getExperienceType())
.role(member.getRole())
.availableStartDate(member.getAvailableStartDate())
.availableEndDate(member.getAvailableEndDate())
.unavailableDates(unavailableDates)
.activityRegion(member.getActivityRegion())
.historyCenterIds(member.getHistoryCenterIds())
.residenceCode(member.getResidenceCode())
.preferenceRegions(member.getPreferenceRegions())
.build();
}
private PairingCandidates mergeCandidates(List<PairingCandidates> roundCandidates) {
Map<String, Set<String>> reasons = new LinkedHashMap<>();
roundCandidates.stream()
.map(PairingCandidates::getUnassignedCenterReasons)
.forEach(reasonMap -> reasonMap.forEach((centerId, centerReasons) ->
reasons.computeIfAbsent(centerId, key -> new LinkedHashSet<>()).addAll(centerReasons)));
return PairingCandidates.builder()
.pairCandidates(roundCandidates.stream()
.flatMap(candidates -> candidates.getPairCandidates().stream())
.toList())
.dispatchRegionCandidates(roundCandidates.stream()
.flatMap(candidates -> candidates.getDispatchRegionCandidates().stream())
.toList())
.assignmentCandidates(roundCandidates.stream()
.flatMap(candidates -> candidates.getAssignmentCandidates().stream())
.toList())
.unassignedCenterReasons(reasons)
.build();
}
private String stopReason(int round, List<Center> remainingCenters, String stopReason) {
if (remainingCenters.isEmpty()) {
return "SCHEDULE_COMPLETED";
}
return "SCHEDULE_STOPPED round=" + round + ", remainingCenters=" + remainingCenters.size()
+ ", reason=" + stopReason;
}
private PairingResult appendScheduleSummaries(PairingResult result, int round,
int originalCenterCount, int remainingCenterCount) {
List<PairingSummaryExcelDto> summaries = new ArrayList<>(result.getSummaries());
summaries.add(new PairingSummaryExcelDto("스케줄링 라운드 수", String.valueOf(round)));
summaries.add(new PairingSummaryExcelDto("스케줄링 시작 센터 수", String.valueOf(originalCenterCount)));
summaries.add(new PairingSummaryExcelDto("스케줄링 잔여 센터 수", String.valueOf(remainingCenterCount)));
List<CandidateSummaryExcelDto> candidateSummaries = new ArrayList<>(
result.getCandidateSummaries());
candidateSummaries.add(new CandidateSummaryExcelDto("스케줄링 라운드 수",
String.valueOf(round), "배정 후 위원 불가일과 잔여 센터를 갱신한 반복 횟수"));
return PairingResult.builder()
.assignments(result.getAssignments())
.unassignedCenters(result.getUnassignedCenters())
.unusedMembers(result.getUnusedMembers())
.summaries(summaries)
.abPairs(result.getAbPairs())
.candidateSummaries(candidateSummaries)
.validationErrors(result.getValidationErrors())
.ruleViolations(result.getRuleViolations())
.build();
}
}

View File

@@ -1,8 +1,8 @@
package com.kri.p6.ncrc.pairing.service; package com.kri.p6.ncrc.pairing.service;
import com.kri.p6.ncrc.pairing.dto.excel.input.PairingWorkbookData; import com.kri.p6.ncrc.pairing.dto.excel.input.PairingWorkbookData;
import com.kri.p6.ncrc.pairing.model.NewPairingResult;
import com.kri.p6.ncrc.pairing.model.PairingData; import com.kri.p6.ncrc.pairing.model.PairingData;
import com.kri.p6.ncrc.pairing.model.PairingResult;
import lombok.RequiredArgsConstructor; import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Service; import org.springframework.stereotype.Service;
import org.springframework.web.multipart.MultipartFile; import org.springframework.web.multipart.MultipartFile;
@@ -15,14 +15,14 @@ public class PairingService {
private final PairingNormalizeService pairingNormalizeService; private final PairingNormalizeService pairingNormalizeService;
private final PairingHolidayService pairingHolidayService; private final PairingHolidayService pairingHolidayService;
private final PairingValidationService pairingValidationService; private final PairingValidationService pairingValidationService;
private final PairingScheduleService pairingScheduleService; private final PairingNewService pairingNewService;
public byte[] pairingMemberByCenter(MultipartFile file) { public byte[] pairingMemberByCenterNew(MultipartFile file) {
PairingWorkbookData workbookData = pairingExcelService.read(file); PairingWorkbookData workbookData = pairingExcelService.read(file);
PairingData pairingData = pairingNormalizeService.normalize(workbookData); PairingData pairingData = pairingNormalizeService.normalize(workbookData);
pairingData = pairingHolidayService.applyHolidayUnavailableDates(pairingData); pairingData = pairingHolidayService.applyHolidayUnavailableDates(pairingData);
pairingValidationService.validate(pairingData); pairingValidationService.validate(pairingData);
PairingResult result = pairingScheduleService.schedule(pairingData); NewPairingResult result = pairingNewService.pair(pairingData);
return pairingExcelService.write(result); return pairingExcelService.writeNew(result);
} }
} }

View File

@@ -1,742 +0,0 @@
package com.kri.p6.ncrc.pairing.service;
import com.google.ortools.Loader;
import com.google.ortools.sat.BoolVar;
import com.google.ortools.sat.CpModel;
import com.google.ortools.sat.CpSolver;
import com.google.ortools.sat.CpSolverStatus;
import com.google.ortools.sat.LinearArgument;
import com.google.ortools.sat.LinearExpr;
import com.kri.p6.ncrc.pairing.common.enums.ExperienceType;
import com.kri.p6.ncrc.pairing.common.enums.Gender;
import com.kri.p6.ncrc.pairing.config.PairingProperties;
import com.kri.p6.ncrc.pairing.dto.excel.output.ABPairExcelDto;
import com.kri.p6.ncrc.pairing.dto.excel.output.AssignmentResultExcelDto;
import com.kri.p6.ncrc.pairing.dto.excel.output.CandidateSummaryExcelDto;
import com.kri.p6.ncrc.pairing.dto.excel.output.PairingSummaryExcelDto;
import com.kri.p6.ncrc.pairing.dto.excel.output.RuleViolationExcelDto;
import com.kri.p6.ncrc.pairing.dto.excel.output.UnassignedCenterExcelDto;
import com.kri.p6.ncrc.pairing.dto.excel.output.UnusedMemberExcelDto;
import com.kri.p6.ncrc.pairing.model.ABPairMatch;
import com.kri.p6.ncrc.pairing.model.AssignmentCandidate;
import com.kri.p6.ncrc.pairing.model.Center;
import com.kri.p6.ncrc.pairing.model.Member;
import com.kri.p6.ncrc.pairing.model.PairingCandidates;
import com.kri.p6.ncrc.pairing.model.PairingData;
import com.kri.p6.ncrc.pairing.model.PairingResult;
import java.time.LocalDate;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Comparator;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.Set;
import java.util.function.Function;
import java.util.stream.Collectors;
import java.util.stream.Stream;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Service;
@Service
@RequiredArgsConstructor
public class PairingSolverService {
private final PairingProperties pairingProperties;
public PairingResult solve(PairingData data, PairingCandidates candidates) {
SolveSelection selection = select(candidates);
if (!selection.hasSolution()) {
return emptyResult(data, candidates, selection.status());
}
return toResult(data, candidates, selection.selectedAssignments(), selection.status());
}
public SolveSelection select(PairingCandidates candidates) {
return select(candidates, Map.of());
}
public SolveSelection select(PairingCandidates candidates,
Map<String, Set<String>> existingCounterpartsByMember) {
return select(candidates, existingCounterpartsByMember, Map.of(), Set.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) {
if (candidates.getAssignmentCandidates().isEmpty()) {
return new SolveSelection(false, List.of(), "배정 가능한 후보가 없습니다.");
}
CpModel model = new CpModel();
List<AssignmentCandidate> assignmentCandidates = candidates.getAssignmentCandidates();
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));
}
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));
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());
}
public PairingResult buildResult(PairingData data, PairingCandidates candidates,
List<AssignmentCandidate> selectedAssignments, String status) {
return toResult(data, candidates, selectedAssignments, status);
}
private BoolVar[] createAssignmentVars(CpModel model, List<AssignmentCandidate> candidates) {
BoolVar[] vars = new BoolVar[candidates.size()];
for (int i = 0; i < candidates.size(); i++) {
vars[i] = model.newBoolVar("assign_" + i + "_" + candidates.get(i).getCenterId());
}
return vars;
}
private Map<String, BoolVar> createPairUsedVars(CpModel model, List<AssignmentCandidate> candidates) {
return candidates.stream().map(this::pairKey).distinct()
.collect(Collectors.toMap(Function.identity(), key -> model.newBoolVar("pair_used_" + key)));
}
private Map<String, BoolVar> createPairDayVars(CpModel model, List<AssignmentCandidate> candidates) {
return candidates.stream().map(this::pairDayKey).distinct()
.collect(Collectors.toMap(Function.identity(), key -> model.newBoolVar("pair_day_" + key)));
}
private Map<String, BoolVar> createPairDayAdjacentVars(CpModel model, List<AssignmentCandidate> candidates) {
return candidates.stream().map(this::pairDayAdjacentKey).distinct()
.collect(Collectors.toMap(Function.identity(), key -> model.newBoolVar("pair_day_adjacent_" + key)));
}
private 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) {
for (int i = 0; i < candidates.size(); i++) {
AssignmentCandidate candidate = candidates.get(i);
model.addLessOrEqual(assignmentVars[i], pairUsedVars.get(pairKey(candidate)));
model.addLessOrEqual(assignmentVars[i], pairDayVars.get(pairDayKey(candidate)));
model.addLessOrEqual(assignmentVars[i], pairDayAdjacentVars.get(pairDayAdjacentKey(candidate)));
}
}
private void 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) {
groupIndexes(candidates, AssignmentCandidate::getCenterId).values()
.forEach(indexes -> model.addAtMostOne(toLiteralArray(indexes, assignmentVars)));
}
private void addPairDailyCapacity(CpModel model, List<AssignmentCandidate> candidates,
BoolVar[] assignmentVars) {
groupIndexes(candidates, this::pairDayKey).values().forEach(indexes -> model.addLessOrEqual(
LinearExpr.sum(toLinearArgumentArray(indexes, assignmentVars)),
pairingProperties.getRule().getMaxCentersPerPairPerDay()));
}
private void addMemberDailyOnePair(CpModel model, List<AssignmentCandidate> candidates,
Map<String, BoolVar> pairDayVars) {
Map<String, Set<String>> pairDayKeysByMemberDay = candidates.stream()
.collect(Collectors.groupingBy(candidate -> candidate.getFieldMemberId() + "|" + candidate.getDate(),
Collectors.mapping(this::pairDayKey, Collectors.toSet())));
Map<String, Set<String>> externalPairDayKeysByMemberDay = candidates.stream()
.collect(Collectors.groupingBy(candidate -> candidate.getExternalMemberId() + "|" + candidate.getDate(),
Collectors.mapping(this::pairDayKey, Collectors.toSet())));
externalPairDayKeysByMemberDay.forEach((key, value) -> pairDayKeysByMemberDay.merge(key, value, (left, right) -> {
left.addAll(right);
return left;
}));
pairDayKeysByMemberDay.values().forEach(pairDayKeys ->
model.addAtMostOne(pairDayKeys.stream().map(pairDayVars::get).toArray(BoolVar[]::new)));
}
private void addPairDailyOneAdjacentClassification(CpModel model,
List<AssignmentCandidate> candidates, Map<String, BoolVar> pairDayAdjacentVars) {
Map<String, Set<String>> adjacentKeysByPairDay = candidates.stream()
.collect(Collectors.groupingBy(this::pairDayKey,
Collectors.mapping(this::pairDayAdjacentKey, Collectors.toSet())));
adjacentKeysByPairDay.values().forEach(adjacentKeys ->
model.addAtMostOne(adjacentKeys.stream().map(pairDayAdjacentVars::get).toArray(BoolVar[]::new)));
}
private void addCumulativeBuddyLimit(CpModel model, List<AssignmentCandidate> candidates,
Map<String, BoolVar> pairUsedVars, Map<String, Set<String>> existingCounterpartsByMember) {
Map<String, Set<String>> pairKeysByMember = candidates.stream()
.collect(Collectors.groupingBy(AssignmentCandidate::getFieldMemberId,
Collectors.mapping(this::pairKey, Collectors.toSet())));
Map<String, Set<String>> externalPairKeysByMember = candidates.stream()
.collect(Collectors.groupingBy(AssignmentCandidate::getExternalMemberId,
Collectors.mapping(this::pairKey, Collectors.toSet())));
externalPairKeysByMember.forEach((key, value) -> pairKeysByMember.merge(key, value, (left, right) -> {
left.addAll(right);
return left;
}));
pairKeysByMember.forEach((memberId, pairKeys) -> {
Set<String> existingCounterparts = existingCounterpartsByMember.getOrDefault(memberId,
Set.of());
List<BoolVar> newCounterpartVars = pairKeys.stream()
.filter(pairKey -> !existingCounterparts.contains(counterpartId(pairKey, memberId)))
.map(pairUsedVars::get)
.toList();
if (newCounterpartVars.isEmpty()) {
return;
}
int remainingNewCounterpartSlots = Math.max(0,
pairingProperties.getRule().getMaxCounterpartsPerMember() - existingCounterparts.size());
model.addLessOrEqual(
LinearExpr.sum(newCounterpartVars.toArray(LinearArgument[]::new)),
remainingNewCounterpartSlots);
});
}
private LinearExpr createObjective(List<AssignmentCandidate> candidates,
BoolVar[] assignmentVars, Map<String, BoolVar> memberUsedVars,
Map<String, Integer> visitCountsByMember) {
List<LinearArgument> vars = new ArrayList<>();
List<Long> weights = new ArrayList<>();
for (int i = 0; i < assignmentVars.length; i++) {
AssignmentCandidate candidate = candidates.get(i);
vars.add(assignmentVars[i]);
weights.add(pairingProperties.getObjective().getAssignmentWeight()
+ Math.max(0L, pairingProperties.getObjective().getPreferenceBaseWeight()
- candidate.getPreferencePriority() * pairingProperties.getObjective().getPreferenceRankPenalty())
+ candidate.getResidenceMatchScore() * pairingProperties.getObjective().getResidenceMatchWeight()
- memberBalancePenalty(candidate, visitCountsByMember));
}
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());
}
private long memberBalancePenalty(AssignmentCandidate candidate,
Map<String, Integer> visitCountsByMember) {
return (long) (visitCountsByMember.getOrDefault(candidate.getFieldMemberId(), 0)
+ visitCountsByMember.getOrDefault(candidate.getExternalMemberId(), 0))
* pairingProperties.getObjective().getMemberBalanceWeight();
}
private List<AssignmentCandidate> collectSelectedAssignments(List<AssignmentCandidate> candidates,
BoolVar[] assignmentVars, CpSolver solver) {
List<AssignmentCandidate> selected = new ArrayList<>();
for (int i = 0; i < candidates.size(); i++) {
if (solver.booleanValue(assignmentVars[i])) {
selected.add(candidates.get(i));
}
}
selected.sort(Comparator.comparing(AssignmentCandidate::getDate)
.thenComparing(AssignmentCandidate::getFieldMemberId)
.thenComparing(AssignmentCandidate::getCenterId));
return selected;
}
private PairingResult toResult(PairingData data, PairingCandidates candidates,
List<AssignmentCandidate> selectedAssignments, String status) {
Set<String> 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());
Map<String, Member> memberMap = data.getMembers().stream()
.collect(Collectors.toMap(Member::getId, Function.identity(), (left, right) -> left));
Map<String, Center> centerMap = data.getCenters().stream()
.collect(Collectors.toMap(Center::getId, Function.identity(), (left, right) -> left));
ABPairBuildResult abPairBuildResult = createABPairMatches(selectedAssignments);
Map<String, ABPairMatch> abPairMatches = abPairBuildResult.matches();
List<AssignmentResultExcelDto> assignments = selectedAssignments.stream()
.map(candidate -> toAssignmentResult(candidate, memberMap, centerMap, abPairMatches))
.toList();
List<UnassignedCenterExcelDto> unassignedCenters = data.getCenters().stream()
.filter(center -> !assignedCenterIds.contains(center.getId()))
.map(center -> toUnassignedCenter(center, candidates.getUnassignedCenterReasons()))
.toList();
List<UnusedMemberExcelDto> unusedMembers = data.getMembers().stream()
.filter(member -> !usedMemberIds.contains(member.getId()))
.map(member -> new UnusedMemberExcelDto(member.getId(), member.getRole().name(),
"최종 배정에 포함되지 않았습니다. 후보 부족 또는 제약 충돌 가능"))
.toList();
return PairingResult.builder()
.assignments(assignments)
.unassignedCenters(unassignedCenters)
.unusedMembers(unusedMembers)
.summaries(createSummaries(data, candidates, assignments.size(), unassignedCenters.size(),
unusedMembers.size(), countABGroups(abPairMatches), status))
.abPairs(abPairBuildResult.rows())
.candidateSummaries(createCandidateSummaries(data, candidates, assignments.size(),
unassignedCenters.size(), unusedMembers.size(), countABGroups(abPairMatches)))
.validationErrors(List.of())
.ruleViolations(createRuleChecks(data, selectedAssignments, abPairMatches))
.build();
}
private PairingResult emptyResult(PairingData data, PairingCandidates candidates, String reason) {
return PairingResult.builder()
.assignments(List.of())
.unassignedCenters(data.getCenters().stream()
.map(center -> new UnassignedCenterExcelDto(center.getId(), center.getMunicipalityId(), reason))
.toList())
.unusedMembers(data.getMembers().stream()
.map(member -> new UnusedMemberExcelDto(member.getId(), member.getRole().name(), reason))
.toList())
.summaries(createSummaries(data, candidates, 0, data.getCenters().size(), data.getMembers().size(), 0, reason))
.abPairs(List.of())
.candidateSummaries(createCandidateSummaries(data, candidates, 0, data.getCenters().size(), data.getMembers().size(), 0))
.validationErrors(List.of())
.ruleViolations(List.of(new RuleViolationExcelDto("solver feasible 해", "FAIL", reason)))
.build();
}
private AssignmentResultExcelDto toAssignmentResult(AssignmentCandidate candidate,
Map<String, Member> memberMap, Map<String, Center> centerMap,
Map<String, ABPairMatch> abPairMatches) {
Member fieldMember = memberMap.get(candidate.getFieldMemberId());
Member externalMember = memberMap.get(candidate.getExternalMemberId());
Center center = centerMap.get(candidate.getCenterId());
ABPairMatch abPairMatch = abPairMatches.get(pairKey(candidate));
return new AssignmentResultExcelDto(candidate.getDate().toString(),
candidate.getFieldMemberId(), formatGender(fieldMember.getGender()),
formatExperience(fieldMember.getExperienceType()), fieldMember.getResidenceCode(),
fieldMember.getActivityRegion(), formatPreferenceRank(candidate.getFieldMemberPreferenceRank()),
candidate.getExternalMemberId(), formatGender(externalMember.getGender()),
formatExperience(externalMember.getExperienceType()), externalMember.getResidenceCode(),
externalMember.getActivityRegion(), formatPreferenceRank(candidate.getExternalMemberPreferenceRank()),
candidate.getCenterId(), candidate.getMunicipalityId(), center.isWomenOnly() ? "1" : "0",
candidate.getDispatchRegion(), candidate.getAdjacentRegionClassification(),
String.valueOf(candidate.getPreferencePriority()),
abPairMatch == null ? "" : abPairMatch.getGroupId(),
abPairMatch == null ? "" : abPairMatch.getCounterpartFieldMemberId(),
abPairMatch == null ? "" : abPairMatch.getCounterpartExternalMemberId());
}
private UnassignedCenterExcelDto toUnassignedCenter(Center center, Map<String, Set<String>> reasonMap) {
Set<String> reasons = new LinkedHashSet<>((Collection<String>) (reasonMap == null ? Set.of()
: reasonMap.getOrDefault(center.getId(), Set.of())));
reasons.add("solver 최적화에서 선택되지 않음");
return new UnassignedCenterExcelDto(center.getId(), center.getMunicipalityId(), String.join(", ", reasons));
}
private String formatGender(Gender gender) {
return gender == Gender.FEMALE ? "여" : "남";
}
private String formatExperience(ExperienceType experienceType) {
return experienceType == ExperienceType.EXPERIENCED ? "경력" : "신규";
}
private String formatPreferenceRank(int rank) {
if (rank == 0) {
return "00";
}
return rank == 99 ? "99" : String.valueOf(rank);
}
private List<PairingSummaryExcelDto> createSummaries(PairingData data,
PairingCandidates candidates, int assignmentCount, int unassignedCenterCount,
int unusedMemberCount, int abGroupCount, String status) {
return List.of(
new PairingSummaryExcelDto("위원 수", String.valueOf(data.getMembers().size())),
new PairingSummaryExcelDto("지자체 수", String.valueOf(data.getMunicipalities().size())),
new PairingSummaryExcelDto("센터 수", String.valueOf(data.getCenters().size())),
new PairingSummaryExcelDto("페어 후보 수", String.valueOf(candidates.getPairCandidates().size())),
new PairingSummaryExcelDto("파견 권역 후보 수", String.valueOf(candidates.getDispatchRegionCandidates().size())),
new PairingSummaryExcelDto("배정 후보 수", String.valueOf(candidates.getAssignmentCandidates().size())),
new PairingSummaryExcelDto("배정 센터 수", String.valueOf(assignmentCount)),
new PairingSummaryExcelDto("미배정 센터 수", String.valueOf(unassignedCenterCount)),
new PairingSummaryExcelDto("미사용 위원 수", String.valueOf(unusedMemberCount)),
new PairingSummaryExcelDto("AB 그룹 수", String.valueOf(abGroupCount)),
new PairingSummaryExcelDto("처리 상태", status));
}
private ABPairBuildResult createABPairMatches(List<AssignmentCandidate> selectedAssignments) {
Map<String, List<AssignmentCandidate>> assignmentsByPair = selectedAssignments.stream()
.collect(Collectors.groupingBy(this::pairKey));
List<UsedPair> usedPairs = assignmentsByPair.entrySet().stream()
.map(entry -> UsedPair.of(entry.getKey(), entry.getValue()))
.sorted(Comparator.comparing(UsedPair::pairKey))
.toList();
Map<String, ABPairMatch> matches = new HashMap<>();
List<ABPairExcelDto> rows = new ArrayList<>();
Set<String> alreadyMatched = new HashSet<>();
int groupSequence = 1;
for (UsedPair pair : usedPairs) {
if (alreadyMatched.contains(pair.pairKey())) {
continue;
}
UsedPair counterpart = usedPairs.stream()
.filter(candidate -> !alreadyMatched.contains(candidate.pairKey()))
.filter(candidate -> !candidate.pairKey().equals(pair.pairKey()))
.filter(pair::canBeABWith)
.findFirst()
.orElse(null);
if (counterpart == null) {
continue;
}
String groupId = "AB-" + String.format("%03d", groupSequence++);
matches.put(pair.pairKey(), toABPairMatch(groupId, pair, counterpart));
matches.put(counterpart.pairKey(), toABPairMatch(groupId, counterpart, pair));
rows.add(toABPairRow(groupId, pair, counterpart));
alreadyMatched.add(pair.pairKey());
alreadyMatched.add(counterpart.pairKey());
}
return new ABPairBuildResult(matches, rows);
}
private ABPairMatch toABPairMatch(String groupId, UsedPair pair, UsedPair counterpart) {
return ABPairMatch.builder()
.groupId(groupId)
.fieldMemberId(pair.fieldMemberId())
.externalMemberId(pair.externalMemberId())
.counterpartFieldMemberId(counterpart.fieldMemberId())
.counterpartExternalMemberId(counterpart.externalMemberId())
.build();
}
private int countABGroups(Map<String, ABPairMatch> matches) {
return (int) matches.values().stream().map(ABPairMatch::getGroupId).distinct().count();
}
private ABPairExcelDto toABPairRow(String groupId, UsedPair pair, UsedPair counterpart) {
Set<String> counterpartDispatchRegions = counterpart.dispatchRegions();
String sharedDispatchRegion = pair.dispatchRegions().stream()
.filter(counterpartDispatchRegions::contains)
.sorted()
.findFirst()
.orElse("");
boolean dateOverlapped = pair.dates().stream().anyMatch(counterpart.dates()::contains);
return new ABPairExcelDto(groupId, pair.fieldMemberId(), pair.externalMemberId(),
counterpart.fieldMemberId(), counterpart.externalMemberId(), sharedDispatchRegion,
formatDates(pair.dates()), formatDates(counterpart.dates()), dateOverlapped ? "Y" : "N");
}
private List<CandidateSummaryExcelDto> createCandidateSummaries(PairingData data,
PairingCandidates candidates, int assignmentCount, int unassignedCenterCount,
int unusedMemberCount, int abGroupCount) {
long fieldMemberCount = data.getMembers().stream().filter(member -> member.getRole().name().equals("FIELD")).count();
long externalMemberCount = data.getMembers().stream().filter(member -> member.getRole().name().equals("EXTERNAL")).count();
long womenOnlyCenterCount = data.getCenters().stream().filter(Center::isWomenOnly).count();
long noCandidateCenterCount = data.getCenters().stream()
.filter(center -> candidates.getAssignmentCandidates().stream()
.noneMatch(candidate -> candidate.getCenterId().equals(center.getId())))
.count();
return List.of(
new CandidateSummaryExcelDto("전체 위원 수", String.valueOf(data.getMembers().size()), "입력 위원 수"),
new CandidateSummaryExcelDto("현장위원 수", String.valueOf(fieldMemberCount), "현장위원 입력 수"),
new CandidateSummaryExcelDto("외부위원 수", String.valueOf(externalMemberCount), "외부위원 입력 수"),
new CandidateSummaryExcelDto("센터 수", String.valueOf(data.getCenters().size()), "입력 센터 수"),
new CandidateSummaryExcelDto("여성 전용 센터 수", String.valueOf(womenOnlyCenterCount), "여성 위원만 가능한 센터 수"),
new CandidateSummaryExcelDto("공통 불가일 수", String.valueOf(commonUnavailableDates(data).size()), "배정 제외 공통 불가능 일자 수"),
new CandidateSummaryExcelDto("페어 후보 수", String.valueOf(candidates.getPairCandidates().size()), "현장+외부 조합 후보 수"),
new CandidateSummaryExcelDto("파견 권역 후보 수", String.valueOf(candidates.getDispatchRegionCandidates().size()), "페어별 파견 권역 후보 수"),
new CandidateSummaryExcelDto("배정 후보 수", String.valueOf(candidates.getAssignmentCandidates().size()), "solver 입력 배정 후보 수"),
new CandidateSummaryExcelDto("후보 없는 센터 수", String.valueOf(noCandidateCenterCount), "배정 후보가 하나도 없는 센터 수"),
new CandidateSummaryExcelDto("배정 센터 수", String.valueOf(assignmentCount), "최종 배정된 센터 수"),
new CandidateSummaryExcelDto("미배정 센터 수", String.valueOf(unassignedCenterCount), "최종 미배정 센터 수"),
new CandidateSummaryExcelDto("미사용 위원 수", String.valueOf(unusedMemberCount), "최종 배정에 포함되지 않은 위원 수"),
new CandidateSummaryExcelDto("AB 그룹 수", String.valueOf(abGroupCount), "후처리로 구성된 AB 그룹 수"));
}
private List<RuleViolationExcelDto> createRuleChecks(PairingData data,
List<AssignmentCandidate> selectedAssignments, Map<String, ABPairMatch> abPairMatches) {
Map<String, Member> memberMap = data.getMembers().stream()
.collect(Collectors.toMap(Member::getId, Function.identity(), (left, right) -> left));
Map<String, Center> centerMap = data.getCenters().stream()
.collect(Collectors.toMap(Center::getId, Function.identity(), (left, right) -> left));
List<RuleViolationExcelDto> checks = new ArrayList<>();
checks.add(checkDuplicate(selectedAssignments.stream().map(AssignmentCandidate::getCenterId).toList(), "센터 1회 초과 배정"));
checks.add(checkMaxGroupCount(selectedAssignments, this::pairDayKey,
pairingProperties.getRule().getMaxCentersPerPairPerDay(), "페어 하루 최대 센터 수"));
checks.add(checkMemberDateDuplicate(selectedAssignments));
checks.add(checkPairDayAdjacentClassification(selectedAssignments));
checks.add(checkWomenOnly(selectedAssignments, memberMap, centerMap));
checks.add(checkActivityRegion(selectedAssignments, memberMap));
checks.add(checkHistoryCenter(selectedAssignments, memberMap));
checks.add(checkHoliday(selectedAssignments, commonUnavailableDates(data)));
checks.add(checkABDateOverlap(abPairMatches));
checks.add(checkAllMembersUsed(data, selectedAssignments));
checks.add(checkMemberVisitBalance(data, selectedAssignments));
return checks;
}
private RuleViolationExcelDto checkDuplicate(List<String> values, String ruleName) {
Set<String> seen = new HashSet<>();
Set<String> duplicates = values.stream().filter(value -> !seen.add(value))
.collect(Collectors.toCollection(LinkedHashSet::new));
return new RuleViolationExcelDto(ruleName, duplicates.isEmpty() ? "PASS" : "FAIL",
duplicates.isEmpty() ? "위반 없음" : String.join(", ", duplicates));
}
private RuleViolationExcelDto checkMaxGroupCount(List<AssignmentCandidate> assignments,
Function<AssignmentCandidate, String> classifier, int max, String ruleName) {
Map<String, Long> countsByKey = assignments.stream().collect(Collectors.groupingBy(classifier, Collectors.counting()));
List<String> violations = countsByKey.entrySet().stream()
.filter(entry -> entry.getValue() > max)
.map(entry -> entry.getKey() + "=" + entry.getValue())
.toList();
return new RuleViolationExcelDto(ruleName, violations.isEmpty() ? "PASS" : "FAIL",
violations.isEmpty() ? "위반 없음" : String.join(", ", violations));
}
private RuleViolationExcelDto checkMemberDateDuplicate(List<AssignmentCandidate> assignments) {
Map<String, Set<String>> pairKeysByMemberDate = new HashMap<>();
assignments.forEach(candidate -> {
pairKeysByMemberDate.computeIfAbsent(candidate.getFieldMemberId() + "|" + candidate.getDate(), key -> new HashSet<>()).add(pairKey(candidate));
pairKeysByMemberDate.computeIfAbsent(candidate.getExternalMemberId() + "|" + candidate.getDate(), key -> new HashSet<>()).add(pairKey(candidate));
});
List<String> violations = pairKeysByMemberDate.entrySet().stream()
.filter(entry -> entry.getValue().size() > 1)
.map(entry -> entry.getKey() + "=" + String.join("/", entry.getValue()))
.toList();
return new RuleViolationExcelDto("같은 위원 같은 날짜 중복", violations.isEmpty() ? "PASS" : "FAIL",
violations.isEmpty() ? "위반 없음" : String.join(", ", violations));
}
private RuleViolationExcelDto checkPairDayAdjacentClassification(List<AssignmentCandidate> assignments) {
Map<String, Set<String>> adjacentClassificationsByPairDay = assignments.stream()
.collect(Collectors.groupingBy(this::pairDayKey,
Collectors.mapping(AssignmentCandidate::getAdjacentRegionClassification, Collectors.toSet())));
List<String> violations = adjacentClassificationsByPairDay.entrySet().stream()
.filter(entry -> entry.getValue().size() > 1)
.map(entry -> entry.getKey() + "=" + String.join("/", entry.getValue()))
.toList();
return new RuleViolationExcelDto("페어 하루 1개 인접지역분류", violations.isEmpty() ? "PASS" : "FAIL",
violations.isEmpty() ? "위반 없음" : String.join(", ", violations));
}
private RuleViolationExcelDto checkWomenOnly(List<AssignmentCandidate> assignments,
Map<String, Member> memberMap, Map<String, Center> centerMap) {
List<String> violations = assignments.stream()
.filter(candidate -> centerMap.get(candidate.getCenterId()).isWomenOnly())
.filter(candidate -> memberMap.get(candidate.getFieldMemberId()).getGender() != Gender.FEMALE
|| memberMap.get(candidate.getExternalMemberId()).getGender() != Gender.FEMALE)
.map(AssignmentCandidate::getCenterId)
.toList();
return new RuleViolationExcelDto("여성 전용 센터 조건", violations.isEmpty() ? "PASS" : "FAIL",
violations.isEmpty() ? "위반 없음" : String.join(", ", violations));
}
private RuleViolationExcelDto checkActivityRegion(List<AssignmentCandidate> assignments, Map<String, Member> memberMap) {
List<String> violations = assignments.stream()
.filter(candidate -> hasActivityRegion(memberMap.get(candidate.getFieldMemberId()), candidate.getDispatchRegion())
|| hasActivityRegion(memberMap.get(candidate.getExternalMemberId()), candidate.getDispatchRegion()))
.map(candidate -> candidate.getCenterId() + ":" + candidate.getDispatchRegion())
.toList();
return new RuleViolationExcelDto("활동지역 상피제", violations.isEmpty() ? "PASS" : "FAIL",
violations.isEmpty() ? "위반 없음" : String.join(", ", violations));
}
private boolean hasActivityRegion(Member member, String dispatchRegion) {
return java.util.Arrays.stream(member.getActivityRegion().split(",")).map(String::trim).anyMatch(dispatchRegion::equals);
}
private RuleViolationExcelDto checkHistoryCenter(List<AssignmentCandidate> assignments, Map<String, Member> memberMap) {
List<String> violations = assignments.stream()
.filter(candidate -> memberMap.get(candidate.getFieldMemberId()).getHistoryCenterIds().contains(candidate.getCenterId())
|| memberMap.get(candidate.getExternalMemberId()).getHistoryCenterIds().contains(candidate.getCenterId()))
.map(AssignmentCandidate::getCenterId)
.toList();
return new RuleViolationExcelDto("2023년 진행 센터 재배정", violations.isEmpty() ? "PASS" : "FAIL",
violations.isEmpty() ? "위반 없음" : String.join(", ", violations));
}
private RuleViolationExcelDto checkHoliday(List<AssignmentCandidate> assignments, Set<LocalDate> holidays) {
List<String> violations = assignments.stream()
.filter(candidate -> holidays.contains(candidate.getDate()))
.map(candidate -> candidate.getCenterId() + ":" + candidate.getDate())
.toList();
return new RuleViolationExcelDto("공휴일 배정", violations.isEmpty() ? "PASS" : "FAIL",
violations.isEmpty() ? "위반 없음" : String.join(", ", violations));
}
private RuleViolationExcelDto checkABDateOverlap(Map<String, ABPairMatch> abPairMatches) {
return new RuleViolationExcelDto("A/B 페어 날짜 겹침", "PASS", "A/B 그룹은 날짜가 겹치지 않는 페어만 후처리로 생성합니다.");
}
private RuleViolationExcelDto checkAllMembersUsed(PairingData data,
List<AssignmentCandidate> assignments) {
Set<String> usedMemberIds = assignments.stream()
.flatMap(candidate -> Stream.of(candidate.getFieldMemberId(),
candidate.getExternalMemberId()))
.collect(Collectors.toSet());
List<String> unusedMemberIds = data.getMembers().stream()
.map(Member::getId)
.filter(memberId -> !usedMemberIds.contains(memberId))
.toList();
return new RuleViolationExcelDto("위원 전원 조편성", unusedMemberIds.isEmpty() ? "PASS" : "FAIL",
unusedMemberIds.isEmpty() ? "위반 없음" : String.join(", ", unusedMemberIds));
}
private RuleViolationExcelDto checkMemberVisitBalance(PairingData data,
List<AssignmentCandidate> assignments) {
Map<String, Long> visitCounts = data.getMembers().stream()
.collect(Collectors.toMap(Member::getId, member -> 0L, (left, right) -> left));
assignments.forEach(candidate -> {
visitCounts.merge(candidate.getFieldMemberId(), 1L, Long::sum);
visitCounts.merge(candidate.getExternalMemberId(), 1L, Long::sum);
});
long min = visitCounts.values().stream().mapToLong(Long::longValue).min().orElse(0L);
long max = visitCounts.values().stream().mapToLong(Long::longValue).max().orElse(0L);
double average = visitCounts.values().stream().mapToLong(Long::longValue).average().orElse(0.0D);
String detail = "min=" + min + ", max=" + max + ", avg=" + String.format("%.2f", average);
return new RuleViolationExcelDto("위원별 방문 센터 수 균등 배분", "PASS", detail);
}
private String formatDates(Set<LocalDate> dates) {
return dates.stream().sorted().map(LocalDate::toString).collect(Collectors.joining(", "));
}
private Set<LocalDate> commonUnavailableDates(PairingData data) {
return data.getCommonUnavailableDates() == null ? Set.of() : data.getCommonUnavailableDates();
}
private Map<String, List<Integer>> groupIndexes(List<AssignmentCandidate> candidates,
Function<AssignmentCandidate, String> classifier) {
Map<String, List<Integer>> grouped = new HashMap<>();
for (int i = 0; i < candidates.size(); i++) {
grouped.computeIfAbsent(classifier.apply(candidates.get(i)), key -> new ArrayList<>()).add(i);
}
return grouped;
}
private BoolVar[] toLiteralArray(List<Integer> indexes, BoolVar[] assignmentVars) {
return indexes.stream().map(index -> assignmentVars[index]).toArray(BoolVar[]::new);
}
private LinearArgument[] toLinearArgumentArray(List<Integer> indexes, BoolVar[] assignmentVars) {
return indexes.stream().map(index -> assignmentVars[index]).toArray(LinearArgument[]::new);
}
private String pairKey(AssignmentCandidate candidate) {
return candidate.getFieldMemberId() + "|" + candidate.getExternalMemberId();
}
private String counterpartId(String pairKey, String memberId) {
String[] memberIds = pairKey.split("\\|", 2);
if (memberIds.length != 2) {
return "";
}
return memberId.equals(memberIds[0]) ? memberIds[1] : memberIds[0];
}
private String pairDayKey(AssignmentCandidate candidate) {
return pairKey(candidate) + "|" + candidate.getDate();
}
private String pairDayAdjacentKey(AssignmentCandidate candidate) {
return pairDayKey(candidate) + "|" + candidate.getAdjacentRegionClassification();
}
public record SolveSelection(boolean hasSolution, List<AssignmentCandidate> selectedAssignments, String status) {
}
private record ABPairBuildResult(Map<String, ABPairMatch> matches, List<ABPairExcelDto> rows) {
}
private record UsedPair(String pairKey, String fieldMemberId, String externalMemberId,
Set<LocalDate> dates, Set<String> dispatchRegions) {
private static UsedPair of(String pairKey, List<AssignmentCandidate> assignments) {
AssignmentCandidate first = assignments.get(0);
return new UsedPair(pairKey, first.getFieldMemberId(), first.getExternalMemberId(),
assignments.stream().map(AssignmentCandidate::getDate).collect(Collectors.toSet()),
assignments.stream().map(AssignmentCandidate::getDispatchRegion).collect(Collectors.toSet()));
}
private boolean canBeABWith(UsedPair other) {
return dates.stream().noneMatch(other.dates::contains)
&& dispatchRegions.stream().anyMatch(other.dispatchRegions::contains)
&& !Objects.equals(fieldMemberId, other.fieldMemberId)
&& !Objects.equals(fieldMemberId, other.externalMemberId)
&& !Objects.equals(externalMemberId, other.fieldMemberId)
&& !Objects.equals(externalMemberId, other.externalMemberId);
}
}
static {
Loader.loadNativeLibraries();
}
}

View File

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

View File

@@ -4,8 +4,7 @@ server:
spring: spring:
application: application:
name: narc-pairing name: ncrc-pairing
servlet: servlet:
multipart: multipart:
max-file-size: 50MB max-file-size: 50MB
@@ -21,7 +20,7 @@ kri:
security: security:
enabled: true enabled: true
public-paths: # 인증 없이 열어둘 URL public-paths:
- /v3/api-docs/** - /v3/api-docs/**
- /swagger-ui.html - /swagger-ui.html
- /swagger-ui/** - /swagger-ui/**
@@ -30,68 +29,37 @@ kri:
swagger: swagger:
enabled: true enabled: true
allowed-ips:
- 211.254.145.130
- 1.235.195.3
title: "KRI P6 NCRC Pairing API" title: "KRI P6 NCRC Pairing API"
description: "KRI P6 아동관리 보장원 조편성 API" description: "아동권리보장원 조편성 API"
version: "v1.0.0" version: "v1.0.0"
base-package: "com.kri.p6.ncrc.pairing" base-package: "com.kri.p6.ncrc.pairing"
web: web:
enabled: true # 공통 Web 구성 사용 여부 (기본 true) enabled: true
webmvc: webmvc:
enabled: true # 공통 Webmvc 구성 사용 여부 (기본 true) enabled: true
redis: redis:
enabled: false # RedisQueueHelper 사용 시 true enabled: false
scheduling: scheduling:
enabled: false # @Scheduled 사용 시 true enabled: false
pairing: pairing:
excel: excel:
# ExcelMapper에서 헤더가 위치한 행 번호입니다. 공통 라이브러리 기준 1부터 시작합니다.(HARD) # ExcelMapper가 데이터를 읽기 시작하는 헤더 행 번호입니다.
header-row-index: 1 header-row-index: 1
code: code:
# 활동지역, 선호지역, 파견 권역처럼 권역 비교에 사용하는 코드 길이입니다. # 활동지역, 희망지역, 파견권역 코드의 표준 길이입니다.
region-code-length: 2 region-code-length: 2
# 위원 거주지 입력 코드 길이입니다. # 위원 거주지 코드의 표준 길이입니다.
residence-code-length: 5 residence-code-length: 5
# 거주지 유사도 비교 시 앞에서 몇 자리까지 비교할지 정합니다. # 희망지역에서 '어디든 가능'을 의미하는 코드입니다.
residence-match-prefix-length: 3
# 선호지역에서 "어디든 가능"을 의미하는 코드입니다.
any-region-code: "00" any-region-code: "00"
rule:
# 한 페어가 하루에 방문할 수 있는 최대 센터 수입니다. (HARD)
max-centers-per-pair-per-day: 3
# 한 위원이 전체 기간 동안 가질 수 있는 최대 상대 파트너 수입니다.(HARD)
max-counterparts-per-member: 2
preference: preference:
# 선호지역 00(anywhere)을 희망지역 매칭표에서 표현하는 rank 값입니다.(HARD) # 희망지역 00(anywhere)이 희망지역 매칭표에서 표현되는 순위입니다.
anywhere-rank: 0 anywhere-rank: 0
# 희망지역 매칭표에서 해당 위원의 선호지역을 고려하지 않는 wildcard rank 값입니다.(HARD) # 희망지역을 고려하지 않는 wildcard 순위입니다.
ignored-rank: 99 ignored-rank: 99
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
# 희망지역 매칭 순위 점수의 기준값입니다. 값이 클수록 선호지역 품질 영향이 커집니다.
preference-base-weight: 1_000
# 매칭 순위가 1 내려갈 때마다 차감하는 점수입니다. 값이 클수록 낮은 순위를 더 강하게 불리하게 봅니다.
preference-rank-penalty: 100
candidate:
# 현장+외부 페어 1개가 solver에 넘기기 전에 유지할 최대 파견 권역 후보 수입니다.
max-dispatch-regions-per-pair: 20
# 센터 1개마다 solver에 넘기기 전에 유지할 최대 배정 후보 수입니다.
max-assignments-per-center: 100
# 위원 1명(현장/외부 모두 포함)이 solver 후보에 등장할 수 있는 최대 횟수입니다.
max-assignments-per-member: 160
# 페어-센터 후보 1개에서 생성할 최대 가능 날짜 수입니다. 값이 클수록 전원 조편성 가능성은 커지지만 solver 후보 수가 늘어납니다.
max-dates-per-assignment-candidate: 5
solver:
# OR-Tools CP-SAT solver가 한 요청에서 탐색할 최대 시간(초)입니다.
max-time-seconds: 120.0
# OR-Tools CP-SAT 병렬 탐색 worker 수입니다. 서버 CPU 상황에 맞춰 조정합니다.
num-search-workers: 15

Binary file not shown.

View File

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

View File

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

View File

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

View File

@@ -1,83 +0,0 @@
package com.kri.p6.ncrc.pairing.service;
import static com.kri.p6.ncrc.pairing.common.consts.PairingConstant.RESULT_SHEET_AB_PAIR;
import static com.kri.p6.ncrc.pairing.common.consts.PairingConstant.RESULT_SHEET_ASSIGNMENT;
import static com.kri.p6.ncrc.pairing.common.consts.PairingConstant.RESULT_SHEET_CANDIDATE_SUMMARY;
import static com.kri.p6.ncrc.pairing.common.consts.PairingConstant.RESULT_SHEET_RULE_CHECK;
import static com.kri.p6.ncrc.pairing.common.consts.PairingConstant.RESULT_SHEET_SUMMARY;
import static com.kri.p6.ncrc.pairing.common.consts.PairingConstant.RESULT_SHEET_UNASSIGNED_CENTER;
import static com.kri.p6.ncrc.pairing.common.consts.PairingConstant.RESULT_SHEET_UNUSED_MEMBER;
import static com.kri.p6.ncrc.pairing.common.consts.PairingConstant.RESULT_SHEET_VALIDATION_ERROR;
import com.kri.common.feature.excel.ExcelMapper;
import com.kri.p6.ncrc.pairing.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;
import java.io.InputStream;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.List;
import org.apache.poi.ss.usermodel.Workbook;
import org.apache.poi.ss.usermodel.WorkbookFactory;
import org.assertj.core.api.Assertions;
import org.junit.jupiter.api.Test;
import org.springframework.mock.web.MockMultipartFile;
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())
);
@Test
void pairingMemberByCenterCreatesResultWorkbook() throws IOException {
try (InputStream inputStream = getClass().getResourceAsStream("/sample/기초 data TEST.xlsx")) {
MockMultipartFile file = new MockMultipartFile("file", "기초 data TEST.xlsx",
"application/vnd.openxmlformats-officedocument.spreadsheetml.sheet", inputStream);
byte[] result = pairingService.pairingMemberByCenter(file);
Assertions.assertThat(result).isNotEmpty();
Files.createDirectories(Path.of("build"));
Files.write(Files.createTempFile(Path.of("build"), "pairing-result", ".xlsx"), result);
try (Workbook workbook = WorkbookFactory.create(new ByteArrayInputStream(result))) {
Assertions.assertThat(workbook.getSheet(RESULT_SHEET_ASSIGNMENT)).isNotNull();
Assertions.assertThat(workbook.getSheet(RESULT_SHEET_UNASSIGNED_CENTER)).isNotNull();
Assertions.assertThat(workbook.getSheet(RESULT_SHEET_UNUSED_MEMBER)).isNotNull();
Assertions.assertThat(workbook.getSheet(RESULT_SHEET_SUMMARY)).isNotNull();
Assertions.assertThat(workbook.getSheet(RESULT_SHEET_AB_PAIR)).isNotNull();
Assertions.assertThat(workbook.getSheet(RESULT_SHEET_CANDIDATE_SUMMARY)).isNotNull();
Assertions.assertThat(workbook.getSheet(RESULT_SHEET_VALIDATION_ERROR)).isNotNull();
Assertions.assertThat(workbook.getSheet(RESULT_SHEET_RULE_CHECK)).isNotNull();
List<RuleViolationExcelDto> ruleChecks = ExcelMapper.readFromWorkbook(workbook,
RuleViolationExcelDto.class, RESULT_SHEET_RULE_CHECK, 1);
Assertions.assertThat(ruleChecks)
.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();
}
}
}

View File

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

View File

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