?뱁댆 留덉씪?ㅽ넠 湲곕뒫 媛쒖꽑 諛??좎쭨 ?좏떥由ы떚 異붽?

EXAONE_설치_가이드.md

@@ -186,6 +186,8 @@ tokenizer = AutoTokenizer.from_pretrained("LGAI-EXAONE/EXAONE-3.0-7.8B-Instruct"
 
 
 
+
+
 
 
 

add_exaone_model.py

@@ -181,6 +181,8 @@ if __name__ == "__main__":
 
 
 
+
+
 
 
 

app/__init__.py

@@ -302,9 +302,38 @@ def create_app() -> Flask:
             path = request.path or ''
             if not (path.startswith('/static') or path == '/favicon.ico'):
                 return _db_error_response()
+        
+        # 민감한 정보 제외하고 로깅
+        if request.path.endswith('.json') or request.path.endswith('.ico') or request.path.startswith('/static'):
+            return
+
         logger.info(f"[요청] {request.method} {request.path} - IP: {request.remote_addr}")
         if request.args:
             logger.debug(f"[요청 파라미터] {dict(request.args)}")
+        
+        # POST 요청 바디 로깅 (JSON인 경우만, 너무 길면 자름)
+        if request.method == 'POST' and request.is_json:
+            try:
+                body = request.get_json()
+                body_str = str(body)
+                if len(body_str) > 1000:
+                    body_str = body_str[:1000] + "..."
+                logger.info(f"[요청 본문] {body_str}")
+            except:
+                pass
+
+    @app.errorhandler(Exception)
+    def handle_exception(e):
+        """처리되지 않은 모든 예외 로깅"""
+        import traceback
+        err_trace = traceback.format_exc()
+        logger.error(f"[Unhandled Exception] {str(e)}\n{err_trace}")
+        
+        # API 요청인 경우 JSON 응답
+        if request.path.startswith('/api/'):
+            return jsonify({'error': str(e), 'trace': err_trace}), 500
+        
+        return str(e), 500
     
     @app.after_request
     def log_response_info(response):

app/routes.py

@@ -24,6 +24,7 @@ from datetime import date as date_type
 import uuid
 import re
 import json
+from app.utils.date_utils import add_business_days, is_holiday, get_holidays_in_range
 
 main_bp = Blueprint('main', __name__)
 
@@ -83,6 +84,7 @@ def get_default_admin_menu():
                     {"label": "마일스톤 기본 데이터 세팅", "endpoint": "main.admin_webtoon_milestone_settings", "roles": ["admin", "webtoon_pm"]},
                     {"label": "작품별 마일스톤 세팅", "endpoint": "main.admin_webtoon_milestones", "roles": ["admin", "webtoon_pm"]},
                     {"label": "마일스톤 확인", "endpoint": "main.admin_webtoon_milestone_latest_result", "roles": ["admin", "webtoon_pm"]},
+                    {"label": "마일스톤 확인(휴일)", "endpoint": "main.admin_webtoon_milestone_latest_result_holidays", "roles": ["admin", "webtoon_pm"]},
                 ]
             },
             {
@@ -541,15 +543,25 @@ def admin_required(f):
     @wraps(f)
     @login_required
     def decorated_function(*args, **kwargs):
-        # admin 또는 webtoon_pm 허용 (기본 관리자 페이지 접근)
-        user_role = getattr(current_user, 'role', 'user')
-        if not (current_user.is_admin or user_role in ['admin', 'webtoon_pm']):
-            # API 요청인 경우 JSON 응답 반환
+        try:
+            # admin 또는 webtoon_pm 허용 (기본 관리자 페이지 접근)
+            # current_user 속성 접근 시 DB 에러가 발생할 수 있음 (스키마 불일치 등)
+            user_role = getattr(current_user, 'role', 'user')
+            if not (current_user.is_admin or user_role in ['admin', 'webtoon_pm']):
+                # API 요청인 경우 JSON 응답 반환
+                if request.path.startswith('/api/'):
+                    return jsonify({'error': '관리자 권한이 필요합니다.'}), 403
+                flash('관리자 권한이 필요합니다.', 'error')
+                return redirect(url_for('main.index'))
+            return f(*args, **kwargs)
+        except Exception as e:
+            # 데코레이터 내부 에러 로깅
+            import traceback
+            err_trace = traceback.format_exc()
+            current_app.logger.error(f"[admin_required Error] {str(e)}\n{err_trace}")
             if request.path.startswith('/api/'):
-                return jsonify({'error': '관리자 권한이 필요합니다.'}), 403
-            flash('관리자 권한이 필요합니다.', 'error')
-            return redirect(url_for('main.index'))
-        return f(*args, **kwargs)
+                return jsonify({'error': '권한 확인 중 오류 발생', 'details': str(e)}), 500
+            raise e
     return decorated_function
 
 # Ollama 기본 URL (환경 변수로 설정 가능)
@@ -6483,18 +6495,53 @@ def create_webtoon_milestone():
     """웹소설 파일에 대한 마일스톤 생성 (순차 진행 역산)"""
     try:
         data = request.json
+        current_app.logger.info(f"[create_webtoon_milestone] Request data: {data}")
+        current_app.logger.info("[DEBUG] New Logic Applied - Loop Removed")
+        
+        def safe_int(v, default):
+            try:
+                if v is None or str(v).strip() == '': return default
+                return int(v)
+            except:
+                return default
+
         file_id = data.get('file_id')
         basis = data.get('basis', 'median')
-        cadence_days = int(data.get('cadence_days', 7))
-        ep0_days = int(data.get('ep0_days', 21))
-        plan_days = int(data.get('plan_days', 7))
+        cadence_days = safe_int(data.get('cadence_days'), 7)
+        ep0_days = safe_int(data.get('ep0_days'), 21)
+        plan_days = safe_int(data.get('plan_days'), 7)
         launch_date_s = data.get('launch_date')
+        apply_holidays = bool(data.get('apply_holidays', False))
         
         if not file_id or not launch_date_s:
             return jsonify({'error': '필수 파라미터가 누락되었습니다.'}), 400
             
         launch_date = datetime.strptime(launch_date_s, '%Y-%m-%d').date()
         
+        # --- 휴일 관련 유틸 ---
+        # from app.utils.date_utils import add_business_days, is_holiday
+
+        def _add_days(start: datetime.date, d: int) -> datetime.date:
+            """
+            d일 '작업' 후의 날짜를 계산.
+            apply_holidays=True 이면 업무일 기준 d일 후 (주말/휴일 건너뜀)
+            apply_holidays=False 이면 단순 d일 후
+            (단, d=duration이므로 1일 작업이면 같은 날짜가 되어야 하므로
+             실제로는 (d-1)일을 더하는 로직 등에서 사용됨)
+            """
+            if apply_holidays:
+                # 업무일 기준 d일 '후'가 아니라, d일치 작업을 수행한 후의 날짜?
+                # 보통 start_date 포함 d일 작업 -> start_date + (d-1)일 후
+                return add_business_days(start, d)
+            else:
+                return start + timedelta(days=d)
+
+        def _sub_days(start: datetime.date, d: int) -> datetime.date:
+            if apply_holidays:
+                return add_business_days(start, -d)
+            else:
+                return start - timedelta(days=d)
+
         def _median_int(vals):
             if not vals: return 0
             vals = sorted(vals)
@@ -6641,14 +6688,50 @@ def create_webtoon_milestone():
 
         d20 = episode_total_days.get(20, 0)
         ep20_end = launch_date
-        ep20_start = ep20_end - timedelta(days=d20 - 1) if d20 > 0 else ep20_end
+        
+        # 20화 시작일 역산
+        # ep20_start = ep20_end - (d20 - 1)
+        if d20 > 0:
+            ep20_start = _sub_days(ep20_end, d20 - 1)
+        else:
+            ep20_start = ep20_end
+
+        # 전체 시작일(start_date) 역산 (1~19화 간격 포함)
+        # start_date = ep20_start - (19 * cadence_days)
+        # cadence도 휴일 적용? 보통 착수 간격은 달력일 기준이 많으나, 여기선 '휴일 반영' 요청이므로 업무일로 처리할 수도 있음.
+        # 하지만 착수 간격(Cadence)은 보통 '매주 금요일' 처럼 캘린더 기준이 강함.
+        # 사용자 요청 "주말 반영"이 작업 기간에 대한 것인지 일정 전체인지 모호하나, 작업일(Duration) 위주로 적용하는게 일반적.
+        # Cadence는 달력일(timedelta)로 유지하고, 작업 종료일(Duration) 계산에만 휴일을 적용하는 것이 안전.
+        # -> 라고 생각했으나 "베트남 휴무 일정 반영"이면 공장 가동일 기준일 수 있음.
+        # 우선 Cadence는 달력일로 유지하되, 착수일이 휴일이면 미루는 정도?
+        # 여기서는 단순화를 위해 Cadence는 달력일로 유지. (기존 로직 유지)
         start_date = ep20_start - timedelta(days=(20 - 1) * cadence_days)
-        proj_start_date = start_date - timedelta(days=ep0_days) if ep0_days > 0 else start_date
+        
+        # 0화/기획 기간 역산
+        if ep0_days > 0:
+            # proj_start_date = start_date - ep0_days
+            # ep0_days도 작업일이므로 _sub_days 사용
+            proj_start_date = _sub_days(start_date, ep0_days) # 0화 기간만큼 전
+            # 다만 바로 이어지므로 하루 더 빼야 하나? 
+            # 아니, start_date가 1화 시작일. 0화 종료일 = start_date - 1일?
+            # 보통 0화 끝난 다음날 1화 시작.
+            # 0화 종료 = start_date - 1 (달력일? 업무일?)
+            # 복잡성을 피하기 위해: 0화 종료일 = start_date - 1 (달력) -> 그로부터 ep0_days 전 (업무)
+            # 그냥 start_date 기준으로 ep0_days 업무일 전을 0화 시작일로 잡고 계산
+            pass
+        else:
+            proj_start_date = start_date
         
         episodes = []
         if ep0_days > 0:
-            ep0_start = proj_start_date
-            ep0_end = ep0_start + timedelta(days=ep0_days - 1)
+            # 0화 날짜 계산 (정방향)
+            # 0화 시작일이 proj_start_date라고 가정하면...
+            # 역산이 꼬일 수 있으므로, 1화 시작일(start_date) 기준으로 0화 종료일을 맞춤
+            # 0화 종료일 = start_date 하루 전 (달력일)
+            ep0_end = start_date - timedelta(days=1)
+            # 0화 시작일 = 0화 종료일 - (ep0_days - 1) (업무일)
+            ep0_start = _sub_days(ep0_end, ep0_days - 1)
+            
             episodes.append({
                 'episode_num': 0,
                 'start_date': ep0_start.isoformat(),
@@ -6663,53 +6746,92 @@ def create_webtoon_milestone():
             stages_out = []
             
             if basis == 'settings':
-                # 위에서 계산한 로직과 동일하게 날짜 배정
-                sim_starts = [] 
-                sim_ends = []
+                # 날짜 기반 시뮬레이션
+                real_starts = [] # index -> date
+                real_ends = []   # index -> date
+                
                 for i, stage in enumerate(tpl):
                     dur = stage['days']
                     s_key = stage['stage_key']
                     
-                    prev_end = sim_ends[i-1] if i > 0 else 0
-                    my_start_offset = prev_end + 1
-                    
+                    # 1. 순차 시작일 계산 (이전 단계 종료 다음 날)
+                    # 이전 단계가 없으면 ep_start
+                    if i == 0:
+                        base_start = ep_start
+                    else:
+                        base_start = real_ends[i-1] + timedelta(days=1) # 달력일 다음날
+                        
+                    # 2. Overlap 적용
+                    # settings_overlaps[s_key] -> {a: prev_key, overlap_days: N}
+                    # 앞당겨질 날짜 계산
+                    target_start = base_start
                     if i > 0:
                         prev_key = tpl[i-1]['stage_key']
                         ov_info = settings_overlaps.get(str(s_key))
                         if ov_info and str(ov_info.get('a')) == str(prev_key):
                             ov_days = float(ov_info.get('overlap_days') or 0)
-                            target_start = prev_end - ov_days + 1
-                            # 이전 단계 시작일보다는 같거나 뒤여야 논리적임 (sim_starts[i-1])
-                            # (Gantt 로직과 유사하게)
-                            my_start_offset = max(sim_starts[i-1], target_start)
-                            my_start_offset = max(1, my_start_offset)
-                            
-                    sim_starts.append(my_start_offset)
-                    sim_ends.append(my_start_offset + dur - 1)
+                            # overlap_days만큼 "이전 단계 종료일"에서 앞으로 당김
+                            # overlap이 업무일 기준? 달력일 기준? -> 보통 달력일 (기간 겹침)
+                            # 하지만 여기선 "작업일수" 기준이므로 
+                            # (이전종료 - ov_days) 날짜를 구해야 함.
+                            # 단순하게 달력일로 뺌.
+                            prev_end_date = real_ends[i-1]
+                            target_start = prev_end_date - timedelta(days=int(ov_days)) + timedelta(days=1)
                     
-                    # 실제 날짜 변환 (ep_start가 Day 1)
-                    s_date = ep_start + timedelta(days=my_start_offset - 1)
-                    e_date = ep_start + timedelta(days=my_start_offset + dur - 1 - 1) # -1 due to inclusive
+                    # 3. 최종 시작일 결정
+                    # 순차 시작일(base_start)보다 target_start가 빠르면 당겨짐.
+                    # 단, 이전 단계 시작일(real_starts[i-1])보다는 같거나 뒤여야 함.
+                    final_start = target_start
+                    if i > 0:
+                         # 논리적 하한선: 이전 단계 시작일
+                         if final_start < real_starts[i-1]:
+                             final_start = real_starts[i-1]
+                    
+                    # 시작일이 휴일이면 다음 업무일로 밀어야 함?
+                    # "작업 시작"은 업무일에 하는 게 맞음.
+                    if apply_holidays:
+                        while is_holiday(final_start):
+                            final_start += timedelta(days=1)
+
+                    # 4. 종료일 계산 (Duration 반영)
+                    # final_start 포함 dur일 소요
+                    final_end = _add_days(final_start, dur - 1)
+                    
+                    real_starts.append(final_start)
+                    real_ends.append(final_end)
                     
                     stages_out.append({
                         'stage_key': s_key,
                         'duration_days': dur,
-                        'start_date': s_date.isoformat(),
-                        'end_date': e_date.isoformat()
+                        'start_date': final_start.isoformat(),
+                        'end_date': final_end.isoformat()
                     })
 
             else:
+                # basis != settings (기존 로직 + 휴일 적용)
                 cur = ep_start
+                # 시작일이 휴일이면 미룸
+                if apply_holidays:
+                    while is_holiday(cur):
+                        cur += timedelta(days=1)
+                        
                 for t in tpl:
                     d = t['days']
-                    en = cur + timedelta(days=d - 1)
+                    # cur부터 d일 작업
+                    en = _add_days(cur, d - 1)
+                    
                     stages_out.append({
                         'stage_key': t['stage_key'],
                         'duration_days': d,
                         'start_date': cur.isoformat(),
                         'end_date': en.isoformat()
                     })
+                    # 다음 단계는 종료일 다음날(달력)부터? 아니면 다음 업무일부터?
+                    # 보통 종료 다음날부터 시작. 그게 휴일이면 미룸.
                     cur = en + timedelta(days=1)
+                    if apply_holidays:
+                        while is_holiday(cur):
+                            cur += timedelta(days=1)
             
             if stages_out:
                 ep_end = datetime.strptime(stages_out[-1]['end_date'], '%Y-%m-%d').date()
@@ -6735,17 +6857,86 @@ def create_webtoon_milestone():
             launch_date=launch_date,
             schedule_json=json.dumps(result, ensure_ascii=False)
         )
+        # apply_holidays 정보도 저장하고 싶지만 모델 스키마 변경 필요.
+        # 일단 schedule_json 안에 포함시키는 것으로 충분. (result 객체 안에 들어감)
+        if apply_holidays:
+            # result 딕셔너리에 추가
+            result['apply_holidays'] = True
+            milestone.schedule_json = json.dumps(result, ensure_ascii=False)
+
         db.session.add(milestone)
         db.session.commit()
-        return jsonify({'message': '마일스톤 생성 완료', 'id': milestone.id}), 200
+        return jsonify({'message': '마일스톤 생성 완료', 'id': milestone.id, 'apply_holidays': apply_holidays}), 200
     except Exception as e:
         db.session.rollback()
+        import traceback
+        err_trace = traceback.format_exc()
+        current_app.logger.error(f"[create_webtoon_milestone Error] {str(e)}\n{err_trace}")
+        return jsonify({'error': str(e), 'trace': err_trace}), 500
+
+@main_bp.route('/api/webtoons/milestones/<int:milestone_id>/holidays')
+@admin_required
+def get_webtoon_milestone_holidays(milestone_id):
+    """마일스톤 기간 내의 휴일 목록 반환 (JSON)"""
+    ms = WebtoonMilestone.query.get_or_404(milestone_id)
+    try:
+        data = json.loads(ms.schedule_json)
+        episodes = data.get('episodes', [])
+        if not episodes:
+            return jsonify({'holidays': []})
+        
+        # 전체 기간 파악
+        # (생성 로직상 에피소드들이 정렬되어 있다고 가정)
+        # 하지만 0화, 1화 등 순서가 다를 수 있음. min/max 찾기.
+        all_dates = []
+        for ep in episodes:
+            if ep.get('start_date'): all_dates.append(ep['start_date'][:10])
+            if ep.get('end_date'): all_dates.append(ep['end_date'][:10])
+        
+        if not all_dates:
+            return jsonify({'holidays': []})
+            
+        min_s = min(all_dates)
+        max_s = max(all_dates)
+        
+        from app.utils.date_utils import get_holidays_in_range
+        from datetime import datetime
+        
+        d1 = datetime.strptime(min_s, '%Y-%m-%d').date()
+        d2 = datetime.strptime(max_s, '%Y-%m-%d').date()
+        
+        holidays_list = get_holidays_in_range(d1, d2)
+        # ISO 문자열로 변환
+        return jsonify({'holidays': [d.isoformat() for d in holidays_list]})
+    except Exception as e:
         return jsonify({'error': str(e)}), 500
 
+@main_bp.route('/admin/webtoons/milestones/result-holidays/<int:milestone_id>')
+@admin_required
+def admin_webtoon_milestone_result_holidays(milestone_id):
+    """휴일 적용 마일스톤 상세 결과 (휴일 표시 기능 추가)"""
+    ms = WebtoonMilestone.query.get_or_404(milestone_id)
+    files = (
+        UploadedFile.query
+        .join(WebtoonMilestone, UploadedFile.id == WebtoonMilestone.file_id)
+        .filter(UploadedFile.is_public == True, UploadedFile.parent_file_id == None)
+        .distinct()
+        .order_by(UploadedFile.uploaded_at.desc())
+        .all()
+    )
+    schedule_data = json.loads(ms.schedule_json) if ms.schedule_json else {}
+    return render_template('admin_webtoon_milestone_detail_holidays.html', milestone=ms, files=files, schedule=schedule_data)
+
+
 @main_bp.route('/admin/webtoons/milestones/result/<int:milestone_id>')
 @admin_required
 def admin_webtoon_milestone_result(milestone_id):
     ms = WebtoonMilestone.query.get_or_404(milestone_id)
+    
+    # schedule_json에서 apply_holidays 여부 확인
+    schedule_data = json.loads(ms.schedule_json) if ms.schedule_json else {}
+    # 리다이렉트 로직 제거: apply_holidays여도 사용자가 원하면 기본 뷰로 볼 수 있게 함
+
     # 좌측 프로젝트 목록: 마일스톤이 생성된 프로젝트만 노출
     files = (
         UploadedFile.query
@@ -6755,7 +6946,6 @@ def admin_webtoon_milestone_result(milestone_id):
         .order_by(UploadedFile.uploaded_at.desc())
         .all()
     )
-    schedule_data = json.loads(ms.schedule_json) if ms.schedule_json else {}
     return render_template('admin_webtoon_milestone_detail.html', milestone=ms, files=files, schedule=schedule_data)
 
 
@@ -6769,9 +6959,23 @@ def admin_webtoon_milestone_latest_result():
     latest = WebtoonMilestone.query.order_by(WebtoonMilestone.created_at.desc()).first()
     if not latest:
         return redirect(url_for('main.admin_webtoon_milestones'))
+    
     return redirect(url_for('main.admin_webtoon_milestone_result', milestone_id=latest.id))
 
 
+@main_bp.route('/admin/webtoons/milestones/result-holidays/latest')
+@admin_required
+def admin_webtoon_milestone_latest_result_holidays():
+    """
+    메뉴 진입용: 최신 마일스톤 결과(휴일 뷰)로 이동.
+    """
+    latest = WebtoonMilestone.query.order_by(WebtoonMilestone.created_at.desc()).first()
+    if not latest:
+        return redirect(url_for('main.admin_webtoon_milestones'))
+    
+    return redirect(url_for('main.admin_webtoon_milestone_result_holidays', milestone_id=latest.id))
+
+
 @main_bp.route('/admin/webtoons/milestones/result/<int:milestone_id>/export-xlsx')
 @admin_required
 def admin_webtoon_milestone_export_xlsx(milestone_id):
@@ -6892,15 +7096,7 @@ def admin_webtoon_milestone_export_xlsx(milestone_id):
         for i, w in enumerate(widths, start=1):
             ws2.column_dimensions[openpyxl.utils.get_column_letter(i)].width = w
 
-        # 3) 간트 시트 (옵션 A: 셀 배경색으로 간트 형태 생성)
-        ws3 = wb.create_sheet("간트")
-        ws3.freeze_panes = "C2"
-
-        gantt_header_fill = PatternFill("solid", fgColor="EEF2FF")
-        gantt_group_fill = PatternFill("solid", fgColor="D2E3FC")   # 회차(상위)
-        gantt_stage_fill = PatternFill("solid", fgColor="BFC5CC")   # 작업 단계(하위)
-
-        # 간트 데이터 구성: 상위(회차) + 하위(작업 단계)
+        # 3) 간트 시트 (함수로 분리)
         gantt_rows = []
         for ep in (schedule_data.get("episodes") or []):
             ep_num = ep.get("episode_num")
@@ -6929,79 +7125,95 @@ def admin_webtoon_milestone_export_xlsx(milestone_id):
                         "is_group": False,
                     })
 
