refactor(tkeg): print→logging 교체 + 레거시 파일 정리 (-5,447줄)

- 6개 파일 디버그 print문 102건 → logger.info/warning/error 교체
- DashboardPage.old.jsx 삭제 (미사용)
- NewMaterialsPage.jsx/css 삭제 (dead import)
- spool_manager_v2.py 삭제 (미사용)
- App.jsx dead import 제거
- main.py 구 주석 블록 제거

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

tkeg/api/app/services/excel_parser.py

@@ -1,3 +1,4 @@
+import logging
 
 import pandas as pd
 import re
@@ -6,6 +7,8 @@ import uuid
 from datetime import datetime
 from pathlib import Path
 
+logger = logging.getLogger(__name__)
+
 # 허용된 확장자
 ALLOWED_EXTENSIONS = {".xlsx", ".xls", ".csv"}
 
@@ -72,7 +75,7 @@ class BOMParser:
             
             # 양식 감지
             format_type = cls.detect_format(df)
-            print(f"📋 감지된 BOM 양식: {format_type}")
+            logger.info(f"감지된 BOM 양식: {format_type}")
             
             if format_type == 'INVENTOR':
                 return cls._parse_inventor_bom(df)
@@ -109,7 +112,7 @@ class BOMParser:
                     mapped_columns[standard_col] = possible_upper
                     break
         
-        print(f"📋 [Standard] 컬럼 매핑 결과: {mapped_columns}")
+        logger.info(f"[Standard] 컬럼 매핑 결과: {mapped_columns}")
         
         materials = []
         for index, row in df.iterrows():
@@ -190,7 +193,7 @@ class BOMParser:
         헤더: NO., NAME, Q'ty, LENGTH & THICKNESS, WEIGHT, DESCIPTION, REMARK
         특징: Size 컬럼 부재, NAME에 주요 정보 포함
         """
-        print("⚠️ [Inventor] 인벤터 양식 파서를 사용합니다.")
+        logger.warning("[Inventor] 인벤터 양식 파서를 사용합니다.")
         
         # 컬럼명 전처리 (좌우 공백 제거 및 대문자화)
         df.columns = df.columns.str.strip().str.upper()

tkeg/api/app/services/material_grade_extractor.py

@@ -3,9 +3,12 @@
 원본 설명에서 완전한 재질명을 추출하여 축약되지 않은 형태로 제공
 """
 
+import logging
 import re
 from typing import Optional, Dict
 
+logger = logging.getLogger(__name__)
+
 def extract_full_material_grade(description: str) -> str:
     """
     원본 설명에서 전체 재질명 추출
@@ -196,7 +199,7 @@ def update_full_material_grades(db, batch_size: int = 1000) -> Dict:
         count_query = text("SELECT COUNT(*) FROM materials WHERE full_material_grade IS NULL OR full_material_grade = ''")
         total_count = db.execute(count_query).scalar()
         
-        print(f"📊 업데이트 대상 자재: {total_count}개")
+        logger.info(f"업데이트 대상 자재: {total_count}개")
         
         updated_count = 0
         processed_count = 0
@@ -244,7 +247,7 @@ def update_full_material_grades(db, batch_size: int = 1000) -> Dict:
             db.commit()
             offset += batch_size
             
-            print(f"📈 진행률: {processed_count}/{total_count} ({processed_count/total_count*100:.1f}%)")
+            logger.info(f"진행률: {processed_count}/{total_count} ({processed_count/total_count*100:.1f}%)")
         
         return {
             "total_processed": processed_count,
@@ -254,7 +257,7 @@ def update_full_material_grades(db, batch_size: int = 1000) -> Dict:
         
     except Exception as e:
         db.rollback()
-        print(f"❌ 업데이트 실패: {str(e)}")
+        logger.error(f"업데이트 실패: {str(e)}")
         return {
             "total_processed": 0,
             "updated_count": 0,

tkeg/api/app/services/material_service.py

@@ -1,3 +1,4 @@
+import logging
 
 from sqlalchemy.orm import Session
 from sqlalchemy import text
@@ -18,6 +19,8 @@ from app.services.structural_classifier import classify_structural
 from app.services.pipe_classifier import classify_pipe_for_purchase, extract_end_preparation_info
 from app.services.material_grade_extractor import extract_full_material_grade
 
+logger = logging.getLogger(__name__)
+
 class MaterialService:
     """자재 처리 및 저장을 담당하는 서비스"""
 
@@ -70,7 +73,7 @@ class MaterialService:
         if revision_comparison and revision_comparison.get("materials_to_classify"):
             materials_to_classify = revision_comparison.get("materials_to_classify")
             
-        print(f"🔧 자재 분류 및 저장 시작: {len(materials_to_classify)}개")
+        logger.info(f"자재 분류 및 저장 시작: {len(materials_to_classify)}개")
         
         for material_data in materials_to_classify:
             MaterialService._classify_and_save_single_material(
@@ -116,7 +119,7 @@ class MaterialService:
                     new_keys.add(new_key)
                     
         except Exception as e:
-            print(f"❌ 변경사항 분석 실패: {e}")
+            logger.error(f"변경사항 분석 실패: {e}")
 
     @staticmethod
     def _generate_material_key(dwg, line, desc, size, grade):
@@ -332,7 +335,7 @@ class MaterialService:
     def inherit_purchase_requests(db: Session, current_file_id: int, parent_file_id: int):
         """이전 리비전의 구매신청 정보를 상속합니다."""
         try:
-            print(f"🔄 구매신청 정보 상속 처리 시작...")
+            logger.info(f"구매신청 정보 상속 처리 시작...")
             
             # 1. 이전 리비전에서 그룹별 구매신청 수량 집계
             prev_purchase_summary = text("""
