hotfix

.gitignore

@@ -155,4 +155,3 @@ restart_systemd.sh
 SERVERS.md
 
 *.json
-

README.md

@@ -29,6 +29,15 @@ uvicorn app.main:app --reload --port 8000
 
 API 문서: `http://127.0.0.1:8000/docs`
 
+### 비동기 처리 흐름(업로드 이후)
+
+업로드 API(`/users/voices`) 호출 후 서버는 다음을 비동기로 수행합니다.
+
+- STT → 텍스트 감정 분석 → `voice_content` 저장
+- 음성 감정 분석(오디오 자체) → `voice_analyze` 저장
+
+응답은 업로드 및 메타/매핑 저장 후 즉시 반환되며, 분석 결과는 나중에 조회 API에서 확인할 수 있습니다.
+
 ### Docker를 사용한 실행
 
 #### 1. 환경 변수 설정

_schema_fix.py

@@ -0,0 +1,22 @@
+from app.database import engine
+from sqlalchemy import text
+
+
+def ensure_surprise_column() -> None:
+    with engine.connect() as conn:
+        res = conn.execute(text("SHOW COLUMNS FROM voice_analyze LIKE 'surprise_bps'"))
+        row = res.fetchone()
+        if row is None:
+            print("Adding surprise_bps column...")
+            conn.execute(text("ALTER TABLE voice_analyze ADD COLUMN surprise_bps SMALLINT NOT NULL DEFAULT 0"))
+            print("Added surprise_bps")
+        else:
+            print("surprise_bps exists")
+        conn.commit()
+
+
+if __name__ == "__main__":
+    ensure_surprise_column()
+
+
+

app/care_service.py

@@ -0,0 +1,103 @@
+from sqlalchemy import func, extract
+from .models import User, Voice, VoiceAnalyze
+from .auth_service import get_auth_service
+from datetime import datetime, timedelta
+from collections import Counter, defaultdict
+
+class CareService:
+    def __init__(self, db):
+        self.db = db
+        self.auth_service = get_auth_service(db)
+
+    def get_emotion_monthly_frequency(self, care_username: str, month: str) -> dict:
+        """
+        보호자 페이지: 연결 유저의 한달간 top_emotion 집계 반환
+        :param care_username: 보호자 아이디
+        :param month: 'YYYY-MM'
+        :return: {success, frequency: {emotion: count, ...}}
+        """
+        try:
+            care = self.auth_service.get_user_by_username(care_username)
+            if not care or care.role != 'CARE' or not care.connecting_user_code:
+                return {"success": False, "frequency": {}, "message": "Care user not found or no connection."}
+            user = self.db.query(User).filter(User.user_code == care.connecting_user_code).first()
+            if not user:
+                return {"success": False, "frequency": {}, "message": "Connected user not found."}
+            try:
+                y, m = map(int, month.split("-"))
+            except Exception:
+                return {"success": False, "frequency": {}, "message": "month format YYYY-MM required"}
+            results = (
+                self.db.query(VoiceAnalyze.top_emotion, func.count())
+                .join(Voice, Voice.voice_id == VoiceAnalyze.voice_id)
+                .filter(
+                    Voice.user_id == user.user_id,
+                    extract('year', Voice.created_at) == y,
+                    extract('month', Voice.created_at) == m
+                )
+                .group_by(VoiceAnalyze.top_emotion)
+                .all()
+            )
+            freq = {str(emotion): count for emotion, count in results if emotion}
+            return {"success": True, "frequency": freq}
+        except Exception as e:
+            return {"success": False, "frequency": {}, "message": f"error: {str(e)}"}
+
+    def get_emotion_weekly_summary(self, care_username: str, month: str, week: int) -> dict:
+        """
+        보호자 페이지: 연결 유저의 월/주차별 요일별 top 감정 요약 반환
+        :param care_username: 보호자 아이디
+        :param month: YYYY-MM
+        :param week: 1~5 (1주차~5주차)
+        :return: {success, weekly: [{day: "2025-10-02", weekday: "Thu", top_emotion: "happy"}, ...]}
+        """
+        try:
+            care = self.auth_service.get_user_by_username(care_username)
+            if not care or care.role != 'CARE' or not care.connecting_user_code:
+                return {"success": False, "weekly": [], "message": "Care user not found or no connection."}
+            user = self.db.query(User).filter(User.user_code == care.connecting_user_code).first()
+            if not user:
+                return {"success": False, "weekly": [], "message": "Connected user not found."}
+            try:
+                y, m = map(int, month.split("-"))
+            except Exception:
+                return {"success": False, "weekly": [], "message": "month format YYYY-MM required"}
+            # 주차 구간 계산
+            from calendar import monthrange
+            start_day = (week-1)*7+1
+            end_day = min(week*7, monthrange(y, m)[1])
+            start_date = datetime(y, m, start_day)
+            end_date = datetime(y, m, end_day, 23, 59, 59)
+            # 요일별 group
+            q = (
+                self.db.query(Voice, VoiceAnalyze)
+                .join(VoiceAnalyze, Voice.voice_id == VoiceAnalyze.voice_id)
+                .filter(
+                    Voice.user_id == user.user_id,
+                    Voice.created_at >= start_date,
+                    Voice.created_at <= end_date,
+                ).order_by(Voice.created_at.asc())
+            )
+            days = defaultdict(list)  # day: [emotion, ...]
+            day_first = {}
+            for v, va in q:
+                d = v.created_at.date()
+                em = va.top_emotion
+                days[d].append(em)
+                if d not in day_first:
+                    day_first[d] = em  # 업로드 빠른 감정 미리 기억
+            result = []
+            for d in sorted(days.keys()):
+                cnt = Counter(days[d])
+                top, val = cnt.most_common(1)[0]
+                # 동률 맞추기(동점시 가장 먼저 업로드한 감정을 top으로)
+                top_emotions = [e for e, c in cnt.items() if c == val]
+                selected = day_first[d] if len(top_emotions) > 1 and day_first[d] in top_emotions else top
+                result.append({
+                    "date": d.isoformat(),
+                    "weekday": d.strftime("%a"),
+                    "top_emotion": selected
+                })
+            return {"success": True, "weekly": result}
+        except Exception as e:
+            return {"success": False, "weekly": [], "message": f"error: {str(e)}"}