-        # 날짜 범위 계산
         if gantt_rows:
             min_d = min(r["start"] for r in gantt_rows)
             max_d = max(r["end"] for r in gantt_rows)
         else:
             min_d, max_d = None, None
 
-        def _fmt_md(d):
-            return f"{d.month}/{d.day}"
-
-        # 헤더 작성
-        ws3.cell(row=1, column=1, value="회차").font = header_font
-        ws3.cell(row=1, column=2, value="작업 단계").font = header_font
-        ws3.cell(row=1, column=1).fill = gantt_header_fill
-        ws3.cell(row=1, column=2).fill = gantt_header_fill
-        ws3.cell(row=1, column=1).alignment = Alignment(horizontal="center", vertical="center")
-        ws3.cell(row=1, column=2).alignment = Alignment(horizontal="center", vertical="center")
-        ws3.column_dimensions["A"].width = 20
-        ws3.column_dimensions["B"].width = 28
-
-        # 기간이 길면 주 단위로 자동 전환(컬럼 폭 폭발 방지)
-        timeline = []
-        mode = "day"
-        if min_d and max_d:
-            total_days = (max_d - min_d).days + 1
-            if total_days > 120:
-                mode = "week"
-                # 해당 주의 월요일로 정렬
-                start_week = min_d - timedelta(days=min_d.weekday())
-                end_week = max_d - timedelta(days=max_d.weekday())
-                cur = start_week
-                while cur <= end_week:
-                    timeline.append(cur)
-                    cur += timedelta(days=7)
-            else:
-                cur = min_d
-                while cur <= max_d:
-                    timeline.append(cur)
-                    cur += timedelta(days=1)
-
-        # 타임라인 컬럼 생성
-        base_col = 3
-        for i, d in enumerate(timeline):
-            c = base_col + i
-            ws3.cell(row=1, column=c, value=_fmt_md(d)).font = header_font
-            ws3.cell(row=1, column=c).fill = gantt_header_fill
-            ws3.cell(row=1, column=c).alignment = Alignment(horizontal="center", vertical="center", text_rotation=90)
-            ws3.column_dimensions[openpyxl.utils.get_column_letter(c)].width = 3
-
-        # 간트 바 채우기
-        r_idx = 2
-        for gr in gantt_rows:
-            ws3.cell(row=r_idx, column=1, value=gr["episode"])
-            ws3.cell(row=r_idx, column=2, value=gr["stage"])
-            # 상위 행은 굵게
-            if gr["is_group"]:
-                ws3.cell(row=r_idx, column=1).font = Font(bold=True)
-            fill = gantt_group_fill if gr["is_group"] else gantt_stage_fill
-
-            if timeline:
-                for i, td in enumerate(timeline):
-                    col = base_col + i
-                    if mode == "day":
-                        cell_date = td
-                        if gr["start"] <= cell_date <= gr["end"]:
-                            ws3.cell(row=r_idx, column=col).fill = fill
-                    else:
-                        # week: td는 week start (월요일), 범위는 7일
-                        week_start = td
-                        week_end = td + timedelta(days=6)
-                        if not (gr["end"] < week_start or gr["start"] > week_end):
-                            ws3.cell(row=r_idx, column=col).fill = fill
-            r_idx += 1
+        def _create_gantt_sheet(sheet_name, view_mode):
+            """
+            view_mode: 'day' or 'week'
+            """
+            ws = wb.create_sheet(sheet_name)
+            ws.freeze_panes = "C2"
+
+            gantt_header_fill = PatternFill("solid", fgColor="EEF2FF")
+            gantt_group_fill = PatternFill("solid", fgColor="D2E3FC")
+            gantt_stage_fill = PatternFill("solid", fgColor="BFC5CC")
+
+            def _fmt_md(d):
+                return f"{d.month}/{d.day}"
+
+            # 헤더
+            ws.cell(row=1, column=1, value="회차").font = header_font
+            ws.cell(row=1, column=2, value="작업 단계").font = header_font
+            ws.cell(row=1, column=1).fill = gantt_header_fill
+            ws.cell(row=1, column=2).fill = gantt_header_fill
+            ws.cell(row=1, column=1).alignment = Alignment(horizontal="center", vertical="center")
+            ws.cell(row=1, column=2).alignment = Alignment(horizontal="center", vertical="center")
+            ws.column_dimensions["A"].width = 20
+            ws.column_dimensions["B"].width = 28
+
+            # 타임라인
+            timeline = []
+            if min_d and max_d:
+                if view_mode == "week":
+                    # 해당 주의 월요일로 정렬
+                    start_week = min_d - timedelta(days=min_d.weekday())
+                    end_week = max_d - timedelta(days=max_d.weekday())
+                    cur = start_week
+                    while cur <= end_week:
+                        timeline.append(cur)
+                        cur += timedelta(days=7)
+                else:
+                    # day
+                    cur = min_d
+                    while cur <= max_d:
+                        timeline.append(cur)
+                        cur += timedelta(days=1)
+            
+            # 타임라인 컬럼
+            base_col = 3
+            for i, d in enumerate(timeline):
+                c = base_col + i
+                ws.cell(row=1, column=c, value=_fmt_md(d)).font = header_font
+                ws.cell(row=1, column=c).fill = gantt_header_fill
+                ws.cell(row=1, column=c).alignment = Alignment(horizontal="center", vertical="center", text_rotation=90)
+                ws.column_dimensions[openpyxl.utils.get_column_letter(c)].width = 3
+
+            # 데이터 바
+            r_idx = 2
+            for gr in gantt_rows:
+                ws.cell(row=r_idx, column=1, value=gr["episode"])
+                ws.cell(row=r_idx, column=2, value=gr["stage"])
+                if gr["is_group"]:
+                    ws.cell(row=r_idx, column=1).font = Font(bold=True)
+                
+                fill = gantt_group_fill if gr["is_group"] else gantt_stage_fill
+
+                if timeline:
+                    for i, td in enumerate(timeline):
+                        col = base_col + i
+                        if view_mode == "day":
+                            cell_date = td
+                            if gr["start"] <= cell_date <= gr["end"]:
+                                ws.cell(row=r_idx, column=col).fill = fill
+                        else:
+                            # week: td는 week start (월요일), 범위는 7일
+                            week_start = td
+                            week_end = td + timedelta(days=6)
+                            if not (gr["end"] < week_start or gr["start"] > week_end):
+                                ws.cell(row=r_idx, column=col).fill = fill
+                r_idx += 1
+
+        # 두 가지 모드로 각각 생성 (요청사항: 주간과 함께 일 자료도 같이)
+        # 1) 간트(일)
+        #    데이터 양이 많으면 엑셀 컬럼 한계(16384)가 있으나, 마일스톤이 수십년이 아닌 이상 보통 OK.
+        _create_gantt_sheet("간트(일)", "day")
+
+        # 2) 간트(주)
+        _create_gantt_sheet("간트(주)", "week")
 
         # 파일명
         base = getattr(getattr(ms, "file", None), "original_filename", "") or ""