@@ -396,14 +399,14 @@ class MaterialService:
                 
                 inherited_count = len(new_materials)
                 if inherited_count > 0:
-                    print(f"  ✅ {prev_purchase.original_description[:30]}... (도면: {prev_purchase.drawing_name or 'N/A'}) → {inherited_count}/{purchased_count}개 상속")
+                    logger.info(f"  {prev_purchase.original_description[:30]}... (도면: {prev_purchase.drawing_name or 'N/A'}) -> {inherited_count}/{purchased_count}개 상속")
             
             # 커밋은 호출하는 쪽에서 일괄 처리하거나 여기서 처리
             # db.commit() 
-            print(f"✅ 구매신청 정보 상속 완료")
+            logger.info(f"구매신청 정보 상속 완료")
             
         except Exception as e:
-            print(f"❌ 구매신청 정보 상속 실패: {str(e)}")
+            logger.error(f"구매신청 정보 상속 실패: {str(e)}")
             # 상속 실패는 전체 프로세스를 중단하지 않음
 
     @staticmethod

tkeg/api/app/services/spool_manager_v2.py

@@ -1,229 +0,0 @@
-"""
-수정된 스풀 관리 시스템
-도면별 스풀 넘버링 + 에리어는 별도 관리
-"""
-
-import re
-from typing import Dict, List, Optional, Tuple
-from datetime import datetime
-
-# ========== 스풀 넘버링 규칙 ==========
-SPOOL_NUMBERING_RULES = {
-    "SPOOL_NUMBER": {
-        "sequence": ["A", "B", "C", "D", "E", "F", "G", "H", "I", "J", 
-                    "K", "L", "M", "N", "O", "P", "Q", "R", "S", "T",
-                    "U", "V", "W", "X", "Y", "Z"],
-        "description": "도면별 스풀 넘버"
-    },
-    "AREA_NUMBER": {
-        "pattern": r"#(\d{2})",  # #01, #02, #03...
-        "format": "#{:02d}",     # 2자리 숫자
-        "range": (1, 99),        # 01~99
-        "description": "물리적 구역 넘버 (별도 관리)"
-    }
-}
-
-class SpoolManagerV2:
-    """수정된 스풀 관리 클래스"""
-    
-    def __init__(self, project_id: int = None):
-        self.project_id = project_id
-    
-    def generate_spool_identifier(self, dwg_name: str, spool_number: str) -> str:
-        """
-        스풀 식별자 생성 (도면명 + 스풀넘버)
-        
-        Args:
-            dwg_name: 도면명 (예: "A-1", "B-3")
-            spool_number: 스풀넘버 (예: "A", "B")
-        
-        Returns:
-            스풀 식별자 (예: "A-1-A", "B-3-B")
-        """
-        
-        # 스풀 넘버 포맷 검증
-        spool_formatted = self.format_spool_number(spool_number)
-        
-        # 조합: {도면명}-{스풀넘버}
-        return f"{dwg_name}-{spool_formatted}"
-    
-    def parse_spool_identifier(self, spool_id: str) -> Dict:
-        """스풀 식별자 파싱"""
-        
-        # 패턴: DWG_NAME-SPOOL_NUMBER
-        # 예: A-1-A, B-3-B, 1-IAR-3B1D0-0129-N-A
-        
-        # 마지막 '-' 기준으로 분리
-        parts = spool_id.rsplit('-', 1)
-        
-        if len(parts) == 2:
-            dwg_base = parts[0]
-            spool_number = parts[1]
-            
-            return {
-                "original_id": spool_id,
-                "dwg_name": dwg_base,
-                "spool_number": spool_number,
-                "is_valid": self.validate_spool_number(spool_number),
-                "format": "CORRECT"
-            }
-        else:
-            return {
-                "original_id": spool_id,
-                "dwg_name": None,
-                "spool_number": None,
-                "is_valid": False,
-                "format": "INVALID"
-            }
-    
-    def format_spool_number(self, spool_input: str) -> str:
-        """스풀 넘버 포맷팅 및 검증"""
-        
-        spool_clean = spool_input.upper().strip()
-        
-        # 유효한 스풀 넘버인지 확인 (A-Z 단일 문자)
-        if re.match(r'^[A-Z]$', spool_clean):
-            return spool_clean
-        
-        raise ValueError(f"유효하지 않은 스풀 넘버: {spool_input} (A-Z 단일 문자만 가능)")
-    
-    def validate_spool_number(self, spool_number: str) -> bool:
-        """스풀 넘버 유효성 검증"""
-        return bool(re.match(r'^[A-Z]$', spool_number))
-    
-    def get_next_spool_number(self, dwg_name: str, existing_spools: List[str] = None) -> str:
-        """해당 도면의 다음 사용 가능한 스풀 넘버 추천"""
-        
-        if not existing_spools:
-            return "A"  # 첫 번째 스풀
-        
-        # 해당 도면의 기존 스풀들 파싱
-        used_spools = set()
-        
-        for spool_id in existing_spools:
-            parsed = self.parse_spool_identifier(spool_id)
-            if parsed["dwg_name"] == dwg_name and parsed["is_valid"]:
-                used_spools.add(parsed["spool_number"])
-        
-        # 다음 사용 가능한 넘버 찾기
-        sequence = SPOOL_NUMBERING_RULES["SPOOL_NUMBER"]["sequence"]
-        for spool_num in sequence:
-            if spool_num not in used_spools:
-                return spool_num
-        
-        raise ValueError(f"도면 {dwg_name}에서 사용 가능한 스풀 넘버가 없습니다")
-    
-    def validate_spool_identifier(self, spool_id: str) -> Dict:
-        """스풀 식별자 전체 유효성 검증"""
-        
-        parsed = self.parse_spool_identifier(spool_id)
-        
-        validation_result = {
-            "is_valid": True,
-            "errors": [],
-            "warnings": [],
-            "parsed": parsed
-        }
-        
-        # 도면명 확인
-        if not parsed["dwg_name"]:
-            validation_result["is_valid"] = False
-            validation_result["errors"].append("도면명이 없습니다")
-        
-        # 스풀 넘버 확인
-        if not parsed["spool_number"]:
-            validation_result["is_valid"] = False
-            validation_result["errors"].append("스풀 넘버가 없습니다")
-        elif not self.validate_spool_number(parsed["spool_number"]):
-            validation_result["is_valid"] = False
-            validation_result["errors"].append("스풀 넘버 형식이 잘못되었습니다 (A-Z 단일 문자)")
-        
-        return validation_result
-
-# ========== 에리어 관리 (별도 시스템) ==========
-class AreaManager:
-    """에리어 관리 클래스 (물리적 구역)"""
-    
-    def __init__(self, project_id: int = None):
-        self.project_id = project_id
-    
-    def format_area_number(self, area_input: str) -> str:
-        """에리어 넘버 포맷팅"""
-        
-        # 숫자만 추출
-        numbers = re.findall(r'\d+', area_input)
-        if numbers:
-            area_num = int(numbers[0])
-            if 1 <= area_num <= 99:
-                return f"#{area_num:02d}"
-        
-        raise ValueError(f"유효하지 않은 에리어 넘버: {area_input} (#01-#99)")
-    
-    def assign_drawings_to_area(self, area_number: str, drawing_names: List[str]) -> Dict:
-        """도면들을 에리어에 할당"""
-        
-        area_formatted = self.format_area_number(area_number)
-        
-        return {
-            "area_number": area_formatted,
-            "assigned_drawings": drawing_names,
-            "assignment_count": len(drawing_names),
-            "assignment_date": datetime.now().isoformat()
-        }
-
-def classify_pipe_with_corrected_spool(dat_file: str, description: str, main_nom: str,
-                                     length: float = None, dwg_name: str = None,
-                                     spool_number: str = None, area_number: str = None) -> Dict:
-    """파이프 분류 + 수정된 스풀 정보"""
-    
-    # 기본 파이프 분류
-    from .pipe_classifier import classify_pipe
-    pipe_result = classify_pipe(dat_file, description, main_nom, length)
-    
-    # 스풀 관리자 생성
-    spool_manager = SpoolManagerV2()
-    area_manager = AreaManager()
-    
-    # 스풀 정보 처리
-    spool_info = {
-        "dwg_name": dwg_name,
-        "spool_number": None,
-        "spool_identifier": None,
-        "area_number": None,  # 별도 관리
-        "manual_input_required": True,
-        "validation": None
-    }
-    
-    # 스풀 넘버가 제공된 경우
-    if dwg_name and spool_number:
-        try:
-            spool_identifier = spool_manager.generate_spool_identifier(dwg_name, spool_number)
-            
-            spool_info.update({
-                "spool_number": spool_manager.format_spool_number(spool_number),
-                "spool_identifier": spool_identifier,
-                "manual_input_required": False,
-                "validation": {"is_valid": True, "errors": []}
-            })
-            
-        except ValueError as e:
-            spool_info["validation"] = {
-                "is_valid": False,
-                "errors": [str(e)]
-            }
-    
-    # 에리어 정보 처리 (별도)
-    if area_number:
-        try:
-            area_formatted = area_manager.format_area_number(area_number)
-            spool_info["area_number"] = area_formatted
-        except ValueError as e:
-            spool_info["area_validation"] = {
-                "is_valid": False,
-                "errors": [str(e)]
-            }
-    
-    # 기존 결과에 스풀 정보 추가
-    pipe_result["spool_info"] = spool_info
-    
-    return pipe_result