feat: 작업 2 - 최종 입장 표현 구현

[토론] 토론 전 초기 입장(찬성/반대/중립) 선택 UI 추가
[토론] 토론 후 최종 입장 투표 UI 추가
[토론] 교사 대시보드 전후 입장 변화율 도넛 차트 시각화
[토의] 토의 종료 후 '가장 중요한 결론은?' 한 줄 입력 UI 추가
[토의] 교사 대시보드 결론 워드클라우드 시각화
DB: opinion_changes에 initial_stance, final_stance, discussion_conclusion 컬럼 추가 필요 (SQL 별도 안내)

https://claude.ai/code/session_016DE3uHLsVmA5Uv7gZGGaKT

app.py

@@ -209,7 +209,7 @@ if user_role == "학생" and opinion_changes_available():
         row = fetch_opinion_change(supabase, room_name, student_name)
         has_pre_opinion = bool((row or {}).get("pre_opinion"))
         if not has_pre_opinion:
-            render_pre_opinion_form(supabase, room_name, student_name, current_topic)
+            render_pre_opinion_form(supabase, room_name, student_name, current_topic, act_type)
             st.caption("💡 위에서 토론 전 생각을 제출하면 의견 작성이 활성화됩니다.")
         else:
             _render_opinion_input(supabase, room_name, user_role, student_name, student_number, current_mode)

components/opinion_change.py

@@ -7,6 +7,7 @@ from db import (
     fetch_opinion_change,
     opinion_changes_available,
     save_opinion_analysis,
+    stance_available,
     upsert_post_opinion,
     upsert_pre_opinion,
 )
@@ -14,9 +15,22 @@ from env import get_secret
 from services.ai import build_opinion_change_prompt, generate_ai_response
 
 
-def render_pre_opinion_form(supabase, room_name, student_name, current_topic):
+_STANCE_OPTIONS = ["🔵 찬성", "🔴 반대", "⚪ 중립"]
+
+
+def render_pre_opinion_form(supabase, room_name, student_name, current_topic, act_type="토론"):
     """토론 전 생각 입력 폼. 제출 완료 시 전체 앱 재실행."""