app/db_service.py

@@ -36,6 +36,10 @@ def get_user_by_username(self, username: str) -> Optional[User]:
     def get_users(self, skip: int = 0, limit: int = 100) -> List[User]:
         """사용자 목록 조회"""
         return self.db.query(User).offset(skip).limit(limit).all()
+
+    def get_user_by_user_code(self, user_code: str) -> Optional[User]:
+        """user_code로 사용자 조회"""
+        return self.db.query(User).filter(User.user_code == user_code).first()
 
     # Voice 관련 메서드
     def create_voice(self, voice_key: str, voice_name: str, duration_ms: int, 
@@ -58,6 +62,21 @@ def create_voice(self, voice_key: str, voice_name: str, duration_ms: int,
     def get_voice_by_id(self, voice_id: int) -> Optional[Voice]:
         """ID로 음성 파일 조회"""
         return self.db.query(Voice).filter(Voice.voice_id == voice_id).first()
+
+    def get_voice_detail_for_username(self, voice_id: int, username: str) -> Optional[Voice]:
+        """username으로 소유권을 검증하며 상세를 로드(joinedload)"""
+        from sqlalchemy.orm import joinedload
+        return (
+            self.db.query(Voice)
+            .join(User, Voice.user_id == User.user_id)
+            .filter(Voice.voice_id == voice_id, User.username == username)
+            .options(
+                joinedload(Voice.questions),
+                joinedload(Voice.voice_content),
+                joinedload(Voice.voice_analyze),
+            )
+            .first()
+        )
 
     def get_voice_by_key(self, voice_key: str) -> Optional[Voice]:
         """S3 키로 음성 파일 조회"""
@@ -69,6 +88,29 @@ def get_voices_by_user(self, user_id: int, skip: int = 0, limit: int = 50) -> Li
         return self.db.query(Voice).filter(Voice.user_id == user_id)\
             .options(joinedload(Voice.questions))\
             .order_by(Voice.created_at.desc()).offset(skip).limit(limit).all()
+
+    def get_care_voices(self, care_username: str, skip: int = 0, limit: int = 20) -> List[Voice]:
+        """보호자(care)의 연결 사용자 음성 중 voice_analyze가 존재하는 항목만 최신순 조회"""
+        from sqlalchemy.orm import joinedload
+        # 1) 보호자 조회
+        care = self.get_user_by_username(care_username)
+        if not care or not care.connecting_user_code:
+            return []
+        # 2) 연결된 사용자 조회
+        linked_user = self.get_user_by_user_code(care.connecting_user_code)
+        if not linked_user:
+            return []
+        # 3) 연결 사용자 음성 중 분석 완료만(join) 페이징
+        q = (
+            self.db.query(Voice)
+            .join(VoiceAnalyze, VoiceAnalyze.voice_id == Voice.voice_id)
+            .filter(Voice.user_id == linked_user.user_id)
+            .options(joinedload(Voice.questions), joinedload(Voice.voice_analyze))
+            .order_by(Voice.created_at.desc())
+            .offset(skip)
+            .limit(limit)
+        )
+        return q.all()
 
     def get_all_voices(self, skip: int = 0, limit: int = 50) -> List[Voice]:
         """전체 음성 파일 목록 조회"""
@@ -126,7 +168,7 @@ def update_voice_content(self, voice_id: int, content: str,
 
     # VoiceAnalyze 관련 메서드
     def create_voice_analyze(self, voice_id: int, happy_bps: int, sad_bps: int, 
-                           neutral_bps: int, angry_bps: int, fear_bps: int,
+                           neutral_bps: int, angry_bps: int, fear_bps: int, surprise_bps: int = 0,
                            top_emotion: Optional[str] = None, top_confidence_bps: Optional[int] = None,
                            model_version: Optional[str] = None) -> VoiceAnalyze:
         """음성 감정 분석 데이터 생성"""
@@ -137,6 +179,7 @@ def create_voice_analyze(self, voice_id: int, happy_bps: int, sad_bps: int,
             neutral_bps=neutral_bps,
             angry_bps=angry_bps,
             fear_bps=fear_bps,
+            surprise_bps=surprise_bps,
             top_emotion=top_emotion,
             top_confidence_bps=top_confidence_bps,
             model_version=model_version
@@ -151,7 +194,7 @@ def get_voice_analyze_by_voice_id(self, voice_id: int) -> Optional[VoiceAnalyze]
         return self.db.query(VoiceAnalyze).filter(VoiceAnalyze.voice_id == voice_id).first()
 
     def update_voice_analyze(self, voice_id: int, happy_bps: int, sad_bps: int, 
-                           neutral_bps: int, angry_bps: int, fear_bps: int,
+                           neutral_bps: int, angry_bps: int, fear_bps: int, surprise_bps: Optional[int] = None,
                            top_emotion: Optional[str] = None, top_confidence_bps: Optional[int] = None,
                            model_version: Optional[str] = None) -> Optional[VoiceAnalyze]:
         """음성 감정 분석 결과 업데이트"""
@@ -162,6 +205,8 @@ def update_voice_analyze(self, voice_id: int, happy_bps: int, sad_bps: int,
             voice_analyze.neutral_bps = neutral_bps
             voice_analyze.angry_bps = angry_bps
             voice_analyze.fear_bps = fear_bps
+            if surprise_bps is not None:
+                voice_analyze.surprise_bps = surprise_bps
             if top_emotion is not None:
                 voice_analyze.top_emotion = top_emotion
             if top_confidence_bps is not None:
@@ -229,6 +274,29 @@ def unlink_voice_question(self, voice_id: int, question_id: int) -> bool:
             return True
         return False
 
+    # 삭제 관련
+    def get_voice_owned_by_username(self, voice_id: int, username: str) -> Optional[Voice]:
+        """username 소유의 voice 조회"""
+        return (
+            self.db.query(Voice)
+            .join(User, Voice.user_id == User.user_id)
+            .filter(Voice.voice_id == voice_id, User.username == username)
+            .first()
+        )
+
+    def delete_voice_with_relations(self, voice_id: int) -> bool:
+        """연관 데이터(voice_question, voice_content, voice_analyze) 삭제 후 voice 삭제"""
+        # voice_question
+        self.db.query(VoiceQuestion).filter(VoiceQuestion.voice_id == voice_id).delete(synchronize_session=False)
+        # voice_content
+        self.db.query(VoiceContent).filter(VoiceContent.voice_id == voice_id).delete(synchronize_session=False)
+        # voice_analyze
+        self.db.query(VoiceAnalyze).filter(VoiceAnalyze.voice_id == voice_id).delete(synchronize_session=False)
+        # voice
+        deleted = self.db.query(Voice).filter(Voice.voice_id == voice_id).delete(synchronize_session=False)
+        self.db.commit()
+        return deleted > 0
+
 
 def get_db_service(db: Session) -> DatabaseService:
     """데이터베이스 서비스 인스턴스 생성"""

app/dto.py

@@ -63,6 +63,7 @@ class VoiceQuestionUploadResponse(BaseModel):
 
 
 class VoiceListItem(BaseModel):
+    voice_id: int
     created_at: str
     emotion: Optional[str] = None
     question_title: Optional[str] = None
@@ -74,6 +75,38 @@ class UserVoiceListResponse(BaseModel):
     voices: list[VoiceListItem]
 
 
+class CareVoiceListItem(BaseModel):
+    voice_id: int
+    created_at: str
+    emotion: Optional[str] = None
+
+
+class CareUserVoiceListResponse(BaseModel):
+    success: bool
+    voices: list[CareVoiceListItem]
+
+
+class UserVoiceDetailResponse(BaseModel):
+    voice_id: int
+    title: Optional[str] = None
+    top_emotion: Optional[str] = None
+    created_at: str
+    voice_content: Optional[str] = None
+
+
+class VoiceAnalyzePreviewResponse(BaseModel):
+    voice_id: Optional[int] = None
+    happy_bps: int
+    sad_bps: int
+    neutral_bps: int
+    angry_bps: int
+    fear_bps: int
+    surprise_bps: int
+    top_emotion: Optional[str] = None
+    top_confidence_bps: Optional[int] = None
+    model_version: Optional[str] = None
+
+
 class VoiceDetailResponse(BaseModel):
     voice_id: str
     filename: str