app/utils/date_utils.py

@@ -0,0 +1,66 @@
+import holidays
+from datetime import date, timedelta
+
+# 베트남 휴일 객체 생성 (캐싱)
+try:
+    vn_holidays = holidays.VN()
+except Exception as e:
+    print(f"[date_utils] 휴일 정보 로드 실패: {e}")
+    vn_holidays = {}
+
+def is_holiday(d: date) -> bool:
+    """
+    해당 날짜가 주말(토,일)이거나 베트남 공휴일인지 확인
+    """
+    # 주말 체크 (5: 토요일, 6: 일요일)
+    if d.weekday() >= 5:
+        return True
+    
+    # 공휴일 체크
+    if d in vn_holidays:
+        return True
+        
+    return False
+
+def add_business_days(start_date: date, days: int) -> date:
+    """
+    start_date로부터 days만큼의 업무일(Business Days)을 더하거나 뺀 날짜를 반환
+    - days > 0: 미래로 이동
+    - days < 0: 과거로 이동
+    - days == 0: start_date가 휴일이면 다음 업무일(미래 방향) 반환, 아니면 그대로 반환
+    """
+    current_date = start_date
+    
+    # 0일인 경우: 시작일이 휴일이면 평일이 나올 때까지 전진
+    if days == 0:
+        while is_holiday(current_date):
+            current_date += timedelta(days=1)
+        return current_date
+
+    # 이동 방향 설정
+    step = 1 if days > 0 else -1
+    days_left = abs(days)
+    
+    while days_left > 0:
+        current_date += timedelta(days=step)
+        # 휴일이면 카운트하지 않음 (건너뜀)
+        if not is_holiday(current_date):
+            days_left -= 1
+            
+    return current_date
+
+def get_holidays_in_range(start_date: date, end_date: date) -> list:
+    """
+    start_date ~ end_date (inclusive) 기간 내의 휴일 목록(date 객체) 반환
+    """
+    holidays_list = []
+    # 날짜 순서 보정
+    if start_date > end_date:
+        start_date, end_date = end_date, start_date
+        
+    curr = start_date
+    while curr <= end_date:
+        if is_holiday(curr):
+            holidays_list.append(curr)
+        curr += timedelta(days=1)
+    return holidays_list

