# 🔥 Java-Service-Tree-Framework-Engine-Fire

## 프로젝트 기동 가이드

### 1. Github Repository clone
```bash
git clone -b dev https://github.com/313DEVGRP/Java-Service-Tree-Framework-Engine-Fire.git
cd Java-Service-Tree-Framework-Engine-Fire
```

### 2. 환경 설정
- Java 21
- languageVersion = JavaLanguageVersion.of(21)

### 3. 설정 파일 구성

### 프로파일 설정
```bash
-Dspring.profiles.active=dev
```

### 설정 확인 경로
```bash
http://www.313.co.kr:33133/javaServiceTreeFrameworkEngineFire/dev
```

> A-RMS(Requirements Management System)의 핵심 백엔드 엔진 서비스

[![Java](https://img.shields.io/badge/Java-21-orange.svg)](https://openjdk.java.net/)
[![Spring Boot](https://img.shields.io/badge/Spring%20Boot-3.4.4-brightgreen.svg)](https://spring.io/projects/spring-boot)
[![Gradle](https://img.shields.io/badge/Gradle-8.13-blue.svg)](https://gradle.org/)
[![License](https://img.shields.io/badge/License-Proprietary-red.svg)]()

## 📋 목차

- [프로젝트 개요](#-프로젝트-개요)
- [주요 기능](#-주요-기능)
- [기술 스택](#-기술-스택)
- [시스템 아키텍처](#-시스템-아키텍처)
- [프로젝트 구조](#-프로젝트-구조)
- [시작하기](#-시작하기)
- [API 문서](#-api-문서)
- [배포](#-배포)
- [개발 가이드](#-개발-가이드)
- [라이선스](#-라이선스)

---

## 🎯 프로젝트 개요

**Engine-Fire**는 A-RMS의 백엔드 마이크로서비스 중 하나로, ALM(Application Lifecycle Management) 통합, 요구사항 관리, 검색 엔진, 그리고 이슈 트래킹 기능을 제공합니다.

### 핵심 역할

- 🔗 **ALM 통합**: Jira Cloud/Server, Redmine 연동
- 📊 **요구사항 관리**: 계층 구조 기반 요구사항 CRUD
- 🔍 **검색 엔진**: OpenSearch/Elasticsearch 기반 전문 검색
- 📈 **분석 & 대시보드**: 비용/시간/범위/리소스 분석

### 마이크로서비스 아키텍처

```
[Frontend: Java-Service-Tree-Framework-Frontend-Web]
                    ↓
         [Middleware-Proxy (API Gateway)]
            ↙         ↓         ↘
    Backend-Core  Engine-Fire ⭐  Engine-Search
```

---

## ✨ 주요 기능

### 1. 요구사항 관리 (Requirement Management)

- ✅ 계층적 요구사항 구조 관리
- ✅ 버전별/제품별 필터링
- ✅ 담당자별 집계 및 추적
- ✅ 진척도 모니터링
- ✅ 삭제/복구 관리

**주요 API 엔드포인트:**

```http
POST   /engine/jira/dashboard/req-assignees          # 담당자 목록
GET    /engine/reqStatus/reqIssues-created-together  # 묶음 조회
GET    /engine/reqStatus/deletedIssueList            # 삭제 목록
PUT    /engine/reqStatus/deleteWithdrawal            # 삭제 철회
POST   /engine/req-gantt/resolution                  # 간트 차트용 검색
POST   /engine/reqStatus/issue-list-by-updated       # 업데이트 기준 조회
POST   /engine/reqStatus/subtasks-and-linked-issues  # 서브태스크 조회
```

### 2. ALM 이슈 통합

**지원 ALM 시스템:**
- Jira Cloud (Atlassian REST API v3)
- Jira Server/Data Center (Atlassian REST API v2)
- Redmine (Redmine REST API)

**주요 API 엔드포인트:**

```http
POST   /{connectId}/jira/issue                       # 이슈 생성
PUT    /{connectId}/jira/issue/{issueKeyOrId}        # 이슈 수정
PUT    /{connectId}/jira/issue/{issueKeyOrId}/{statusId}  # 상태 변경
DELETE /{connectId}/jira/issue/{issueKeyOrId}        # 이슈 삭제
GET    /{connectId}/jira/issue/{issueKeyOrId}        # 이슈 조회
```

### 3. 검색 엔진

- 🔍 OpenSearch/Elasticsearch 기반 전문 검색
- 📊 집계 쿼리 (Aggregation)
- ⚡ 실시간 인덱싱
- 🔗 커넥션 풀링 및 Keep-Alive 관리

### 4. 분석 & 대시보드

- 📊 **비용 분석** (Cost Analysis)
- ⏱️ **시간 분석** (Time Analysis)
- 📐 **범위 분석** (Scope Analysis)
- 👥 **리소스 분석** (Resource Analysis)
- 📈 **대시보드 데이터** 제공

### 5. 리포트 생성

- 📄 Full Data Report
- 🎯 SWOT Analysis
- 📊 ALM Project Report
- 📅 간트 차트 리포트

---

## 🔧 기술 스택

### 핵심 프레임워크

| 카테고리 | 기술 | 버전 |
|---------|------|------|
| **Language** | Java | 21 |
| **Framework** | Spring Boot | 3.4.4 |
| **Cloud Config** | Spring Cloud Config | 2024.0.1 |
| **Build Tool** | Gradle | 8.13 |
| **Container** | Docker | Latest |

### 주요 라이브러리

#### ALM 통합
```gradle
// Jira REST API Client
implementation 'com.atlassian.jira:jira-rest-java-client-core:5.1.6'
implementation 'com.atlassian.jira:jira-rest-java-client-api:5.1.6'

// Redmine REST API Client
implementation 'com.taskadapter:redmine-java-api:4.0.0.rc4'
```

#### 검색 엔진
```gradle
// OpenSearch
implementation 'org.opensearch.client:spring-data-opensearch:1.6.4'
implementation 'org.opensearch.client:opensearch-rest-client:2.11.0'

// Elasticsearch (Legacy Support)
implementation 'co.elastic.clients:elasticsearch-java:8.11.1'
```

#### HTTP 통신
```gradle
// OpenFeign
implementation 'org.springframework.cloud:spring-cloud-starter-openfeign'
implementation 'io.github.openfeign:feign-hc5'

// Apache HTTP Components
implementation 'org.apache.httpcomponents:httpclient:4.5.14'
```

#### 유틸리티
```gradle
// ModelMapper for DTO-Entity conversion
implementation 'org.modelmapper:modelmapper:3.1.1'

// Lombok
compileOnly 'org.projectlombok:lombok'

// Jackson Joda Time
implementation 'com.fasterxml.jackson.datatype:jackson-datatype-joda:2.12.5'
```

#### 모니터링 & 문서화
```gradle
// Actuator
implementation 'org.springframework.boot:spring-boot-starter-actuator'

// SpringDoc OpenAPI (Swagger)
implementation 'org.springdoc:springdoc-openapi-starter-webmvc-ui:2.1.0'

// Slack API
implementation 'com.slack.api:slack-api-client:1.25.1'
```

---

## 🏗️ 시스템 아키텍처

### 디자인 패턴

#### 1. Strategy Pattern (전략 패턴)
ALM별 구현체를 런타임에 선택

```java
interface AlmStrategy {
    AlmIssue createIssue(AlmIssueDTO dto);
    AlmIssue updateIssue(AlmIssueDTO dto);
    AlmIssue getIssue(String issueKey);
    void deleteIssue(String issueKey);
}

// Jira 구현체
class JiraStrategy implements AlmStrategy { ... }

// Redmine 구현체
class RedmineStrategy implements AlmStrategy { ... }
```

#### 2. DTO-VO-Entity Pattern
계층별 데이터 객체 분리

- **DTO** (Data Transfer Object): API 요청/응답
- **VO** (Value Object): 읽기 전용 값 객체
- **Entity**: 영속성 객체

#### 3. Repository Pattern
OpenSearch/Elasticsearch 추상화

```java
@EnableElasticsearchRepositories(
    basePackages = {"com.arms"},
    repositoryBaseClass = EsCommonRepositoryImpl.class
)
```

#### 4. AOP (Aspect-Oriented Programming)
횡단 관심사 분리

- 로깅
- 트랜잭션 관리
- 예외 처리

---

## 📂 프로젝트 구조

```
src/main/java/com/arms/
├── Application.java                    # 메인 애플리케이션 엔트리포인트
│
├── config/                             # 설정 클래스
│   ├── OpensearchClientConfig.java     # OpenSearch 클라이언트 설정
│   ├── ElasticsearchProperties.java    # ES 연결 정보
│   ├── OpenFeignConfig.java            # Feign 클라이언트 설정
│   ├── SlackConfig.java                # Slack 알림 설정
│   ├── SwaggerUIConfiguration.java     # API 문서화
│   └── ...
│
├── api/
│   ├── requirement/                    # ⭐ 요구사항 관리
│   │   ├── controller/
│   │   │   └── RequirementController.java
│   │   ├── model/
│   │   │   ├── dto/                   # RequirementDTO, RequirementAggrDTO
│   │   │   └── vo/                    # RequirementVO, ReqProgressVO
│   │   └── service/
│   │       └── RequirementService.java
│   │
│   ├── issue/                          # ⭐ ALM 이슈 통합
│   │   ├── almapi/                    # Jira/Redmine API 통합
│   │   │   ├── controller/
│   │   │   │   └── IssueController.java
│   │   │   ├── model/
│   │   │   │   ├── dto/               # AlmIssueDTO
│   │   │   │   ├── entity/            # AlmIssueEntity
│   │   │   │   └── vo/                # AlmIssueVOResponse
│   │   │   ├── service/
│   │   │   │   └── IssueService.java
│   │   │   ├── strategy/              # Strategy 패턴 (Jira/Redmine)
│   │   │   └── repository/
│   │   ├── priority/                  # 이슈 우선순위
│   │   ├── status/                    # 이슈 상태
│   │   ├── type/                      # 이슈 타입
│   │   └── resolution/                # 이슈 해결책
│   │
│   ├── search_engine/                  # ⭐ 검색 엔진
│   │   ├── controller/
│   │   ├── service/
│   │   │   ├── AlmIssueSearch.java
│   │   │   └── AlmIssueSearchImpl.java
│   │   ├── dto/
│   │   └── vo/
│   │
│   ├── project/                        # 프로젝트 관리
│   ├── dashboard/                      # 대시보드
│   ├── analysis/                       # 분석 (비용/시간/범위/리소스)
│   │   ├── cost/
│   │   ├── time/
│   │   ├── scope/
│   │   └── resource/
│   ├── report/                         # 리포트 생성
│   ├── account/                        # 계정 관리
│   └── util/                           # 유틸리티
│       ├── alm/                        # ALM 유틸리티
│       ├── aes/                        # 암호화
│       ├── slack/                      # Slack 알림
│       └── aspect/                     # AOP
│
└── egovframework/                      # 전자정부 프레임워크
    └── javaservice/
        └── esframework/                # Elasticsearch Framework
```

---

## 🚀 시작하기

### 필수 요구사항

- ☕ **Java 21** 이상
- 🐘 **Gradle 8.13** 이상
- 🐳 **Docker** (선택사항)
- 🔍 **OpenSearch** 또는 **Elasticsearch**

### 1. Repository Clone

```bash
git clone -b dev https://github.com/313DEVGRP/Java-Service-Tree-Framework-Engine-Fire.git
cd Java-Service-Tree-Framework-Engine-Fire
```

### 2. 환경 설정

#### Spring Cloud Config 설정

```yaml
# src/main/resources/application.yml
spring:
  application:
    name: javaServiceTreeFrameworkEngineFire
  cloud:
    config:
      uri: http://www.313.co.kr:33133
      name: javaServiceTreeFrameworkEngineFire
      profile: dev  # dev, prod, local
```

#### 프로파일 활성화

```bash
# VM Options
-Dspring.profiles.active=dev

# 또는 환경 변수
export SPRING_PROFILES_ACTIVE=dev
```

#### 설정 확인

```bash
# Config Server에서 설정 확인
curl http://www.313.co.kr:33133/javaServiceTreeFrameworkEngineFire/dev
```

### 3. 빌드

```bash
# Gradle Wrapper 실행 권한 부여 (Linux/Mac)
chmod +x gradlew

# 빌드
./gradlew clean build

# 테스트 제외 빌드
./gradlew clean build -x test
```

### 4. 실행

#### 로컬 실행

```bash
# Gradle로 실행
./gradlew bootRun

# JAR로 실행
java -jar build/libs/Java-Service-Tree-Framework-Engine-Fire-25.10.x.jar
```

#### Docker로 실행

```bash
# Docker 이미지 빌드
./gradlew buildDockerImage

# Docker 컨테이너 실행
docker run -d \
  -p 8080:8080 \
  --name engine-fire \
  313.co.kr:5550/313devgrp/java-service-tree-framework-engine-fire:25.10.x
```

### 5. 헬스 체크

```bash
# 애플리케이션 상태 확인
curl http://localhost:8080/actuator/health

# 응답 예시
{
  "status": "UP"
}
```

---

## 📖 API 문서

### Swagger UI

애플리케이션 실행 후 다음 URL에서 API 문서를 확인할 수 있습니다:

```
http://localhost:8080/swagger-ui.html
```

### 주요 API 엔드포인트

#### 요구사항 관리

| Method | Endpoint | 설명 |
|--------|----------|------|
| POST | `/engine/jira/dashboard/req-assignees` | 담당자 목록 조회 |
| GET | `/engine/reqStatus/reqIssues-created-together` | 묶음 조회 |
| GET | `/engine/reqStatus/deletedIssueList` | 삭제된 이슈 목록 |
| PUT | `/engine/reqStatus/deleteWithdrawal` | 이슈 삭제 철회 |
| POST | `/engine/req-gantt/resolution` | 간트 차트용 검색 |
| POST | `/engine/reqStatus/issue-list-by-updated` | 업데이트 기준 조회 |

#### ALM 이슈 통합

| Method | Endpoint | 설명 |
|--------|----------|------|
| POST | `/{connectId}/jira/issue` | 이슈 생성 |
| PUT | `/{connectId}/jira/issue/{issueKeyOrId}` | 이슈 수정 |
| PUT | `/{connectId}/jira/issue/{issueKeyOrId}/{statusId}` | 상태 변경 |
| DELETE | `/{connectId}/jira/issue/{issueKeyOrId}` | 이슈 삭제 |
| GET | `/{connectId}/jira/issue/{issueKeyOrId}` | 이슈 조회 |

### API 사용 예시

#### 이슈 생성

```bash
curl -X POST "http://localhost:8080/{connectId}/jira/issue" \
  -H "Content-Type: application/json" \
  -d '{
    "projectKey": "PROJ",
    "issueType": "Task",
    "summary": "New Issue",
    "description": "Issue description"
  }'
```

#### 요구사항 담당자 목록 조회

```bash
curl -X POST "http://localhost:8080/engine/jira/dashboard/req-assignees" \
  -H "Content-Type: application/json" \
  -d '{
    "pdServiceId": 1,
    "pdServiceVersions": [1, 2, 3]
  }'
```

---

## 🐳 배포

### Docker 배포

#### 1. 이미지 빌드

```bash
# Gradle Task로 빌드
./gradlew buildDockerImage

# 또는 Docker 직접 빌드
docker build -t 313devgrp/java-service-tree-framework-engine-fire:25.10.x .
```

#### 2. 이미지 푸시

```bash
# Private Registry에 푸시
./gradlew pushDockerImage

# 또는
docker push 313.co.kr:5550/313devgrp/java-service-tree-framework-engine-fire:25.10.x
```

#### 3. 컨테이너 실행

```bash
docker run -d \
  --name engine-fire \
  -p 8080:8080 \
  -e SPRING_PROFILES_ACTIVE=prod \
  -e JAVA_OPTS="-Xms512m -Xmx2048m" \
  313.co.kr:5550/313devgrp/java-service-tree-framework-engine-fire:25.10.x
```

### Maven Repository 배포

```bash
# Maven 저장소에 배포
./gradlew publish

# 버전 확인
./gradlew printVersion
```

**배포 정보:**
- **Repository**: http://www.313.co.kr/nexus/repository/ple-releases/
- **GroupId**: 313devgrp
- **ArtifactId**: Java-Service-Tree-Framework-Engine-Fire
- **Version**: 25.10.x (자동 증가)

### 버전 관리

버전은 `Major.Minor.Patch` 형식으로 자동 관리됩니다:

```gradle
ext {
    majorVersion = 25  // 수동 관리
    minorVersion = 10  // 수동 관리
    // patchVersion은 Nexus에서 자동 증가
}
```

**자동 증가 로직:**
1. Nexus에서 최신 버전 조회 (maven-metadata.xml)
2. Major 버전 증가 시 → Minor, Patch 리셋 (0.0)
3. Minor 버전 증가 시 → Patch 리셋 (0)
4. 동일 Major.Minor → Patch 자동 증가

---

## 👨‍💻 개발 가이드

### 개발 환경 설정

#### 1. IDE 설정 (IntelliJ IDEA)

1. **프로젝트 Import**
   - `File > Open` → `build.gradle` 선택
   - Gradle 프로젝트로 Import

2. **Java SDK 설정**
   - `File > Project Structure > Project`
   - SDK: Java 21
   - Language Level: 21

3. **Lombok 플러그인 설치**
   - `Settings > Plugins`
   - "Lombok" 검색 및 설치
   - `Settings > Build > Compiler > Annotation Processors`
   - "Enable annotation processing" 체크

4. **Code Style 설정**
   - `Settings > Editor > Code Style > Java`
   - Indent: 4 spaces
   - Tab size: 4

#### 2. 로컬 개발 설정

##### application-local.yml 생성

```yaml
# src/main/resources/application-local.yml
spring:
  profiles:
    active: local
  
server:
  port: 8080

# OpenSearch 설정
elasticsearch:
  url: localhost:9200

# Slack 알림 (선택사항)
slack:
  webhook-url: https://hooks.slack.com/services/YOUR/WEBHOOK/URL
```

##### 로컬 프로파일로 실행

```bash
./gradlew bootRun --args='--spring.profiles.active=local'
```

### 코딩 컨벤션

#### 네이밍 규칙

- **클래스**: PascalCase (예: `RequirementController`)
- **메서드**: camelCase (예: `createIssue`)
- **상수**: UPPER_SNAKE_CASE (예: `MAX_RETRY_COUNT`)
- **패키지**: lowercase (예: `com.arms.api.requirement`)

#### 주석 규칙

```java
/**
 * 요구사항 생성 API
 * 
 * @param requirementDTO 요구사항 데이터
 * @return 생성된 요구사항 정보
 * @throws IllegalArgumentException 필수 파라미터 누락 시
 */
public RequirementVO createRequirement(RequirementDTO requirementDTO) {
    // 구현
}
```

#### 예외 처리

```java
@RestControllerAdvice
public class GlobalExceptionHandler {
    
    @ExceptionHandler(IllegalArgumentException.class)
    public ResponseEntity<ErrorResponse> handleIllegalArgument(
        IllegalArgumentException ex) {
        log.error("Invalid argument: {}", ex.getMessage());
        return ResponseEntity
            .badRequest()
            .body(new ErrorResponse(ex.getMessage()));
    }
}
```

### 테스트 작성

#### 단위 테스트

```java
@SpringBootTest
class RequirementServiceTest {
    
    @Autowired
    private RequirementService requirementService;
    
    @Test
    @DisplayName("요구사항 생성 테스트")
    void createRequirement() {
        // Given
        RequirementDTO dto = new RequirementDTO();
        dto.setTitle("Test Requirement");
        
        // When
        RequirementVO result = requirementService.createRequirement(dto);
        
        // Then
        assertThat(result).isNotNull();
        assertThat(result.getTitle()).isEqualTo("Test Requirement");
    }
}
```

#### 통합 테스트 (WireMock)

```java
@SpringBootTest
@Import(WireMockJiraConfig.class)
class IssueServiceIntegrationTest {
    
    @Autowired
    private IssueService issueService;
    
    @Test
    @DisplayName("Jira 이슈 생성 통합 테스트")
    void createJiraIssue() {
        // Given
        AlmIssueDTO dto = new AlmIssueDTO();
        dto.setServerId("jira-001");
        dto.setProjectKey("PROJ");
        
        // When
        AlmIssueVOResponse response = issueService.createIssue(dto);
        
        // Then
        assertThat(response).isNotNull();
        assertThat(response.getKey()).startsWith("PROJ-");
    }
}
```

### 로깅 가이드

```java
@Slf4j
@Service
public class RequirementService {
    
    public void processRequirement(Long id) {
        log.debug("Processing requirement: {}", id);
        
        try {
            // 비즈니스 로직
            log.info("Successfully processed requirement: {}", id);
        } catch (Exception e) {
            log.error("Failed to process requirement: {}", id, e);
            throw e;
        }
    }
}
```

**로그 레벨:**
- `ERROR`: 시스템 오류, 예외 발생
- `WARN`: 경고, 잠재적 문제
- `INFO`: 중요한 비즈니스 이벤트
- `DEBUG`: 상세한 디버깅 정보
- `TRACE`: 매우 상세한 추적 정보

---

## 🔍 문제 해결 (Troubleshooting)

### 자주 발생하는 문제

#### 1. OpenSearch 연결 실패

**증상:**
```
Connection refused: localhost:9200
```

**해결:**
```bash
# OpenSearch 실행 상태 확인
curl http://localhost:9200

# OpenSearch 시작
docker run -d -p 9200:9200 -e "discovery.type=single-node" opensearchproject/opensearch:2.11.0
```

#### 2. Spring Cloud Config 연결 실패

**증상:**
```
Could not resolve placeholder 'elasticsearch.url'
```

**해결:**
- Config Server 실행 상태 확인
- `application.yml`에 fallback 설정 추가

```yaml
spring:
  cloud:
    config:
      fail-fast: false  # Config Server 없어도 시작
```

#### 3. Jira API 인증 실패

**증상:**
```
401 Unauthorized
```

**해결:**
- API Token 확인
- Base64 인코딩 검증
- Jira 권한 확인

#### 4. 메모리 부족

**증상:**
```
java.lang.OutOfMemoryError: Java heap space
```

**해결:**
```bash
# JVM 메모리 증가
java -Xms512m -Xmx2048m -jar app.jar

# Docker 환경
docker run -e "JAVA_OPTS=-Xmx2048m" ...
```

---

## 📊 성능 최적화

### Connection Pooling

```java
@Bean
public ConnectionKeepAliveStrategy connectionKeepAliveStrategy() {
    return (response, context) -> 180 * 1000;  // 3분 Keep-Alive
}
```

### 비동기 처리

```java
@EnableAsync
@Configuration
public class AsyncConfig implements AsyncConfigurer {
    
    @Override
    public Executor getAsyncExecutor() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        executor.setCorePoolSize(5);
        executor.setMaxPoolSize(10);
        executor.setQueueCapacity(100);
        executor.setThreadNamePrefix("async-");
        executor.initialize();
        return executor;
    }
}
```

### 캐싱 전략

```java
@Cacheable(value = "issues", key = "#issueKey")
public AlmIssueEntity getIssue(String issueKey) {
    // 데이터베이스 조회
}

@CacheEvict(value = "issues", key = "#issueKey")
public void updateIssue(String issueKey, AlmIssueDTO dto) {
    // 업데이트 로직
}
```

---

## 🔐 보안

### Actuator 보안

```yaml
management:
  endpoints:
    web:
      exposure:
        include: health,info  # 최소한의 엔드포인트만 노출
  endpoint:
    health:
      show-details: when-authorized  # 인증된 사용자에게만 상세 정보
```

### API 보안 (향후 개선 사항)

- Spring Security 통합
- OAuth2/JWT 인증
- API Rate Limiting
- CORS 정책 설정

---

## 📈 모니터링

### Actuator 엔드포인트

| Endpoint | 설명 |
|----------|------|
| `/actuator/health` | 애플리케이션 헬스 체크 |
| `/actuator/info` | 애플리케이션 정보 |
| `/actuator/env` | 환경 변수 확인 |
| `/actuator/beans` | Spring Bean 목록 |
| `/actuator/httptrace` | HTTP 요청 추적 |

### 커스텀 Health Indicator

```java
@Component
public class CustomHealthIndicator implements HealthIndicator {
    
    @Override
    public Health health() {
        // 커스텀 헬스 체크 로직
        boolean isHealthy = checkSystemHealth();
        
        if (isHealthy) {
            return Health.up()
                .withDetail("custom", "All systems operational")
                .build();
        } else {
            return Health.down()
                .withDetail("custom", "System degraded")
                .build();
        }
    }
}
```

---

## 🤝 기여 가이드

### 브랜치 전략

- `main`: 프로덕션 릴리즈
- `dev`: 개발 통합 브랜치
- `feature/*`: 기능 개발
- `bugfix/*`: 버그 수정
- `hotfix/*`: 긴급 수정

### Pull Request 프로세스

1. `dev` 브랜치에서 feature 브랜치 생성
2. 기능 개발 및 테스트
3. PR 생성 (dev ← feature)
4. 코드 리뷰
5. 머지

### 커밋 메시지 컨벤션

```
feat: 새로운 기능 추가
fix: 버그 수정
docs: 문서 수정
style: 코드 포맷팅
refactor: 코드 리팩토링
test: 테스트 코드
chore: 빌드 업무, 패키지 매니저 설정
```

**예시:**
```
feat: Redmine API 통합 추가

- Redmine REST API 클라이언트 구현
- RedmineStrategy 구현
- 통합 테스트 작성

Closes #123
```

---

## 📝 변경 이력

### v25.10.x (2025-11-03)
- ✨ OpenSearch 2.11.0 지원
- ✨ Redmine API 4.0 업그레이드
- 🐛 Jira 이슈 생성 시 타임아웃 문제 수정
- 📝 API 문서 개선

### v25.9.x (2025-10-15)
- ✨ 계층적 요구사항 구조 지원
- ✨ Slack 알림 기능 추가
- 🔧 OpenFeign HTTP Client 5 적용
- 📊 대시보드 성능 개선

### v25.8.x (2025-09-20)
- 🎉 Initial Release
- ✨ Jira Cloud/Server 통합
- ✨ 요구사항 관리 기능
- ✨ OpenSearch 검색 엔진

---

## 📞 연락처

- **Maintainer**: 313DEVGRP
- **Email**: 313@313.co.kr
- **Website**: http://www.313.co.kr

---

## 📄 라이선스

Copyright © 2025 313DEVGRP. All rights reserved.

이 소프트웨어는 독점 라이선스로 제공되며, 무단 복제 및 배포를 금지합니다.

---

## 🙏 감사의 글

이 프로젝트는 다음 오픈소스 프로젝트를 사용합니다:

- [Spring Boot](https://spring.io/projects/spring-boot)
- [Spring Cloud](https://spring.io/projects/spring-cloud)
- [OpenSearch](https://opensearch.org/)
- [Atlassian Jira REST Java Client](https://ecosystem.atlassian.net/wiki/spaces/JRJC/overview)
- [Redmine Java API](https://github.com/taskadapter/redmine-java-api)

---

**Made with ❤️ by 313DEVGRP**