-    st.info(f"💬 **토론 전 내 생각 먼저 기록하기**\n\n'{current_topic}' 주제에 대한 나의 생각을 적어주세요. 제출 후 토론에 참여할 수 있습니다.")
+    st.info(f"💬 **{'토론' if act_type == '토론' else '토의'} 전 내 생각 먼저 기록하기**\n\n'{current_topic}' 주제에 대한 나의 생각을 적어주세요. 제출 후 {'토론' if act_type == '토론' else '토의'}에 참여할 수 있습니다.")
+
+    initial_stance = None
+    if act_type == "토론" and stance_available():
+        initial_stance = st.radio(
+            "📌 토론 전 나의 초기 입장",
+            _STANCE_OPTIONS,
+            horizontal=True,
+            key="pre_stance_radio",
+        )
+
     pre_input = st.text_area(
         "이 주제에 대한 내 생각은?",
         height=100,
@@ -28,7 +42,7 @@ def render_pre_opinion_form(supabase, room_name, student_name, current_topic):
         if not pre_input.strip():
             st.warning("생각을 입력해 주세요.")
             return
-        res = upsert_pre_opinion(supabase, room_name, student_name, pre_input.strip())
+        res = upsert_pre_opinion(supabase, room_name, student_name, pre_input.strip(), initial_stance=initial_stance)
         if res is not None:
             st.toast("✅ 내 생각이 기록되었습니다. 이제 토론에 참여할 수 있습니다!", icon="🎉")
             st.rerun()
@@ -54,7 +68,30 @@ def render_post_opinion_section(supabase, room_name, student_name, act_type, cur
         st.caption("📌 토론 전 생각 기록 없음")
 
     if not post_opinion:
-        st.info("토론이 종료되었습니다. 토론 후 생각이 어떻게 바뀌었는지 기록해 주세요.")
+        end_label = "토론" if act_type == "토론" else "토의"
+        st.info(f"{end_label}이 종료되었습니다. {end_label} 후 생각이 어떻게 바뀌었는지 기록해 주세요.")
+
+        final_stance = None
+        discussion_conclusion = None
+
+        if act_type == "토론" and stance_available():
+            initial_stance_val = (row or {}).get("initial_stance") or ""
+            if initial_stance_val:
+                st.caption(f"📌 **토론 전 나의 입장:** {initial_stance_val}")
+            final_stance = st.radio(
+                "🗳️ 토론 후 최종 입장",
+                _STANCE_OPTIONS,
+                horizontal=True,
+                key="post_stance_radio",
+            )
+
+        if act_type == "토의" and stance_available():
+            discussion_conclusion = st.text_input(
+                "💡 가장 중요한 결론은?",
+                max_chars=200,
+                placeholder="이번 토의에서 얻은 가장 중요한 결론을 한 줄로 써보세요.",
+            )
+
         post_input = st.text_area(
             "토론 후 생각 변화",
             height=100,
@@ -67,13 +104,23 @@ def render_post_opinion_section(supabase, room_name, student_name, act_type, cur
             if not post_input.strip():
                 st.warning("생각을 입력해 주세요.")
                 return
-            res = upsert_post_opinion(supabase, room_name, student_name, post_input.strip())
+            res = upsert_post_opinion(
+                supabase, room_name, student_name, post_input.strip(),
+                final_stance=final_stance,
+                discussion_conclusion=discussion_conclusion.strip() if discussion_conclusion else None,
+            )
             if res is not None:
                 _trigger_analysis(supabase, room_name, student_name, act_type, current_topic, pre_opinion, post_input.strip())
                 st.rerun()
             else:
                 st.error("저장에 실패했습니다. 다시 시도해 주세요.")
     else:
+        final_stance_val = (row or {}).get("final_stance") or ""
+        discussion_conclusion_val = (row or {}).get("discussion_conclusion") or ""
+        if act_type == "토론" and final_stance_val:
+            st.success(f"✅ **최종 입장:** {final_stance_val}")
+        if act_type == "토의" and discussion_conclusion_val:
+            st.success(f"✅ **나의 결론:** {discussion_conclusion_val}")
         st.success(f"✅ **토론 후 내 생각:** {post_opinion}")
         st.divider()
         if ai_analysis:

components/teacher_dashboard.py

@@ -3,9 +3,10 @@ import logging
 import plotly.express as px
 import streamlit as st
 
-from db import destroy_room_data, fetch_all_opinion_changes, fetch_debate_status, fetch_live_messages, opinion_changes_available, session_control_available, set_debate_status
+from db import destroy_room_data, fetch_all_opinion_changes, fetch_debate_status, fetch_live_messages, opinion_changes_available, session_control_available, set_debate_status, stance_available
 from utils import create_analysis_image
-from components.opinion_change import _render_image_download
+from components.opinion_change import _render_image_download, _STANCE_OPTIONS
+from wordcloud import build_word_frequencies, build_circular_wordcloud_html
 from validators import with_fallback_author_role
 from utils import log_audit
 from config import DASHBOARD_FETCH_LIMIT, ROOM_DESTROY_ENABLED, UI_FONT_FAMILY
@@ -60,6 +61,19 @@ def render_teacher_dashboard(supabase, room_name, user_role, student_name, curre
             pre  = row.get("pre_opinion")  or "(없음)"
             post = row.get("post_opinion") or "(없음)"
             ai   = row.get("ai_analysis")  or ""
+
+            if stance_available() and act_type == "토론":
+                init_s = row.get("initial_stance") or ""
+                final_s = row.get("final_stance") or ""
+                if init_s or final_s:
+                    col_is, col_fs = st.columns(2)
+                    with col_is:
+                        st.caption("📌 토론 전 입장")
+                        st.info(init_s or "(미입력)")
+                    with col_fs:
+                        st.caption("🗳️ 토론 후 최종 입장")
+                        st.info(final_s or "(미입력)")
+
             col_pre, col_post = st.columns(2)
             with col_pre:
                 st.caption("📌 토론 전 생각")
@@ -78,6 +92,58 @@ def render_teacher_dashboard(supabase, room_name, user_role, student_name, curre
             else:
                 st.caption("AI 분석이 아직 없습니다.")
 
+            # 입장 변화 도넛 차트 (토론) / 워드클라우드 (토의)
+            if stance_available():
+                st.divider()
+                if act_type == "토론":
+                    st.subheader("📊 입장 변화 현황")
+                    col_d1, col_d2 = st.columns(2)
+                    for col, col_name, label in [
+                        (col_d1, "initial_stance", "토론 전 초기 입장"),
+                        (col_d2, "final_stance",   "토론 후 최종 입장"),
+                    ]:
+                        if col_name in df_oc.columns:
+                            counts = (
+                                df_oc[col_name]
+                                .dropna()
+                                .value_counts()
+                                .reindex(_STANCE_OPTIONS, fill_value=0)
+                                .reset_index()
+                            )
+                            counts.columns = ["입장", "인원"]
+                            with col:
+                                st.caption(label)
+                                if counts["인원"].sum() > 0:
+                                    fig = px.pie(
+                                        counts, names="입장", values="인원",
+                                        hole=0.45,
+                                        color="입장",
+                                        color_discrete_map={
+                                            "🔵 찬성": "#1558a0",
+                                            "🔴 반대": "#d62728",
+                                            "⚪ 중립": "#aaaaaa",
+                                        },
+                                    )
+                                    fig.update_layout(
+                                        margin=dict(t=10, b=10, l=10, r=10),
+                                        font={"family": UI_FONT_FAMILY},
+                                        showlegend=True,
+                                        legend=dict(orientation="h"),
+                                    )
+                                    st.plotly_chart(fig, use_container_width=True, config={"displayModeBar": False})
+                                else:
+                                    st.info("아직 입력된 입장이 없습니다.")
+                elif act_type == "토의":
+                    if "discussion_conclusion" in df_oc.columns:
+                        conclusions = df_oc["discussion_conclusion"].dropna()
+                        if not conclusions.empty:
+                            st.subheader("☁️ 결론 워드클라우드")
+                            freq = build_word_frequencies(conclusions)
+                            if freq:
+                                st.markdown(build_circular_wordcloud_html(freq), unsafe_allow_html=True)
+                        else:
+                            st.info("아직 제출된 결론이 없습니다.")
+
     if session_control_available():
         st.divider()
         st.subheader("🎛️ 토론 진행 제어")

db.py

@@ -118,6 +118,7 @@ def check_schema_columns() -> dict:
         ("topic.created_by",               lambda: supabase.table("topic").select("created_by").limit(1).execute()),
         ("teacher_accounts.is_admin",      lambda: supabase.table("teacher_accounts").select("is_admin").limit(1).execute()),
         ("opinion_changes.pre_opinion",    lambda: supabase.table("opinion_changes").select("pre_opinion").limit(1).execute()),
+        ("opinion_changes.initial_stance", lambda: supabase.table("opinion_changes").select("initial_stance").limit(1).execute()),
         ("session_control.status",         lambda: supabase.table("session_control").select("status").limit(1).execute()),
     ]
 
@@ -153,6 +154,9 @@ def topic_owner_column_available() -> bool:
 def opinion_changes_available() -> bool:
     return check_schema_columns().get("opinion_changes.pre_opinion", False)
 
+def stance_available() -> bool:
+    return check_schema_columns().get("opinion_changes.initial_stance", False)
+
 def session_control_available() -> bool:
     return check_schema_columns().get("session_control.status", False)
 
@@ -380,7 +384,7 @@ def fetch_opinion_change(supabase: Client, room_name: str, student_name: str):
         return None
     res = execute_query(
         supabase.table("opinion_changes")
-        .select("pre_opinion, post_opinion, ai_analysis")
+        .select("*")
         .eq("room_name", room_name)
         .eq("student_name", student_name)
         .limit(1),
@@ -391,40 +395,40 @@ def fetch_opinion_change(supabase: Client, room_name: str, student_name: str):
     return res.data[0]
 
 
-def upsert_pre_opinion(supabase: Client, room_name: str, student_name: str, pre_opinion: str):
+def upsert_pre_opinion(supabase: Client, room_name: str, student_name: str, pre_opinion: str, initial_stance: str = None):
     if not opinion_changes_available():
         return None
+    payload = {"pre_opinion": pre_opinion}
+    if initial_stance and stance_available():
+        payload["initial_stance"] = initial_stance
     existing = fetch_opinion_change(supabase, room_name, student_name)
     if existing is not None:
         return execute_query(
-            supabase.table("opinion_changes")
-            .update({"pre_opinion": pre_opinion})
-            .eq("room_name", room_name)
-            .eq("student_name", student_name),
+            supabase.table("opinion_changes").update(payload).eq("room_name", room_name).eq("student_name", student_name),
             fail_message="토론 전 생각 저장 실패",
         )
     return execute_query(
-        supabase.table("opinion_changes")
-        .insert({"room_name": room_name, "student_name": student_name, "pre_opinion": pre_opinion}),
+        supabase.table("opinion_changes").insert({"room_name": room_name, "student_name": student_name, **payload}),
         fail_message="토론 전 생각 저장 실패",
     )
 
 
-def upsert_post_opinion(supabase: Client, room_name: str, student_name: str, post_opinion: str):
+def upsert_post_opinion(supabase: Client, room_name: str, student_name: str, post_opinion: str, final_stance: str = None, discussion_conclusion: str = None):
     if not opinion_changes_available():
         return None
+    payload = {"post_opinion": post_opinion}
+    if final_stance and stance_available():
+        payload["final_stance"] = final_stance
+    if discussion_conclusion and stance_available():
+        payload["discussion_conclusion"] = discussion_conclusion
     existing = fetch_opinion_change(supabase, room_name, student_name)
     if existing is not None:
         return execute_query(
-            supabase.table("opinion_changes")
-            .update({"post_opinion": post_opinion})
-            .eq("room_name", room_name)
-            .eq("student_name", student_name),
+            supabase.table("opinion_changes").update(payload).eq("room_name", room_name).eq("student_name", student_name),
             fail_message="토론 후 생각 저장 실패",
         )
     return execute_query(
-        supabase.table("opinion_changes")
-        .insert({"room_name": room_name, "student_name": student_name, "post_opinion": post_opinion}),
+        supabase.table("opinion_changes").insert({"room_name": room_name, "student_name": student_name, **payload}),
         fail_message="토론 후 생각 저장 실패",
     )
 
@@ -434,7 +438,7 @@ def fetch_all_opinion_changes(supabase: Client, room_name: str):
         return pd.DataFrame()
     res = execute_query(
         supabase.table("opinion_changes")
-        .select("student_name, pre_opinion, post_opinion, ai_analysis")
+        .select("*")
         .eq("room_name", room_name)
         .order("student_name"),
         fail_message="학생별 생각 변화 조회 실패",