check_milestone_table.py

@@ -0,0 +1,33 @@
+import sys
+import os
+# Add project root to path
+sys.path.append(os.getcwd())
+
+from sqlalchemy import create_engine, inspect
+try:
+    from app.core.config import Config
+except ImportError:
+    # Fallback if app module not found or dependencies missing
+    print("Could not import app.core.config. Using direct path.")
+    Config = None
+
+if Config:
+    db_uri = Config.SQLALCHEMY_DATABASE_URI
+else:
+    # Direct guess
+    db_uri = f'sqlite:///{os.path.join(os.getcwd(), "instance", "finance_analysis.db")}'
+
+print(f"Checking DB: {db_uri}")
+
+try:
+    engine = create_engine(db_uri)
+    insp = inspect(engine)
+    if insp.has_table('webtoon_milestone'):
+        print("Table 'webtoon_milestone' exists.")
+        cols = [c['name'] for c in insp.get_columns('webtoon_milestone')]
+        print(f"Columns: {cols}")
+    else:
+        print("Table 'webtoon_milestone' NOT found.")
+except Exception as e:
+    print(f"Error: {e}")
+

migrate_fix_user_schema.py

@@ -0,0 +1,58 @@
+import sqlite3
+import os
+from pathlib import Path
+
+def migrate_db(db_path):
+    print(f"Checking {db_path}...")
+    try:
+        conn = sqlite3.connect(db_path)
+        cursor = conn.cursor()
+        
+        # Check if user table exists
+        cursor.execute("SELECT name FROM sqlite_master WHERE type='table' AND name='user'")
+        if not cursor.fetchone():
+            print("  - 'user' table not found.")
+            conn.close()
+            return
+
+        # Check columns
+        cursor.execute("PRAGMA table_info(user)")
+        columns = [row[1] for row in cursor.fetchall()]
+        print(f"  - Current columns: {columns}")
+        
+        # Add role column
+        if 'role' not in columns:
+            print("  - Adding 'role' column...")
+            try:
+                cursor.execute("ALTER TABLE user ADD COLUMN role VARCHAR(20) DEFAULT 'user' NOT NULL")
+                conn.commit()
+                print("  - 'role' added.")
+            except Exception as e:
+                print(f"  - Failed to add 'role': {e}")
+        else:
+            print("  - 'role' column already exists.")
+
+        # Add must_change_password column
+        if 'must_change_password' not in columns:
+            print("  - Adding 'must_change_password' column...")
+            try:
+                cursor.execute("ALTER TABLE user ADD COLUMN must_change_password BOOLEAN DEFAULT 0 NOT NULL")
+                conn.commit()
+                print("  - 'must_change_password' added.")
+            except Exception as e:
+                print(f"  - Failed to add 'must_change_password': {e}")
+        else:
+            print("  - 'must_change_password' column already exists.")
+            
+        conn.close()
+    except Exception as e:
+        print(f"  - Error: {e}")
+
+if __name__ == "__main__":
+    base_dir = Path("instance")
+    if not base_dir.exists():
+        print("instance directory not found.")
+    else:
+        for f in base_dir.glob("*.db"):
+            migrate_db(str(f))
+

requirements.txt

@@ -19,4 +19,5 @@ openpyxl==3.1.5
 psycopg2-binary  # PostgreSQL support for external database
 # Ollama와 파이썬을 연결하려면 아래 패키지가 보통 필요합니다.
 ollama
+holidays
 

reset_admin_menu.py

@@ -0,0 +1,15 @@
+from app import create_app, db
+from app.models.models import SystemConfig
+
+app = create_app()
+
+with app.app_context():
+    ADMIN_MENU_CONFIG_KEY = "admin_menu_config_v1"
+    config = SystemConfig.query.filter_by(key=ADMIN_MENU_CONFIG_KEY).first()
+    if config:
+        db.session.delete(config)
+        db.session.commit()
+        print(f"[{ADMIN_MENU_CONFIG_KEY}] 메뉴 설정이 삭제되었습니다. 기본 메뉴가 다시 로드됩니다.")
+    else:
+        print(f"[{ADMIN_MENU_CONFIG_KEY}] 저장된 메뉴 설정이 없습니다.")
+

templates/admin_webtoon_milestone_detail_holidays.html

@@ -0,0 +1,515 @@
+<!DOCTYPE html>
+<html lang="ko">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>마일스톤 상세 (휴일 반영) - SOY NV AI</title>
+    <!-- Fonts & Icons -->
+    <link rel="preconnect" href="https://fonts.googleapis.com" crossorigin>
+    <link href="https://fonts.googleapis.com/css2?family=Inter:wght@400;500;600&display=swap" rel="stylesheet">
+    <!-- Frappe Gantt -->
+    <script src="https://cdn.jsdelivr.net/npm/frappe-gantt@0.6.1/dist/frappe-gantt.min.js"></script>
+    <link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/frappe-gantt@0.6.1/dist/frappe-gantt.css">
+    
+    <style>
+        /* 기본 스타일 및 초기화 */
+        :root{
+            --bg:#f6f7fb;--card:#fff;--text:#202124;--muted:#5f6368;--border:#e5e7eb;--border-strong:#dadce0;
+            --primary:#1a73e8;--primary-hover:#1557b0;
+            --danger:#c5221f;
+            
+            /* 차트 레이아웃 상수 */
+            --header-height: 60px;
+            --row-height: 40px; 
+            --side-top-offset: 0px; 
+        }
+        *{margin:0;padding:0;box-sizing:border-box}
+        body{
+            font-family:'Inter', -apple-system, BlinkMacSystemFont,'Segoe UI',Roboto,sans-serif;
+            background: var(--bg);
+            color:var(--text);
+            overflow-x:hidden;
+            height: 100vh;
+            display: flex;
+            flex-direction: column;
+        }
+        
+        .layout-container { display: flex; flex: 1; overflow: hidden; }
+        .sidebar { width: 260px; background: #fff; border-right: 1px solid var(--border); display: flex; flex-direction: column; z-index: 50; }
+        .sidebar-header { padding: 16px 24px; font-weight: 600; font-size: 14px; color: var(--muted); border-bottom: 1px solid var(--border); }
+        .sidebar-content { flex: 1; overflow-y: auto; padding: 12px 0; }
+        
+        .main-content { flex: 1; display: flex; flex-direction: column; overflow: hidden; }
+        .content-scroll { flex: 1; overflow-y: auto; padding: 24px; }
+
+        .sidebar-item { padding: 10px 24px; cursor: pointer; display: flex; align-items: center; justify-content: space-between; text-decoration: none; color: var(--text); font-size: 14px; }
+        .sidebar-item:hover { background: #f8f9fa; }
+        .sidebar-item.active { background: #e8f0fe; color: var(--primary); font-weight: 600; }
+
+        .card { background: var(--card); border: 1px solid var(--border); border-radius: 8px; margin-bottom: 24px; display: flex; flex-direction: column; }
+        .card-header { padding: 16px 24px; border-bottom: 1px solid var(--border); display: flex; justify-content: space-between; align-items: center; }
+        .card-title { font-size: 16px; font-weight: 700; }
+        
+        .btn { padding: 8px 14px; border: 1px solid var(--border); border-radius: 6px; font-size: 13px; font-weight: 600; cursor: pointer; background: #fff; color: var(--text); text-decoration: none; display: inline-block; text-align: center;}
+        .btn-primary { background: var(--primary); border-color: var(--primary); color: #fff; }
+        .btn.active { background: var(--primary); color: #fff; border-color: var(--primary); }
+
+        .gantt-wrapper {
+            display: flex;
+            border: 1px solid var(--border);
+            border-radius: 8px;
+            background: #fff;
+            height: 600px;
+            overflow: hidden;
+            position: relative;
+        }
+        
+        .gantt-side {
+            width: 220px;
+            background: #fff;
+            border-right: 1px solid #e0e0e0;
+            display: flex;
+            flex-direction: column;
+            flex-shrink: 0;
+            z-index: 20;
+        }
+        .gantt-side-header {
+            height: var(--header-height);
+            border-bottom: 1px solid #e0e0e0;
+            background: #f8f9fa;
+            display: flex;
+            align-items: center;
+            justify-content: center;
+            font-weight: 600;
+            font-size: 13px;
+            color: #5f6368;
+            box-sizing: border-box;
+            flex-shrink: 0;
+        }
+        .gantt-side-list {
+            flex: 1;
+            overflow: hidden;
+            background: #fff;
+            padding-top: var(--side-top-offset);
+        }
+        .gantt-side-item {
+            height: var(--row-height);
+            line-height: var(--row-height);
+            padding: 0 16px;
+            font-size: 13px;
+            color: #374151;
+            white-space: nowrap;
+            overflow: hidden;
+            text-overflow: ellipsis;
+            border-bottom: 1px solid #f1f3f4;
+            box-sizing: border-box;
+        }
+        .gantt-side-item.group {
+            font-weight: 700;
+            background-color: #f8f9fa;
+            color: #1a73e8;
+        }
+        .gantt-side-item.holiday {
+            color: var(--danger);
+            font-style: italic;
+            background-color: #fff5f5;
+        }
+        .gantt-side-item:not(.group) {
+            padding-left: 32px;
+        }
+
+        .gantt-right-col {
+            flex: 1;
+            display: flex;
+            flex-direction: column;
+            overflow: hidden;
+            position: relative;
+        }
+        
+        .gantt-chart-container {
+            flex: 1;
+            overflow: auto;
+            position: relative;
+        }
+        
+        .gantt .grid-header { fill: #f8f9fa; }
+        .gantt .grid-row { fill: #fff; }
+        .gantt .grid-row:nth-child(even) { fill: #fbfbff; }
+        .gantt .grid-row.group-row { fill: #eef4ff !important; }
+        .gantt .bar-label { fill: #202124; font-size: 12px; font-weight: 600; }
+        .gantt .bar-wrapper.group .bar { fill: #d2e3fc; stroke: #8ab4f8; opacity: 1; }
+        
+        /* 휴일 바 스타일 */
+        .gantt .bar-wrapper.holiday .bar { fill: #ffcdd2; stroke: #ef9a9a; stroke-dasharray: 4,2; }
+        .gantt .bar-wrapper.holiday .bar-label { fill: #c62828; font-style: italic; }
+
+        .info-grid { display: grid; grid-template-columns: repeat(4, 1fr); gap: 16px; margin-bottom: 24px; }
+        .info-item { background: #fff; padding: 16px; border-radius: 8px; border: 1px solid var(--border); }
+        .info-label { font-size: 12px; color: var(--muted); margin-bottom: 6px; }
+        .info-value { font-size: 15px; font-weight: 600; color: #202124; }
+        
+        .holiday-badge {
+            display: inline-block;
+            padding: 2px 8px;
+            border-radius: 4px;
+            background: #ffebee;
+            color: #c62828;
+            font-size: 11px;
+            font-weight: 600;
+            margin-left: 8px;
+            border: 1px solid #ffcdd2;
+        }
+    </style>
+</head>
+<body>
+    {% set admin_nav_title = '프로젝트 관리' %}
+    {% include '_admin_nav.html' %}
+    
+    <div class="layout-container">
+        <!-- 사이드바 -->
+        <div class="sidebar">
+            <div class="sidebar-header">프로젝트 목록</div>
+            <div class="sidebar-content">
+                {% for f in files %}
+                <a href="{% if f.milestones %}/admin/webtoons/milestones/result/{{ f.milestones[-1].id }}{% else %}#{% endif %}" 
+                   class="sidebar-item {% if f.id == milestone.file_id %}active{% endif %}"
+                   {% if not f.milestones %}onclick="alert('생성된 마일스톤이 없습니다.'); return false;"{% endif %}>
+                    <span>{{ f.original_filename }}</span>
+                    {% if f.milestones %}<span style="font-size:10px; color:var(--primary);">●</span>{% endif %}
+                </a>
+                {% endfor %}
+            </div>
+            <div style="padding: 16px; border-top:1px solid var(--border);">
+                <a href="/admin/webtoons/milestones" class="btn btn-primary" style="display:block; width:100%;">새 마일스톤 생성</a>
+            </div>
+        </div>
+
+        <!-- 메인 컨텐츠 -->
+        <div class="main-content">
+            <div class="content-scroll">
+                <div style="margin-bottom:24px; display:flex; justify-content:space-between; align-items:flex-end;">
+                    <div>
+                        <h1 style="font-size:22px; font-weight:700; margin-bottom:8px;">
+                            {{ milestone.file.original_filename }}
+                            <span class="holiday-badge">베트남 휴일 반영됨</span>
+                        </h1>
+                        <div style="font-size:13px; color:var(--muted);">
+                            마일스톤 상세 ({{ milestone.created_at.strftime('%Y-%m-%d') }})
+                        </div>
+                    </div>
+                    <div>
+                        <a class="btn" href="/admin/webtoons/milestones/result/{{ milestone.id }}/export-xlsx">엑셀 저장</a>
+                    </div>
+                </div>
+
+                <div class="info-grid">
+                    <div class="info-item"><div class="info-label">입력 기준</div><div class="info-value">{{ milestone.basis }}</div></div>
+                    <div class="info-item"><div class="info-label">회차 착수 간격</div><div class="info-value">{{ milestone.cadence_days }}일</div></div>
+                    <div class="info-item"><div class="info-label">0화 / 기획 소요</div><div class="info-value">{{ milestone.ep0_days }}일 / {{ milestone.plan_days }}일</div></div>
+                    <div class="info-item"><div class="info-label">런칭 예정일</div><div class="info-value">{{ milestone.launch_date }}</div></div>
+                </div>
+
+                <div class="card" style="height: calc(100vh - 350px); min-height: 500px;">
+                    <div class="card-header">
+                        <div class="card-title">제작 공정표 (Gantt) - 휴일/주말 포함</div>
+                        <div class="view-controls" style="display:flex; gap:8px; align-items:center;">
+                            <button class="btn active" data-mode="Day" onclick="changeViewMode('Day')">Day</button>
+                            <button class="btn" data-mode="Week" onclick="changeViewMode('Week')">Week</button>
+                            <button class="btn" data-mode="Month" onclick="changeViewMode('Month')">Month</button>
+                        </div>
+                    </div>
+                    <div class="gantt-wrapper">
+                        <div class="gantt-side">
+                            <div class="gantt-side-header">Task Name</div>
+                            <div class="gantt-side-list" id="ganttSideList"></div>
+                        </div>
+                        <div class="gantt-right-col">
+                            <div class="gantt-chart-container" id="ganttContainer">
+                                <svg id="gantt"></svg>
+                            </div>
+                        </div>
+                    </div>
+                </div>
+            </div>
+        </div>
+    </div>
+
+    <script id="scheduleDataJson" type="application/json">{{ schedule | tojson }}</script>
+    <script>
+        const scheduleDataEl = document.getElementById('scheduleDataJson');
+        const scheduleData = scheduleDataEl && scheduleDataEl.textContent
+            ? JSON.parse(scheduleDataEl.textContent)
+            : {};
+        let gantt = null;
+        let stageKeyMap = {};
+        let currentViewMode = 'Day';
+        let translationInterval = null;
+        let holidayDates = [];
+        
+        const HEADER_HEIGHT = 60;
+        const BAR_HEIGHT = 25;
+        const PADDING = 15;
+        
+        async function init() {
+            try {
+                // 1. 단계키 매핑 로드
+                const resKeys = await fetch('/api/webtoons/stage-keys');
+                const dataKeys = await resKeys.json();
+                if(dataKeys.mappings) {
+                    dataKeys.mappings.forEach(m => { stageKeyMap[m.stage_key] = m.label; });
+                }
+                
+                // 2. 휴일 목록 로드
+                const resHolidays = await fetch(`/api/webtoons/milestones/{{ milestone.id }}/holidays`);
+                const dataHolidays = await resHolidays.json();
+                holidayDates = dataHolidays.holidays || [];
+                
+            } catch(e) {
+                console.error('Data load failed', e);
+            }
+            renderGanttChart();
+        }
+
+        function getStageName(key) {
+            if (key === '00') return '0화 분석 및 기획';
+            if (key === '01') return '01. 기획/각색';
+            return stageKeyMap[key] || key;
+        }
+
+        function renderGanttChart() {
+            if (!scheduleData || !scheduleData.episodes) return;
+            
+            const tasks = [];
+            scheduleData.episodes.forEach(ep => {
+                const epId = `ep-${ep.episode_num}`;
+                const epName = ep.episode_num === 0 ? '0화 (Pre-production)' : `${ep.episode_num}화`;
+                
+                tasks.push({
+                    id: epId,
+                    name: epName,
+                    start: ep.start_date,
+                    end: ep.end_date,
+                    progress: 0,
+                    custom_class: 'group',
+                    level: 'group'
+                });
+
+                // 해당 회차 기간 내의 휴일 찾기
+                const epStart = new Date(ep.start_date);
+                const epEnd = new Date(ep.end_date);
+                
+                // 휴일들을 연속된 블록으로 묶기
+                let currentHolidayBlock = null;
+                
+                const epHolidays = holidayDates.filter(dStr => {
+                    const d = new Date(dStr);
+                    return d >= epStart && d <= epEnd;
+                }).sort();
+
+                epHolidays.forEach((hStr, idx) => {
+                    const d = new Date(hStr);
+                    if (!currentHolidayBlock) {
+                        currentHolidayBlock = { start: hStr, end: hStr };
+                    } else {
+                        const prevEnd = new Date(currentHolidayBlock.end);
+                        const diff = (d - prevEnd) / (1000 * 3600 * 24);
+                        if (diff <= 1.1) { // 연속된 날짜 (또는 거의 연속)
+                            currentHolidayBlock.end = hStr;
+                        } else {
+                            // 블록 종료 및 새 블록 시작
+                            tasks.push({
+                                id: `${epId}-h-${idx}`,
+                                name: '휴일 (주말/공휴일)',
+                                start: currentHolidayBlock.start,
+                                end: currentHolidayBlock.end,
+                                progress: 0,
+                                custom_class: 'holiday',
+                                level: 'holiday'
+                            });
+                            currentHolidayBlock = { start: hStr, end: hStr };
+                        }
+                    }
+                });
+                if (currentHolidayBlock) {
+                    tasks.push({
+                        id: `${epId}-h-last`,
+                        name: '휴일 (주말/공휴일)',
+                        start: currentHolidayBlock.start,
+                        end: currentHolidayBlock.end,
+                        progress: 0,
+                        custom_class: 'holiday',
+                        level: 'holiday'
+                    });
+                }
+
+                if (ep.stages) {
+                    ep.stages.forEach((st, idx) => {
+                        tasks.push({
+                            id: `${epId}-s-${idx}`,
+                            name: getStageName(st.stage_key),
+                            start: st.start_date,
+                            end: st.end_date,
+                            progress: 0,
+                            custom_class: 'stage',
+                            level: 'item'
+                        });
+                    });
+                }
+            });
+
+            // 정렬: group -> item -> holiday 순으로 보이면 좋겠지만 Frappe Gantt는 입력 순서 유지
+            // 회차 내에서 item -> holiday 순으로 나오게 함 (위에서 item을 뒤에 넣음)
+
+            gantt = new Gantt("#gantt", tasks, {
+                header_height: HEADER_HEIGHT,
+                column_width: currentViewMode === 'Day' ? 32 : 38,
+                step: 24,
+                view_modes: ['Quarter Day', 'Half Day', 'Day', 'Week', 'Month'],
+                bar_height: BAR_HEIGHT,
+                bar_corner_radius: 4,
+                arrow_curve: 5,
+                padding: PADDING,
+                view_mode: currentViewMode,
+                date_format: 'YYYY-MM-DD',
+                popup_trigger: 'click'
+            });
+
+            setupLayout();
+            
+            const container = document.getElementById('ganttContainer');
+            const sideList = document.getElementById('ganttSideList');
+            container.onscroll = function() {
+                sideList.scrollTop = container.scrollTop;
+            };
+        }
+
+        function setupLayout() {
+            const svg = document.getElementById('gantt');
+            if(!svg) return;
+
+            svg.style.marginTop = '0px';
+            syncSideMetricsFromSvg(svg);
+            applyGroupRowBackground(svg);
+            expandGroupBarsToRow(svg);
+            
+            const list = document.getElementById('ganttSideList');
+            list.innerHTML = '';
+            
+            gantt.tasks.forEach(t => {
+                const div = document.createElement('div');
+                div.className = `gantt-side-item ${t.level === 'group' ? 'group' : ''} ${t.level === 'holiday' ? 'holiday' : ''}`;
+                div.textContent = t.name;
+                div.title = t.name;
+                list.appendChild(div);
+            });
+
+            startTranslationLoop();
+        }
+
+        function applyGroupRowBackground(svg) {
+            try {
+                const rows = svg.querySelectorAll('.grid-row');
+                if (!rows || !rows.length || !gantt || !gantt.tasks) return;
+                const n = Math.min(rows.length, gantt.tasks.length);
+                for (let i = 0; i < n; i++) {
+                    const isGroup = gantt.tasks[i] && gantt.tasks[i].level === 'group';
+                    rows[i].classList.toggle('group-row', !!isGroup);
+                }
+            } catch (e) {}
+        }
+
+        function expandGroupBarsToRow(svg) {
+            try {
+                const rows = svg.querySelectorAll('.grid-row');
+                if (!rows || !rows.length || !gantt || !gantt.tasks) return;
+                const n = Math.min(rows.length, gantt.tasks.length);
+
+                for (let i = 0; i < n; i++) {
+                    const task = gantt.tasks[i];
+                    if (!task || task.level !== 'group') continue;
+
+                    const row = rows[i];
+                    const rowY = parseFloat(row.getAttribute('y') || '0');
+                    const rowH = parseFloat(row.getAttribute('height') || '0');
+                    if (!rowH || Number.isNaN(rowY) || Number.isNaN(rowH)) continue;
+
+                    const wrapper = svg.querySelector(`.bar-wrapper[data-id="${task.id}"]`);
+                    if (!wrapper) continue;
+
+                    const targetY = rowY + 1;
+                    const targetH = Math.max(1, rowH - 2);
+
+                    const bar = wrapper.querySelector('rect.bar');
+                    if (bar) { bar.setAttribute('y', String(targetY)); bar.setAttribute('height', String(targetH)); }
+                    const label = wrapper.querySelector('text.bar-label');
+                    if (label) { label.setAttribute('dominant-baseline', 'middle'); label.setAttribute('y', String(rowY + rowH / 2)); }
+                }
+            } catch (e) {}
+        }
+
+        function syncSideMetricsFromSvg(svg) {
+            try {
+                const firstGridRow = svg.querySelector('.grid-row');
+                if (!firstGridRow) return;
+                const h = parseFloat(firstGridRow.getAttribute('height') || 0);
+                if (h) document.documentElement.style.setProperty('--row-height', `${h}px`);
+                const y = parseFloat(firstGridRow.getAttribute('y') || 0);
+                if (!Number.isNaN(y)) {
+                    const offset = Math.max(0, y - HEADER_HEIGHT);
+                    document.documentElement.style.setProperty('--side-top-offset', `${offset}px`);
+                }
+            } catch (e) {}
+        }
+
+        function startTranslationLoop() {
+            if (translationInterval) clearInterval(translationInterval);
+            const svg = document.getElementById('gantt');
+            translateHeader(svg);
+            let count = 0;
+            translationInterval = setInterval(() => {
+                translateHeader(document.getElementById('gantt'));
+                count++;
+                if(count > 20) clearInterval(translationInterval);
+            }, 200);
+        }
+
+        function translateHeader(targetSvg) {
+            if(!targetSvg) return;
+            const texts = targetSvg.querySelectorAll('.grid-header text, g.date text, .date text');
+            const monthMap = {
+                'January': '1월', 'February': '2월', 'March': '3월', 'April': '4월', 'May': '5월', 'June': '6월',
+                'July': '7월', 'August': '8월', 'September': '9월', 'October': '10월', 'November': '11월', 'December': '12월',
+                'Jan': '1월', 'Feb': '2월', 'Mar': '3월', 'Apr': '4월', 'Jun': '6월', 'Jul': '7월', 'Aug': '8월', 'Sep': '9월', 'Oct': '10월', 'Nov': '11월', 'Dec': '12월'
+            };
+            texts.forEach(t => {
+                let txt = t.textContent.trim();
+                if(!txt) return;
+                txt = txt.replace(/^(\d{1,2})\s*([a-zA-Z]+)$/, (m, d, mon) => {
+                    const monKey = Object.keys(monthMap).find(x => mon.toLowerCase().startsWith(x.slice(0,3).toLowerCase()));
+                    return monKey ? `${monthMap[monKey]} ${parseInt(d, 10)}일` : m;
+                });
+                txt = txt.replace(/^([a-zA-Z]+)\s*(\d{4})$/, (m, mon, y) => {
+                    const monKey = Object.keys(monthMap).find(x => mon.toLowerCase().startsWith(x.slice(0,3).toLowerCase()));
+                    return monKey ? `${y}년 ${monthMap[monKey]}` : m;
+                });
+                Object.keys(monthMap).forEach(en => { if(txt === en) txt = monthMap[en]; });
+                txt = txt.replace(/^\d{1,2}$/, (m) => `${parseInt(m, 10)}일`);
+                if (t.textContent !== txt) t.textContent = txt;
+            });
+        }
+
+        function changeViewMode(mode) {
+            if(!gantt) return;
+            currentViewMode = mode;
+            gantt.change_view_mode(mode);
+            document.querySelectorAll('.view-controls .btn').forEach(b => b.classList.remove('active'));
+            const activeBtn = document.querySelector(`.view-controls .btn[data-mode="${mode}"]`);
+            if (activeBtn) activeBtn.classList.add('active');
+            setupLayout();
+        }
+
+        init();
+    </script>
+</body>
+</html>
+

templates/admin_webtoon_milestones.html

@@ -47,28 +47,36 @@
             <table>
                 <thead>
                     <tr>
-                        <th style="width: 60px;">ID</th>
-                        <th>제목 (파일명)</th>
-                        <th style="width: 150px;">업로드 일시</th>
-                        <th style="width: 120px;">작업</th>
+                        <th style="width: 60px; text-align: center;">ID</th>
+                        <th style="text-align: left;">제목 (파일명)</th>
+                        <th style="width: 150px; text-align: center;">업로드 일시</th>
+                        <th style="width: 200px; text-align: center;">작업</th>
+                        <th style="width: 180px; text-align: center;">확인</th>
                     </tr>
                 </thead>
                 <tbody>
                     {% for file in files %}
                     <tr>
-                        <td>{{ file.id }}</td>
+                        <td style="text-align: center;">{{ file.id }}</td>
                         <td style="font-weight:500;">{{ file.original_filename }}</td>
-                        <td style="color:var(--muted);">{{ file.uploaded_at.strftime('%Y-%m-%d %H:%M') }}</td>
-                        <td>
+                        <td style="text-align: center; color:var(--muted);">{{ file.uploaded_at.strftime('%Y-%m-%d %H:%M') }}</td>
+                        <td style="text-align: center;">
+                            <button class="btn btn-primary" onclick="openCreateModal({{ file.id }}, '{{ file.original_filename }}')">생성</button>
+                            <button class="btn" style="background:#e8f0fe; color:#1a73e8; margin-left:4px;" onclick="openCreateModal({{ file.id }}, '{{ file.original_filename }}', true)">생성(휴일)</button>
+                        </td>
+                        <td style="text-align: center;">
                             {% if file.milestones %}
-                                <button class="btn btn-secondary" onclick="location.href='/admin/webtoons/milestones/result/{{ file.milestones[-1].id }}'">확인</button>
+                                {% set latest_ms = file.milestones|sort(attribute='created_at', reverse=True)|first %}
+                                <a href="{{ url_for('main.admin_webtoon_milestone_result', milestone_id=latest_ms.id) }}" class="btn" style="background:#e6f4ea; color:#1e8e3e; padding:6px 10px; font-size:12px; display:inline-block;">확인</a>
+                                <a href="{{ url_for('main.admin_webtoon_milestone_result_holidays', milestone_id=latest_ms.id) }}" class="btn" style="background:#fce8e6; color:#d93025; padding:6px 10px; font-size:12px; margin-left:4px; display:inline-block;">확인(휴일)</a>
+                            {% else %}
+                                <span style="color:#bdc1c6; font-size:12px;">-</span>
                             {% endif %}
-                            <button class="btn btn-primary" onclick="openCreateModal({{ file.id }}, '{{ file.original_filename }}')">생성</button>
                         </td>
                     </tr>
                     {% else %}
                     <tr>
-                        <td colspan="4">
+                        <td colspan="5">
                             <div class="empty-state">
                                 공개 설정된 웹소설이 없습니다.<br>
                                 <small>웹소설 관리 메뉴에서 공개 여부를 확인해주세요.</small>
@@ -85,7 +93,7 @@
     <div id="createModal" style="display:none; position:fixed; top:0; left:0; width:100%; height:100%; background:rgba(0,0,0,0.5); z-index:10000; align-items:center; justify-content:center;">
         <div style="background:#fff; width:90%; max-width:500px; border-radius:12px; padding:24px; box-shadow:0 10px 25px rgba(0,0,0,0.2);">
             <div style="display:flex; justify-content:space-between; margin-bottom:20px;">
-                <h3 style="margin:0; font-size:18px;">마일스톤 생성</h3>
+                <h3 class="modal-title" style="margin:0; font-size:18px;">마일스톤 생성</h3>
                 <button onclick="closeModal()" style="background:none; border:none; font-size:20px; cursor:pointer;">&times;</button>
             </div>
             
@@ -128,8 +136,9 @@
             </div>
 
             <div style="margin-top:24px; display:flex; justify-content:flex-end; gap:8px;">
+                <input type="hidden" id="applyHolidaysInput" value="false">
                 <button onclick="closeModal()" class="btn" style="background:#f1f3f4; color:#333;">취소</button>
-                <button onclick="submitCreate()" class="btn btn-primary">생성하기</button>
+                <button onclick="submitCreate()" class="btn btn-primary" id="submitBtn">생성하기</button>
             </div>
         </div>
     </div>
@@ -142,6 +151,9 @@
         const planInput = document.getElementById('planInput');
         const launchDateInput = document.getElementById('launchDateInput');
 
+        const submitBtn = document.getElementById('submitBtn');
+        const applyHolidaysInput = document.getElementById('applyHolidaysInput');
+
         // 초기 설정값 로드
         async function loadDefaults() {
             try {
@@ -161,9 +173,19 @@
         }
         loadDefaults();
 
-        function openCreateModal(fileId, fileName) {
+        function openCreateModal(fileId, fileName, useHolidays = false) {
             fileIdInput.value = fileId;
             fileNameInput.value = fileName;
+            
+            applyHolidaysInput.value = useHolidays ? 'true' : 'false';
+            if (useHolidays) {
+                submitBtn.textContent = '생성하기 (휴일적용)';
+                document.querySelector('.modal-title').textContent = '마일스톤 생성 (베트남 휴일 반영)';
+            } else {
+                submitBtn.textContent = '생성하기';
+                document.querySelector('.modal-title').textContent = '마일스톤 생성';
+            }
+            
             modal.style.display = 'flex';
         }
 
@@ -182,7 +204,8 @@
                     cadence_days: document.getElementById('cadenceInput').value,
                     ep0_days: ep0Input.value,
                     plan_days: planInput.value,
-                    launch_date: launchDateInput.value
+                    launch_date: launchDateInput.value,
+                    apply_holidays: applyHolidaysInput.value === 'true'
                 };
                 
                 if (!payload.launch_date) {
@@ -200,7 +223,12 @@
                 if (!res.ok) throw new Error(data.error || '생성 실패');
                 
                 alert('마일스톤이 생성되었습니다.');
-                window.location.href = `/admin/webtoons/milestones/result/${data.id}`;
+                
+                let redirectUrl = `/admin/webtoons/milestones/result/${data.id}`;
+                if (data.apply_holidays) {
+                    redirectUrl = `/admin/webtoons/milestones/result-holidays/${data.id}`;
+                }
+                window.location.href = redirectUrl;
             } catch (e) {
                 alert('오류: ' + e.message);
             }