fix: UsePathBase 미들웨어와 중복되는 '/taxbaik' 하드코딩 경로 접두사 제거 (PR #4 보완)

.gitea/workflows/browser-e2e.yml

@@ -49,13 +49,12 @@ jobs:
             # Suppress stderr and allow failures to handle transition/down periods cleanly
             VERSION_BODY="$(curl -fsS "http://${DEPLOY_HOST}/taxbaik/version.json" 2>/dev/null || true)"
             BLOG_STATUS="$(curl -s -o /dev/null -w '%{http_code}' "http://${DEPLOY_HOST}/taxbaik/blog/accountant-mistakes-5" || true)"
-            LOGIN_STATUS="$(curl -s -o /dev/null -w '%{http_code}' "http://${DEPLOY_HOST}/taxbaik/admin/login" || true)"
+            if echo "$VERSION_BODY" | grep -q "\"version\": \"${SHORT_VERSION}\"" && [ "$BLOG_STATUS" = "200" ]; then
-            if echo "$VERSION_BODY" | grep -q "\"version\": \"${SHORT_VERSION}\"" && [ "$BLOG_STATUS" = "200" ] && [ "$LOGIN_STATUS" = "200" ]; then
               echo "✓ Deployment ready for ${SHORT_VERSION} (attempt $i/20)"
               exit 0
             fi
             if [ $i -lt 20 ]; then
-              echo "  Attempt $i/20: waiting for deployment... (blog=${BLOG_STATUS:-?}, login=${LOGIN_STATUS:-?}, version=${VERSION_BODY:0:30}...)"
+              echo "  Attempt $i/20: waiting for deployment... (blog=${BLOG_STATUS:-?}, version=${VERSION_BODY:0:30}...)"
               sleep 3
             fi
           done
@@ -73,23 +72,6 @@ jobs:
           echo "Running E2E tests on Desktop Chrome (production verification)"
           npx playwright test --project="Desktop Chrome" --reporter=html --reporter=list
 
-      - name: API smoke verification
-        env:
-          DEPLOY_HOST: ${{ secrets.DEPLOY_HOST }}
-          E2E_ADMIN_USERNAME: test_admin
-          E2E_ADMIN_PASSWORD: TestAdmin@123456
-        run: |
-          set -e
-          TOKEN="$(curl -s -X POST "http://${DEPLOY_HOST}/taxbaik/api/auth/login" -H "Content-Type: application/json" -d "{\"username\":\"${E2E_ADMIN_USERNAME}\",\"password\":\"${E2E_ADMIN_PASSWORD}\"}" | python3 -c 'import sys, json; print(json.load(sys.stdin)["accessToken"])')"
-          test -n "$TOKEN"
-          curl -fsS -H "Authorization: Bearer $TOKEN" "http://${DEPLOY_HOST}/taxbaik/api/blog/admin?page=1&pageSize=1" >/dev/null
-          curl -fsS -H "Authorization: Bearer $TOKEN" "http://${DEPLOY_HOST}/taxbaik/api/faq" >/dev/null
-          curl -fsS -H "Authorization: Bearer $TOKEN" "http://${DEPLOY_HOST}/taxbaik/api/announcement" >/dev/null
-          curl -fsS -H "Authorization: Bearer $TOKEN" "http://${DEPLOY_HOST}/taxbaik/api/inquiry?page=1&pageSize=1" >/dev/null
-          curl -fsS "http://${DEPLOY_HOST}/taxbaik/favicon.svg" >/dev/null
-          curl -fsS "http://${DEPLOY_HOST}/taxbaik/favicon.ico" >/dev/null
-          curl -fsS "http://${DEPLOY_HOST}/taxbaik/robots.txt" >/dev/null
-
       - name: Browser E2E summary
         if: always()
         run: |

.gitea/workflows/deploy.yml

@@ -33,9 +33,6 @@ jobs:
       - name: Publish Web
         run: dotnet publish TaxBaik.Web/ -c Release -o ./publish --no-restore
 
-      - name: Publish Proxy
-        run: dotnet publish TaxBaik.Proxy/ -c Release -o ./publish/proxy
-
       - name: Write production secrets
         run: |
           set -e
@@ -70,18 +67,13 @@ jobs:
           )'
           test -s ./publish/appsettings.Production.json || { echo "appsettings.Production.json is empty" >&2; exit 1; }
 
-      - name: Verify proxy artifact
-        run: |
-          test -s ./publish/proxy/TaxBaik.Proxy.dll || { echo "TaxBaik.Proxy.dll missing" >&2; exit 1; }
-          test -s ./publish/proxy/TaxBaik.Proxy.runtimeconfig.json || { echo "TaxBaik.Proxy.runtimeconfig.json missing" >&2; exit 1; }
-
       - name: Copy migrations
-        run: mkdir -p ./publish/db && cp -r db/migrations ./publish/db/ || true
+        run: cp -r db/migrations ./publish/migrations || true
 
       - name: Generate build info
         run: |
           COMMIT_HASH=$(git rev-parse --short HEAD)
-          BUILD_TIME=$(TZ=Asia/Seoul date +'%Y-%m-%d %H:%M:%S KST')
+          BUILD_TIME=$(date -u +'%Y-%m-%d %H:%M:%S UTC')
           mkdir -p ./publish/wwwroot
           printf '{\n  "version": "%s",\n  "built": "%s"\n}\n' "$COMMIT_HASH" "$BUILD_TIME" > ./publish/wwwroot/version.json
           echo "✓ Build: $COMMIT_HASH @ $BUILD_TIME"
@@ -108,14 +100,12 @@ jobs:
 
       - name: Package artifact
         run: |
-          cp deploy_gb.sh ./publish/deploy_gb.sh
           tar -czf taxbaik_deploy.tgz -C ./publish .
           echo "✓ Package: $(du -sh taxbaik_deploy.tgz | cut -f1)"
 
       - name: Deploy & verify on server
         run: |
           set -e
-          export TAXBAIK_DEPLOY_FROM_CI=1
           TIMESTAMP=$(date +%Y%m%d_%H%M%S)
           COMMIT=$(git rev-parse --short HEAD)
           DEPLOY_HOST="${{ secrets.DEPLOY_HOST }}"
@@ -158,7 +148,7 @@ jobs:
           # 2. 서버에서 배포 + 헬스 체크 (SSH 1회 연결로 처리, Green-Blue 지원)
           ssh -i ~/.ssh/id_ed25519 -o StrictHostKeyChecking=yes \
               -o ServerAliveInterval=10 \
-              "$DEPLOY_USER@$DEPLOY_HOST" TAXBAIK_DEPLOY_FROM_CI=1 bash << REMOTE
+              "$DEPLOY_USER@$DEPLOY_HOST" bash << REMOTE
           set -e
           DEPLOY_HOME="/home/kjh2064"
           DEPLOY_DIR="\$DEPLOY_HOME/deployments/taxbaik_${TIMESTAMP}"
@@ -172,12 +162,12 @@ jobs:
           echo "--- [2/5] 운영 설정 검증 ---"
           test -s "\$DEPLOY_DIR/appsettings.Production.json" \
             || { echo "FATAL: appsettings.Production.json 없음" >&2; exit 1; }
-          test -s "\$DEPLOY_DIR/proxy/TaxBaik.Proxy.dll" \
-            || { echo "FATAL: TaxBaik.Proxy.dll 없음" >&2; exit 1; }
 
-          echo "--- [3/4] Green-Blue 배포 실행 ---"
+          echo "--- [3/5] 심볼릭 링크 전환 ---"
-          chmod +x "\$DEPLOY_DIR/deploy_gb.sh"
+          ln -sfn "\$DEPLOY_DIR" "\$DEPLOY_HOME/taxbaik_active"
-          "\$DEPLOY_DIR/deploy_gb.sh" "\$DEPLOY_DIR"
+
+          echo "--- [4/5] 서비스 재시작 ---"
+          sudo /usr/bin/systemctl restart taxbaik
 
           echo "--- [5/5] 헬스 체크 (최대 60초) ---"
           ATTEMPTS=20
@@ -201,20 +191,13 @@ jobs:
               fi
               echo "✓ [3/4] 버전 정보 확인 완료"
 
-              # 검증 4: 5001 프록시 확인
+              # 검증 3: 관리자 로그인 페이지
-              if ! ss -tlnp | grep -q ':5001 '; then
-                echo "❌ 5001 프록시가 실행 중이 아님" >&2
-                exit 1
-              fi
-              echo "✓ [4/5] 5001 프록시 확인 완료"
-
-              # 검증 5: 관리자 로그인 페이지
               LOGIN_STATUS=\$(curl -sf -o /dev/null -w '%{http_code}' http://127.0.0.1:5001/taxbaik/admin/login 2>/dev/null || echo "000")
               if [ "\$LOGIN_STATUS" != "200" ]; then
                 echo "❌ 관리자 로그인 페이지 로드 실패 (상태: \$LOGIN_STATUS)" >&2
                 exit 1
               fi
-              echo "✓ [5/5] 관리자 페이지 로드 완료"
+              echo "✓ [4/4] 관리자 페이지 로드 완료"
 
               echo "✓ 서비스 정상 (시도 \$i/\$ATTEMPTS)"
               # 구 배포 디렉토리 정리 (최근 5개 보존)

BLOG_TEMPLATE.md

@@ -1,777 +0,0 @@
-# 블로그 포스트 작성 템플릿
-
-## 정확성 원칙 (법적 책임 수반)
-
-블로그는 **사실 기반, 세법 기반, 데이터 기반**이어야 합니다. 추측이나 예상은 법적 문제를 일으킬 수 있습니다.
-
-### 절대 금지 표현
-
-- "아마도", "할 것 같다", "추측된다" (추측)
-- "대략", "정도일 거다", "보통" (예상)
-- "좋을 것 같다", "나쁠 것 같다" (의견)
-- 증거 없는 "모두", "항상", "누구나" (일반화)
-- 출처 없는 통계 ("80% 고객이", "평균 X만 원")
-
-### 필수 요소
-
-**1. 세법 기반**:
-- 모든 주장에 세법/시행령/고시 인용
-- 조항 명시: "소득세법 제XX조에 따르면"
-- 최신 기준 명시: "2025년 기준"
-- 변경사항 반영: "전년도와 다르게..."
-
-**2. 사실 기반**:
-- 실제 일어난 고객 사례만 사용
-- 가정일 경우 명시: "예를 들어, 만약 이렇다면"
-- 가상 사례는 "예시 사례"라고 명확히
-- 개인정보는 익명화 (이름, 나이는 일반적인 표현)
-
-**3. 데이터 기반**:
-- 객관적 수치만 사용 (국세청 통계, 협회 자료)
-- 출처 명시: "2025년 세무청 통계에 따르면"
-- 구체적 금액: "약 50만 원" (범위 표현)
-- 비교 데이터: "작년 대비 X% 증가"
-
-**4. 사례 제시 시 확인 사항**:
-```
-✅ 실제 고객인가? (공개 가능한 정보만)
-✅ 세법을 정확하게 적용했는가?
-✅ 금액 계산이 정확한가?
-✅ 이 사례가 대표적인가? (극단적 사례면 명시)
-✅ 다른 고객에게도 적용 가능한가?
-```
-
----
-
-## 카테고리 필수 규칙
-
-**모든 블로그 포스트는 반드시 하나의 카테고리에 할당되어야 합니다. (NOT NULL)**
-
-### 카테고리별 포스트 배치
-
-| 카테고리 | 최소 포스트 | 주제 범위 |
-|---------|-----------|---------|
-| 사업자 세무 | 3개 | 기장, 세무신고, 부가세, 종합소득세 |
-| 부동산 세금 | 3개 | 월세, 양도세, 상속세(부동산) |
-| 종합소득세 | 3개 | 프리랜서, 부업, 경비 처리 |
-| 부가가치세 | 3개 | 신고, 기한, 간이과세 vs 일반과세 |
-| 가족자산·증여 | 3개 | 자녀 증여, 상속, 자산 이전 |
-
-### 카테고리 할당 규칙
-
-1. **명확한 주제 분류**: 포스트 내용이 카테고리 범위에 명확하게 해당
-2. **중복 금지**: 한 포스트는 정확히 하나의 카테고리에만 할당
-3. **균형 배치**: 각 카테고리당 최소 3개씩 (고객 검색 UX)
-4. **검색 최적화**: 고객이 카테고리로 찾을 때 관련 포스트 3개 이상 노출
-
-### 카테고리 미할당 시 (오류)
-- ❌ category_id = NULL (데이터베이스 제약 위반)
-- ❌ SQL 실행 실패 (NOT NULL 제약)
-- ❌ 블로그 페이지 노출 불가
-
-**이 규칙은 모든 포스트 생성/수정 시 필수 준수사항입니다.**
-
----
-
-## 핵심 철학: 고객이 느끼는 여정
-
-### 1️⃣ 기초: "이 정도는 할 수 있어요"
-- 고객이 배울 수 있는 기본 개념
-- 실제 사례로 구체화
-- 단계별 설명
-
-### 2️⃣ 현실: "하지만 복잡하네요"
-- 겹겹이 쌓인 세부사항들
-- 매년 바뀌는 세법
-- "이거 일일이 다 챙기기 어렵다"는 느낌
-
-### 3️⃣ 해결: "세무사와 함께면 괜찮아요"
-- 디테일 자동 관리
-- 세법 변화 자동 반영
-- 고객은 사업에만 집중
-
----
-
-**고객이 글을 읽은 후 느끼는 것**:
-
-1️⃣ 읽고 나서: "아, 이 정도는 내가 할 수 있겠네"  
-2️⃣ 생각해보니: "근데 이 모든 걸 매년 챙기기는... 힘들겠는데?"  
-3️⃣ 결론: "그럼 전문가 도움을 받는 게 낫겠다"
-
-→ 자연스럽게 세무사의 필요성을 깨달음 (강요 아님)
-
----
-
-## 템플릿 (복사해서 사용)
-
-### Step 1: 도입부 (공감)
-```markdown
-# [제목]
-
-"[구체적 상황]?"
-"많은 [직업]들이 이 상황을 겪습니다."
-
-→ 독자가 자신의 상황을 발견하도록
-```
-
-**예시**:
-```markdown
-# 동네 카페 월세 낼 때 세금이 안 나와요 - 정말 그럴까?
-
-"사업을 시작했는데 세금을 낸 적이 없어요"
-"많은 소규모 사업자들이 이렇게 생각합니다."
-```
-
----
-
-### Step 2: 실제 사례 (구체적 페르소나)
-
-**필수 정보**:
-- 이름, 나이, 직업, 사업 경력
-- 월/연간 매출 (현실적 수치)
-- 실제 겪은 문제/성공 사례
-
-```markdown
-### 상황: [지역] [카테고리]를 운영하는 [이름]님 ([나이]세, 사업 [년]차)
-
-**기본 정보**:
-- 위치: [구체적 위치]
-- 월 매출: [금액]
-- 월 경비: [주요 항목들]
-
-### 원래는 이렇게 했어요 (실패 사례)
-→ [실제 실수 1]
-→ [실제 실수 2]
-→ **결과**: 세금을 [X만 원] 더 내게 됨 (또는 세무조사 대상)
-
-### 바뀐 후 (성공 사례)
-→ [해결책 1]
-→ [해결책 2]
-→ **결과**: 세금을 [X만 원] 절약함 (또는 안정적인 운영)
-```
-
-**예시**:
-```markdown
-### 상황: 강남 역삼동에서 카페를 운영하는 김민수님 (34세, 사업 3년차)
-
-**기본 정보**:
-- 위치: 강남역 3번 출구 근처
-- 월 매출: 약 600만 원 (평일 200만, 주말 400만)
-- 월 경비: 월세 150만, 재료비 180만, 직원급여 100만 원
-
-### 원래는 이렇게 했어요
-→ "세금은 큰 회사나 내는 거라고 생각했어요"
-→ 영수증도 대충 정리하고
-→ **결과**: 세무청에서 3년치를 추징받고 가산세까지...손해 70만 원
-
-### 바뀐 후
-→ 매달 영수증을 정리해서
-→ 세무사와 년 1회 기장 상담
-→ **결과**: 세금도 명확하고, 추징도 없음. 심플하고 안전
-```
-
----
-
-### Step 3: 계산 & 설명
-
-**구조**:
-1. **기본 정보 확인** (위에서 제시한 사례 요약)
-2. **단계별 계산** (Step 1, Step 2, ... 명확히)
-3. **표로 시각화**
-
-```markdown
-## 계산 방법
-
-### Step 1️⃣: 매출 정리
-월 600만 원 × 12개월 = 연 7,200만 원
-
-### Step 2️⃣: 경비 계산
-
-월 경비 구성:
-- 월세: 150만 원 (연 1,800만 원)
-- 재료비: 180만 원 (연 2,160만 원)
-- 직원급여: 100만 원 (연 1,200만 원)
-- 기타: 20만 원 (연 240만 원)
-- **월 합계: 450만 원**
-- **연 합계: 5,400만 원**
-
-### Step 3️⃣: 순이익
-7,200만 - 5,400만 = **1,800만 원**
-
-### Step 4️⃣: 세금
-1,800만 원 × 약 6% = **약 108만 원/년**
-```
-
----
-
-### 🎭 Step 3.5: 악마는 디테일이다 (선택사항이지만 강력함)
-
-**구조**: "간단해 보이지만, 실제로는..."
-
-```markdown
-## 겉으로는 간단해 보여요... 하지만
-
-### 📄 "영수증을 정리하세요"라고 했는데
-
-**겉으로는**:
-→ 영수증을 모으기만 하면 돼
-
-**현실의 디테일**:
-→ 이 영수증은 인정되고, 이건 안 됨 (세법)
-→ 이건 개인비? 사업비? (판단)
-→ 카드값이랑 현금값이랑 다르면? (대사)
-→ 3년 지났는데 영수증을 못 찾으면? (소송)
-→ 세무청이 불인정하면? (항의 절차)
-
-**세무사가 처리하는 것**:
-✅ 어떤 영수증이 인정될지 사전에 판단
-✅ 개인비와 사업비의 경계 명확히
-✅ 세법 변경사항 적용
-✅ 세무청 부인시 대응 준비
-
----
-
-### 📊 "매출과 경비를 기록하세요"라고 했는데
-
-**겉으로는**:
-→ 엑셀에 숫자만 입력하면 돼
-
-**현실의 디테일**:
-→ 카드 명세서와 입금액이 안 맞음 (환불? 수수료?)
-→ 한 달간 매출을 빼먹음 (추가 계산)
-→ 같은 카테고리인데 세법상 다르게 분류돼야 함 (부가세/소득세 다름)
-→ 작년에 잘못 입력한 게 발견됨 (수정신고)
-→ 월별로 편차가 커서 세무청이 의심함 (설명 준비)
-
-**세무사가 처리하는 것**:
-✅ 카드명세서 vs 입금액 정산
-✅ 누락된 부분 찾아서 추가
-✅ 세법상 올바른 분류
-✅ 이전년도 오류 수정신고
-✅ 세무청 질의에 대한 근거 제시
-
----
-
-### ✅ "정확하게 기장하면 세금이 확정돼요"라고 했는데
-
-**겉으로는**:
-→ 기장만 잘하면 세금 끝
-
-**현실의 디테일**:
-→ 같은 사업도 절세 방법이 다양함 (어떤 게 맞나?)
-→ 올해는 이렇게, 내년은 저렇게? (일관성)
-→ 부가세와 소득세 둘 다 고려해야 함 (연계 계산)
-→ 세무조사가 오면 3년치를 모두 봄 (소급 처리)
-→ 이의신청/항소하려면? (법적 절차)
-
-**세무사가 처리하는 것**:
-✅ 최적의 절세 전략 제시
-✅ 연도별 일관된 기장 방식 유지
-✅ 부가세/소득세 동시 최적화
-✅ 세무조사 대비 사전 정리
-✅ 이의신청/항소 등 법적 대응
-```
-
-**💡 핵심**: 
-- 기초는 누구나 배울 수 있어요
-- **하지만 디테일을 모두 처리하려면?**
-- **그 디테일들이 바로 세무사가 하는 일**
-- **디테일 하나 놓쳤다가 가산세 50만 원... 이래서 세무사 비용이 아깝지 않음**
-
----
-
-### 🔄 Step 3.6: 세법은 계속 바뀐다 (매년 업데이트)
-
-**구조**: "올해의 세법 변화"를 포스트 작성 시점에 맞춰 갱신
-
-```markdown
-## 그런데 세법은 해마다 바뀝니다
-
-### 📋 [연도] 변경사항들 (꼭 알아야 할 것들)
-
-**✅ 2025년 부가세 변화**:
-- 신고 기한이 [날짜]로 변경됨
-- 영세사업자 기준이 [금액]로 상향조정됨
-- 새로운 공제 항목이 추가됨: [항목들]
-
-**✅ 2025년 소득세 변화**:
-- 기본공제가 [금액]에서 [금액]로 증가
-- 자녀 공제 조건이 변경됨
-- 월급 원천징수 기준이 조정됨
-
-**✅ 2025년 새로운 제도**:
-- 소상공인 세금 감면 확대
-- 청년사업자 지원 강화
-- 부가가치세 간편신청 범위 확대
-
----
-
-**혼자서 할 때의 문제**:
-❌ "작년 기준으로 기장했는데 올해 기준이 바뀐 거야?"
-❌ "이 공제가 되는 건지 안 되는 건지 모르겠어"
-❌ "새로운 제도가 나왔다는 것도 몰랐어"
-❌ "처음 다시 계산해야 하나?"
-
-**세무사가 처리하는 것**:
-✅ 매년 변경사항 자동 추적
-✅ 당신의 상황에 맞는 새로운 공제 적용
-✅ 이전년도 재계산 필요시 수정신고
-✅ 연중 세법 개정 소식 안내
-✅ 새로운 지원 정책 놓치지 않게 관리
-
----
-
-## 결과 비교: 혼자 할 때 vs 세무사와 함께
-
-**세법 변화 추적**
-- 혼자: "어? 규칙이 바뀌었네?"
-- 세무사: 자동으로 적용됨
-
-**새로운 공제**
-- 혼자: 놓치기 쉬움
-- 세무사: 모두 적용됨
-
-**매년 재계산**
-- 혼자: 직접 해야 함
-- 세무사: 자동 갱신
-
-**마음 편함**
-- 혼자: 불안감 ("맞나?")
-- 세무사: 확신 ("전문가가 관리")
-
-**투자 시간**
-- 혼자: 당신의 시간
-- 세무사: 포함 (전문가 비용)
-
----
-
-## 요약: 왜 세무사가 필요한가
-
-**기초는 배울 수 있지만**:
-- 세법은 매년 바뀌고
-- 당신은 본업이 있어서 추적이 어렵고
-- 실수 하나가 가산세 50만 원...
-
-**그래서 세무사가 있으면**:
-- 변화를 자동으로 적용해주고
-- 새 제도도 놓치지 않아주고
-- 당신은 사업에만 집중
-
-→ **결국 시간, 돈, 스트레스 모두 절약**
-
----
-
-### 💡 Step 4: 실무 팁 (3~5개)
-
-**구조**: ✅ 이렇게 하세요 / ❌ 이렇게 하면 안 돼요
-
-```markdown
-## 이렇게 하면 세금이 명확해요
-
-### ✅ 해야 할 것
-1. **영수증 정리** - 매달 봉투에 모아두기
-2. **기본 기록** - 엑셀에 간단히 기입
-3. **연 1회 점검** - 세무사와 기본 상담
-4. **투명성** - 세무청 신고는 정확하게
-
-### ❌ 하면 안 되는 것
-1. **영수증 버리기** - 나중에 증거 없음
-2. **개인비와 섞기** - 기장 혼란
-3. **신고 늦추기** - 가산세 발생
-4. **과하게 깎기** - 세무조사 리스크
-```
-
----
-
-### 📝 Step 5: 결론
-
-고객이 읽은 후 자연스럽게 결론을 내리도록:
-
-**구조**:
-1. 기초는 할 수 있다 (긍정)
-2. 근데 복잡하네요 (현실 직시)
-3. 그래서 세무사가 필요하구나 (자연스러운 깨달음)
-
-**고객이 느끼는 여정**:
-- 처음: "아, 이 정도는 내가 할 수 있겠네"
-- 중간: "근데 이 모든 걸 매년 챙기기는..."
-- 결론: "전문가 도움이 낫겠다"
-
-```markdown
-## 기초는 누구나 할 수 있어요
-
-**이 정도면 자신이 충분히 가능합니다**:
-- 소규모 사업 (월 500만~1,000만 원)
-- 단순 경비 (재료, 임차료 등)
-- 월 1회 정도 기본 정리
-
-→ 영수증 정리 + 기본 엑셀 기입면 충분
-
----
-
-## 하지만 이렇게 복잡하면 전문가 도움이 효율적입니다
-
-**세무사 상담을 권하는 경우**:
-- 📊 월 매출이 2,000만 원을 넘어갈 때
-- 💼 여러 사업을 동시에 운영할 때
-- 🏠 부동산 등 추가 수입이 있을 때
-- 📈 직원을 여러 명 두고 있을 때
-- 🌍 해외 거래나 수입이 있을 때
-
-### 실제 효과: 숫자로 본 세무사의 가치
-
-**절세액**
-- 혼자: X만 원
-- 세무사: X + 200만 원
-- 차이: +200만 원 절약
-
-**세무조사 스트레스**
-- 혼자: 매년 불안
-- 세무사: 안정적 대응
-- 차이: 심리적 안정
-
-**시간 투자**
-- 혼자: 월 10시간
-- 세무사: 월 1시간
-- 차이: 월 9시간 자유
-
-**세무사 비용**
-- 혼자: 0원
-- 세무사: 약 100만 원/년
-- 차이: -100만 원
-
-**실제 이익**
-- 혼자: 순이익
-- 세무사: 순이익 + 100만 원
-- 차이: +100만 원 순이익
-
-**돈을 쓰는 이유**:
-- 세금 절약: 절세 200만 원 - 비용 100만 원 = 순 100만 원 이득
-- 시간 절약: 월 9시간(연 108시간) = 사업에 집중
-- 스트레스 감소: 세무조사 불안 제거
-- 리스크 관리: 실수로 인한 가산세 방지
-
----
-
-## 요약
-
-**기본 개념을 아는 것만으로도**:
-- 실수를 줄이고
-- 세금을 절약하고
-- 세무사와의 상담이 훨씬 효율적
-
-당신의 상황이 어느 정도인지 판단하고,  
-필요할 때 전문가와 함께 하세요.
-```
-
----
-
-## ✅ 작성 체크리스트
-
-### 내용
-- [ ] **실제 사례**: 동네 카페/편의점/학원 같은 주변 상황
-- [ ] **구체적 페르소나**: 이름, 나이, 직업, 사업 경력
-- [ ] **실제 금액**: 매출, 경비, 세금 (현실적 수치)
-- [ ] **Before/After**: 실패 사례 → 성공 사례
-- [ ] **절세 효과**: "X만 원 절약" 또는 "손해를 막음"
-- [ ] **계산**: Step별로 명확, 표 포함
-- [ ] **악마는 디테일**: "겉으로는 간단해 보이지만 실제로는..." (세무사가 처리하는 디테일들)
-- [ ] **세법 변화**: 해당 연도의 세법 변경사항과 그 영향 설명
-
-### 톤
-- [ ] **교육적**: 개념을 이해하도록
-- [ ] **격려적**: 경고/협박 없음
-- [ ] **현실적**: 복잡할 수 있다는 인정
-- [ ] **세무사 자연스러운 유도**: "필요할 때 도움되는 선택"
-- [ ] **임파워먼트**: "기초는 누구나 할 수 있어요"
-
-### 표현
-- [ ] **중학교 수준**: 어려운 용어는 () 설명
-- [ ] **이모지**: 🏠💰✅❌📊 등으로 시각화
-- [ ] **짧은 문장**: 한 문장에 한 개념
-- [ ] **표와 리스트**: 수치는 표로, 항목은 리스트로
-
----
-
-## 🚫 피해야 할 표현 (한국세무사협회 광고 규칙 준수)
-
-### ❌ **절대 금지 표현** (법적 위반 위험)
-
-**1. 과도한 절세 약속 & 절대 표현**:
-- ❌ "50만 원 절약 가능"
-- ❌ "최대한 경비를 깎아줍니다"
-- ❌ "세금을 반으로 줄여드립니다"
-- ❌ "세금을 덜 냅니다" (보장으로 해석)
-- ❌ "가장 많이 절세해드립니다"
-- ✅ "이 사례에서는 약 50만 원 절약되었습니다" (과거 사례만)
-- ✅ "정확한 경비 처리로 세법에 따른 정당한 공제를 받을 수 있습니다" (법적 근거)
-- ✅ "경비를 빠짐없이 처리합니다" (객관적 프로세스)
-
-**2. 보장 표현 (불가능한 결과 약속)**:
-- ❌ "반드시 세금을 줄입니다"
-- ❌ "세무조사 안 받게 해드립니다"
-- ❌ "100% 절세를 보장합니다"
-- ❌ "세금을 보장합니다"
-- ✅ "정확한 신고로 세무조사 리스크를 최소화합니다"
-- ✅ "세법에 따른 정당한 공제를 받을 수 있습니다"
-
-**3. 무료 & 가격 표현**:
-- ❌ "무료로 세금 절약해드립니다"
-- ❌ "최저가 신고료"
-- ❌ "가장 저렴한 가격"
-- ✅ "합리적인 비용으로 전문 서비스를 제공합니다"
-
-**4. 절대/최상급 표현**:
-- ❌ "반드시", "무조건", "반듯이", "항상", "절대"
-- ❌ "최고", "최우수", "1등", "유일"
-- ❌ "모든", "완벽하게"
-- ✅ "일반적으로", "대부분의 경우", "보통"
-
-**5. 과도한 단순화 표현**:
-- ❌ "매우 편합니다", "너무 쉽습니다"
-- ❌ "아무도 실수할 수 없습니다"
-- ❌ "5분이면 끝납니다"
-- ✅ "기초 개념을 배울 수 있습니다"
-- ✅ "복잡한 부분은 전문가가 관리합니다"
-
-**6. 객관적 증거 없는 수치**:
-- ❌ "평균 170만 원 절약" (근거 없으면)
-- ❌ "고객의 80%가 만족" (통계 없으면)
-- ❌ "보통 2배의 환급" (데이터 없으면)
-- ✅ "이 사례에서는 약 170만 원 절약되었습니다"
-- ✅ "많은 고객들이 정확한 기장의 필요성을 느낍니다"
-
----
-
-### ✅ **안전한 표현 (권장)**
-
-| 대신 이렇게 | 이유 |
-|----------|------|
-| "정확한 기장으로 세법에 따른 공제를 받을 수 있습니다" | 법적 근거 (보장 아님) |
-| "경비를 빠짐없이 처리합니다" | 객관적 프로세스 |
-| "이 사례에서는 약 50만 원 절약되었습니다" | 과거 사례 (보장 아님) |
-| "경비를 빠짐없이 처리합니다" | 객관적 프로세스 |
-| "세무조사 대비 근거를 정리합니다" | 예방적 표현 |
-| "당신의 상황에 맞는 최선의 방법을 제시합니다" | 개별 맞춤형 |
-| "세법이 자주 바뀌므로 전문가 도움이 효율적입니다" | 필요성 설명 |
-| "이 정도는 자신이 충분히 가능합니다" | 존중과 임파워먼트 |
-| "복잡한 경우는 전문가와 상담하세요" | 선택지 제시 |
-| "정확하게 하면 나중에 편합니다" | 미래 가치 (현재 보장 아님) |
-
----
-
-### 📋 블로그 작성 시 광고 규칙 체크리스트
-
-- [ ] **절세 약속 제거**: "최대한", "반드시", "보장", "무조건" 단어 없음
-- [ ] **보장 표현 제거**: "세무조사 안 받게", "100% 절세", "확실" 제거
-- [ ] **무료/가격 표현 제거**: "무료", "최저가", "가장 저렴" 제거
-- [ ] **절대 표현 제거**: "항상", "절대", "모두", "완벽" 제거
-- [ ] **최상급 제거**: "최고", "최우수", "1등" (객관적 증거 있으면 가능)
-- [ ] **과도한 단순화 제거**: "매우 쉽습니다", "아무도 실수할 수 없음" 제거
-- [ ] **수치는 사례로**: "절약 가능" → "이 사례에서는 약 X만 원 절약"
-- [ ] **객관성 유지**: 구체적 사례 + 과거형 표현 사용
-- [ ] **필요성 설명**: "왜 필요한가" → 이해와 선택 유도
-- [ ] **세무사협회 규정 준수**: 법적 문제 없음
-
----
-
-## 시즌별 주제 예시
-
-| 월 | 추천 주제 | 톤 |
-|----|---------|-----|
-| 1월 | 부가세 2기 신고 기한 | "이 정도면 자신이 가능" |
-| 5월 | 종소세 신고 방법 | "핵심 개념 + 전문가 도움 타이밍" |
-| 7월 | 부가세 1기 신고 | "기초 정리 방법" |
-| 11월 | 다음해 준비 | "계획하면 편해요" |
-
----
-
-## ⚠️ 실수 방지 체크리스트 (과거 오류 기록)
-
-**이전에 반복된 실수들을 기록하여, 같은 실수를 하지 않도록 합니다.**
-
-### 1️⃣ 카테고리 할당 실수 ❌
-
-**과거 오류**: 포스트를 만들 때 category_id를 NULL로 두었음
-
-**문제점**:
-- DB NOT NULL 제약 위반
-- 블로그 페이지에 노출 안 됨
-- 고객이 카테고리로 검색 불가
-
-**예방책**:
-- ✅ **SQL INSERT 시 반드시 category_id 명시**
-- ✅ **포스트 작성 전에 카테고리 결정**
-- ✅ **DB 적용 후 category_id NOT NULL 확인**
-- ✅ **각 카테고리별 최소 3개 이상 포스트 유지**
-
-**SQL 예시** (권장):
-```sql
-INSERT INTO blog_posts (title, slug, content, category_id, is_published, ...)
-VALUES ('제목', 'slug', $$본문$$, 1, true, ...);
--- category_id 절대 생략 금지!
-```
-
----
-
-### 2️⃣ 내용 길이 부족 ❌
-
-**과거 오류**: 에이전트가 지침(1,500~2,500자)을 무시하고 간단한 버전(500자)으로 생성
-
-**문제점**:
-- 고객 설득력 부족
-- 계산 예시 없음
-- 3단계 구조 불완전
-- 세법 인용 부족
-
-**예방책**:
-- ✅ **각 포스트 최소 1,500자 이상 (추천 2,000~2,500자)**
-- ✅ **포스트 작성 후 글자 수 확인: `LENGTH(content) >= 1500`**
-- ✅ **항상 실제 사례 포함** (이름, 나이, 직업, 구체적 상황)
-- ✅ **항상 계산 과정 포함** (절세액 수치화)
-- ✅ **3단계 구조 필수** (1️⃣ 기초 → 2️⃣ 현실 → 3️⃣ 해결책)
-
-**확인 쿼리**:
-```sql
-SELECT id, title, LENGTH(content) as length FROM blog_posts
-WHERE LENGTH(content) < 1500;  -- 부족한 포스트 검출
-```
-
----
-
-### 3️⃣ 테이블 사용 금지 ❌
-
-**과거 오류**: 마크다운 테이블(`| |---|---|`) 사용
-
-**문제점**:
-- 지침 위반 (리스트만 사용)
-- 모바일에서 가독성 저하
-- 유지보수 어려움
-
-**예방책**:
-- ✅ **테이블 금지, 리스트만 사용** (- 또는 숫자 목록)
-- ✅ **작성 후 `| |` 패턴 검색으로 테이블 확인**
-- ✅ **수치/계산은 리스트 형식**:
-
-**❌ 금지 (테이블)**:
-```markdown
-| 항목 | 월 | 연간 |
-|------|-----|------|
-| 월세 | 150만 | 1,800만 |
-```
-
-**✅ 권장 (리스트)**:
-```markdown
-월 경비 구성:
-- 월세: 150만 원 (연 1,800만 원)
-- 재료비: 180만 원 (연 2,160만 원)
-- 직원급여: 100만 원 (연 1,200만 원)
-```
-
----
-
-### 4️⃣ 계산 예시 누락 ❌
-
-**과거 오류**: 포스트에 개념만 있고 실제 계산 예시 부족
-
-**문제점**:
-- 고객이 "내 상황에 얼마나 해당하나" 판단 어려움
-- 추상적 설명으로 설득력 감소
-- 세무사 필요성 전달 미흡
-
-**예방책**:
-- ✅ **모든 포스트에 구체적 계산 예시 필수**
-- ✅ **절세액을 수치로 제시** ("약 50만 원 절약")
-- ✅ **단계별 계산 과정 포함** (Step 1️⃣, 2️⃣, 3️⃣, 4️⃣)
-- ✅ **실제 사례로 숫자 구체화**:
-
-**예시**:
-```markdown
-### Step 1️⃣: 매출 정리
-월 600만 원 × 12개월 = 연 7,200만 원
-
-### Step 2️⃣: 경비 계산
-- 월세: 150만 원 → 연 1,800만 원
-- 재료비: 180만 원 → 연 2,160만 원
-합계: 5,400만 원
-
-### Step 3️⃣: 순이익
-7,200만 - 5,400만 = 1,800만 원
-
-### Step 4️⃣: 세금
-1,800만 원 × 약 6% = **약 108만 원/년**
-```
-
----
-
-### 5️⃣ 카테고리 주제 불일치 ❌
-
-**과거 오류**: 포스트 주제와 카테고리가 맞지 않음
-
-**문제점**:
-- 고객이 원하는 정보 검색 불가
-- 카테고리 신뢰도 저하
-- UX 혼란
-
-**예방책**:
-- ✅ **포스트 작성 전 카테고리 명확히 결정**
-- ✅ **포스트 주제와 카테고리 일관성 검증**:
-
-| 포스트 | 카테고리 | 확인 |
-|--------|---------|------|
-| 프리랜서 경비 | 종합소득세 (3) | ✅ 맞음 |
-| 월세 신고 | 부동산 세금 (2) | ✅ 맞음 |
-| 자녀 증여세 | 가족자산·증여 (5) | ✅ 맞음 |
-| 사업자 기장 | 사업자 세무 (1) | ✅ 맞음 |
-| 부가세 신고 | 부가가치세 (4) | ✅ 맞음 |
-
----
-
-### 6️⃣ 정확한 세법 인용 누락 ❌
-
-**과거 오류**: 일부 포스트에서 법조 명시 부족
-
-**문제점**:
-- 정확성 원칙 위반
-- 법적 책임 불명확
-- 고객 신뢰도 저하
-
-**예방책**:
-- ✅ **모든 주요 내용에 세법 조항 인용 필수**
-- ✅ **형식**: "소득세법 제XX조에 따르면"
-- ✅ **연도 기준 명시**: "2025년 기준"
-- ✅ **포스트 끝에 "법적 근거" 섹션 필수**:
-
-```markdown
-**법적 근거**:
-- 소득세법 제29조 (수입금액의 계산)
-- 국세기본법 제47조 (가산세)
-- 소득세법 제160조 (증빙 보관)
-```
-
----
-
-## ✅ 포스트 최종 체크리스트
-
-모든 포스트를 DB에 등록하기 전에 다음을 확인하세요:
-
-- [ ] **카테고리 할당**: `category_id NOT NULL` (필수)
-- [ ] **내용 길이**: `LENGTH(content) >= 1500` (최소 1,500자)
-- [ ] **테이블 확인**: `| |` 패턴 없음 (리스트만)
-- [ ] **계산 예시**: Step 1️⃣~4️⃣ 포함 (절세액 수치)
-- [ ] **세법 인용**: 모든 주요 내용에 법조 명시
-- [ ] **카테고리 일치**: 포스트 주제 ↔ 카테고리 일관성
-- [ ] **3단계 구조**: 1️⃣ 기초 → 2️⃣ 현실 → 3️⃣ 해결책
-- [ ] **광고 규칙**: 금지 표현(보장, 최저가, 무료) 없음
-- [ ] **사례 포함**: 실제 상황 + 이름/나이/직업 구체화
-- [ ] **정확성**: 추측/예상/의견 표현 없음
-
-**체크 쿼리**:
-```sql
--- DB 적용 후 확인
-SELECT id, title, LENGTH(content), category_id
-FROM blog_posts
-WHERE LENGTH(content) < 1500 OR category_id IS NULL
-ORDER BY id;
--- 결과 없음이 정상!
-```

CLAUDE.md

@@ -8,8 +8,8 @@
 Blazor → Service (서버) → DB
 
 ✅ 현재: API-First (클라이언트-서버 분리)
-Blazor (UI만, 사용자 액션 후 API 재조회) ← API (모든 로직) ← DB
+Blazor (UI만) ← API (모든 로직) ← DB
-          Blazor 데이터 변경 자동 push/broadcast 금지
+          SignalR (변경 알림만)
 ```
 
 ### SOLID 기반 순차 마이그레이션 전략
@@ -61,10 +61,10 @@ _refreshTokenExpirationMinutes = 10080;
 
 **완료**: 2026-06-28 / 토큰 갱신 자동화 + 이중 토큰 패턴
 
-#### Phase 6: Blazor 데이터 변경 SignalR 갱신 제거
+#### Phase 6: SignalR 통합
-- [x] NotificationHub 제거
+- [ ] NotificationHub (변경 알림만)
-- [x] 데이터 변경용 INotificationService 제거
+- [ ] Blazor에서 구독
-- [x] Program.cs의 별도 AddSignalR/MapHub 등록 제거
+- [ ] 알림 후 API로 데이터 검증
 
 #### Phase 7: 순차적 마이그레이션 ✅
 - [x] Blog 페이지 → API 클라이언트
@@ -76,7 +76,7 @@ _refreshTokenExpirationMinutes = 10080;
 - 모든 API 엔드포인트 구현됨
 - 모든 Browser Client 구현됨
 - 16개 Blazor 페이지 API-First 마이그레이션 완료
-- MudDataGrid 더존 세무회계프로그램 UX 수준 적용
+- MudDataGrid Douzone ERP 수준 UX 적용
 - MudDialog 모달 패턴 (흰 화면 플래시 제거)
 - ConfirmDialog 삭제 확인 컴포넌트
 
@@ -119,7 +119,7 @@ _refreshTokenExpirationMinutes = 10080;
 - 5개 API Controller (TaxProfile, TaxFilingSchedule, ConsultingActivity, Contract, RevenueTracking)
 - 5개 Browser Client (API-First 패턴)
 - 5개 Blazor 페이지 (MudDataGrid Dense, Virtualize, Modal Dialog)
-- 더존 세무회계프로그램 수준의 그리드 UX (32px 행 높이, 데이터 밀도 최적화)
+- Douzone ERP 수준의 그리드 UX (32px 행 높이, 데이터 밀도 최적화)
 
 | 페이지 | API | Client | Blazor | 핵심 기능 |
 |------|---|---|---|---------|
@@ -136,11 +136,11 @@ _refreshTokenExpirationMinutes = 10080;
 - Status Color Chips (Error/Warning/Success)
 - Client 링크 (상세 페이지 연동)
 
-### **Phase 6: Lite Blazor 운영 원칙** ✅
+### **Phase 6: SignalR 통합** ✅
-- Blazor에서 데이터 변경 시 SignalR publish/subscribe로 목록을 자동 갱신하지 않는다.
+- NotificationHub (브로드캐스트만, 상태 관리 없음)
-- NotificationHub와 데이터 변경용 INotificationService는 제거된 상태를 유지한다.
+- INotificationService (이벤트 기반)
-- Blazor Server의 기본 interactive 연결은 UI 구동에만 사용한다.
+- 5개 알림 유형 (Inquiry, Client, Announcement, Filing, Status)
-- 공지사항, 문의, 고객, 신고 등 도메인 CRUD 기능은 그대로 유지하고, 변경 전파 방식만 API 재조회로 제한한다.
+- Program.cs SignalR 등록
 
 ---
 
@@ -160,11 +160,11 @@ Repositories (데이터 계층)
 PostgreSQL Database
 ```
 
-**Lite Blazor 데이터 갱신**:
+**Blazor Server SignalR**:
-- Blazor Server 자동 연결은 컴포넌트 상호작용용 기본 회선으로만 사용한다.
+- 자동 연결 (내장 Hub connection)
-- 데이터 변경 알림용 별도 Hub, 그룹, broadcast, client subscription을 추가하지 않는다.
+- NotificationHub 클라이언트 그룹 (admins)
-- 저장/삭제/완료 같은 사용자 액션 이후 필요한 목록만 API로 다시 조회한다.
+- 이벤트 기반 메시지 (상태 관리 없음)
-- 공지사항, 문의, 고객, 신고 등 도메인 CRUD 기능은 그대로 유지한다.
+- 클라이언트는 알림 후 API로 데이터 검증
 
 ---
 
@@ -182,10 +182,10 @@ PostgreSQL Database
 - [x] Phase 7-4: CRM & 세무관리 (5개 API, 5개 Blazor) - **2026-06-28 완료**
 - [x] SOLID 원칙 전체 적용 (Single Responsibility, Dependency Inversion)
 
-**Lite Blazor / 데이터 갱신 (Phase 6)**:
+**실시간 알림 (Phase 6)**:
-- [x] Blazor 데이터 변경 SignalR 자동 갱신 제거
+- [x] NotificationHub 구현
-- [x] NotificationHub 제거
+- [x] Event-driven 알림 시스템
-- [x] 데이터 변경용 INotificationService 제거
+- [x] Scoped DI 등록
 
 **Blazor 페이지 & UI 고도화 (Phase 7-4)**:
 - [x] 5개 CRM/세무관리 Blazor 페이지
@@ -564,24 +564,33 @@ ssh kjh2064@178.104.200.7
 
 배포는 수동 실행이 아니라 **Gitea Actions CI/CD**만 사용한다.
 
-**무중단 Green-Blue 배포 아키텍처 (2026-06-30 적용 완료)**:
+**표준 배포 (현재)**:
-1. **프록시 레이어**: 포트 `5001`에서 영구 가동되는 초경량 .NET TCP 프록시([TaxBaik.Proxy])가 수신 대기합니다. Nginx는 `/taxbaik` 트래픽을 기존과 같이 `5001`로 중계합니다.
+1. `master` 브랜치에 push
-2. **동적 포트 스위칭**: 프록시는 요청이 들어올 때마다 `/home/kjh2064/taxbaik_port` 파일을 읽어 active 포트(5003 또는 5004)를 판단하고 트래픽을 포워딩합니다.
+2. Gitea Actions가 `TaxBaik.Web`을 build/publish
-3. **배포 흐름 (`deploy_gb.sh`)**:
+3. CI가 서버의 `taxbaik` 서비스와 `~/taxbaik_active`를 갱신
-   - Gitea Actions가 코드를 build/publish 후 압축하여 서버에 업로드합니다.
+4. CI가 서비스 재시작 후 `/taxbaik/admin/login`으로 헬스 체크
-   - 서버의 배포 스크립트([deploy_gb.sh])가 실행되어 현재 미사용 중인 예비 포트(Target Port: 5003 또는 5004)를 파악합니다.
+
-   - 예비 포트에서 새 .NET 웹 앱을 실행하고 `http://127.0.0.1:$target_port/taxbaik/healthz` 헬스 체크를 통과할 때까지 폴링(최대 60초)합니다.
+**API 클라이언트 설정 (Green-Blue 대비)**:
-   - 헬스 체크 성공 시 `/home/kjh2064/taxbaik_port` 파일에 새 포트 번호를 기입하여 **트래픽을 즉시 무중단 전환**합니다.
+- API 클라이언트 Base URL이 이제 동적 설정됨: `appsettings.json` > `ApiClient:BaseUrl`
-   - 기존 포트에서 동작하던 구버전 .NET 프로세스를 종료(`kill -15`)합니다.
+- 기본값: `http://localhost:5001/taxbaik/api/`
-   - 만약 헬스 체크 실패 시 새 프로세스만 강제 종료하고 배포를 롤백하여 실서비스 다운타임을 방지합니다.
+- 배포 시 환경변수로 오버라이드 가능:
+  ```bash
+  export ApiClient__BaseUrl="http://localhost:5002/taxbaik/api/"
+  systemctl start taxbaik  # 새 포트에 배포
+  ```
+- Nginx가 `/taxbaik` → active 포트로 라우팅하면 자동 전환됨
 
 **운영 규칙**:
-- 로컬 또는 서버에서 수동 `dotnet publish`로 운영 배포하지 않는다.
+- 로컬 또는 서버에서 수동 `dotnet publish`로 운영 배포하지 않는다
-- 배포 실패 시 Gitea Actions CI/CD 로그 및 `~/deployments/taxbaik_timestamp/web_*.log`를 먼저 확인한다.
+- `rsync`로 직접 아티팩트를 올리지 않는다
-- 배포 후 최종 검증은 프록시 포트를 경유하는 메인 홈페이지, 관리자 로그인 페이지, 로그인 API를 모두 포함한다.
+- 배포 실패 시 CI 로그를 먼저 본다
+- 배포된 아티팩트는 CI가 만든 것만 신뢰한다
+- 배포 후 검증은 홈, 관리자 로그인 페이지, 로그인 API를 모두 포함한다
 
 **롤백**:
-- 이전 정상 커밋을 `master`에 revert 또는 hotfix로 되돌려 다시 배포를 수행하거나, 비상시 서버의 `taxbaik_port` 파일의 포트 번호를 수동 수정하여 이전 버전 포트로 즉시 원상복구한다.
+- 이전 정상 커밋을 `master`에 revert 또는 hotfix로 되돌린다
+- 서버 파일을 수동으로 복구하지 않는다
+- 롤백은 커밋 단위로 추적 가능해야 한다
 
 ### 3.4 서비스 파일 위치
 ```
@@ -745,22 +754,6 @@ ssh kjh2064@178.104.200.7 crontab -l | grep backup
 
 ---
 
-## 5-1. 블로그 & FAQ 콘텐츠 작성 규칙
-
-**핵심**: 고객 임파워먼트 (당신도 할 수 있습니다!)
-- ✅ 주변에서 흔히 보는 실제 사례 (이름, 나이, 직업 구체화)
-- ✅ 절세 효과 수치화 ("세금을 X만 원 절약했습니다")
-- ✅ 중학교 2학년도 이해 가능한 수준
-- ✅ 단계별 설명 + 표로 시각화
-- ✅ 결론: "정확하게 하면 이런 이점이 있습니다" (임파워먼트)
-
-**피해야 할 톤**: "복잡하니까 맡기세요" (세무사 의존성 강화)  
-**세무사 언급**: "더 복잡하면 전문가와 상담하세요" (선택지)
-
-**자세한 템플릿 및 체크리스트**: `BLOG_TEMPLATE.md` 참고
-
----
-
 ## 6. 코드 규칙
 
 ### 6.1 C# 네이밍
@@ -972,9 +965,9 @@ Admin 로그인 페이지만 [AllowAnonymous]:
 - 페이지 로드 시 `OnInitializedAsync`에서 데이터 가져오기
 - 업데이트는 `StateHasChanged()` 호출
 
-### 8.6 어드민 그리드 UX (더존 세무회계프로그램 수준)
+### 8.6 어드민 그리드 UX (Dorsum ERP 수준)
 
-**목표**: 패드/PC에 특화된 고밀도 데이터 표시 + 더존식 상호작용성
+**목표**: 패드/PC에 특화된 고밀도 데이터 표시 + ERP 수준의 상호작용성
 
 #### 그리드 기본 원칙
 - **데이터 밀도**: 줄 높이 32px, 최대 주요 정보 5-7개 컬럼 (시각적 혼잡 제거)
@@ -1644,7 +1637,7 @@ curl http://127.0.0.1/taxbaik/admin/login
 ### E2E 테스트 & 반응형 검증
 ```bash
 # 문의 폼 제출
-curl -X POST http://taxbaik.com/taxbaik/contact \
+curl -X POST http://178.104.200.7/taxbaik/contact \
   -d "name=테스트&phone=010-1234-5678&service_type=사업자세무&message=테스트"
 
 # 관리자 DB에서 확인
@@ -1683,7 +1676,7 @@ npx playwright test admin-responsive.spec.ts --project="Desktop Chrome"
 
 **프로덕션 E2E 테스트**:
 ```bash
-export E2E_BASE_URL="http://taxbaik.com/taxbaik"
+export E2E_BASE_URL="http://178.104.200.7/taxbaik"
 export E2E_ADMIN_USERNAME="test_admin"
 export E2E_ADMIN_PASSWORD="TestAdmin@123456"
 
@@ -1951,7 +1944,7 @@ else
 2. **Actions run 생성 확인**
    ```powershell
    $headers = @{ Authorization = "token $env:GITEA_TOKEN_TAXBAIK" }
-   $runs = Invoke-RestMethod -Headers $headers -Uri "http://gitea.taxbaik.com/api/v1/repos/kjh2064/taxbaik/actions/runs?limit=10"
+   $runs = Invoke-RestMethod -Headers $headers -Uri "http://178.104.200.7/api/v1/repos/kjh2064/taxbaik/actions/runs?limit=10"
    $runs.workflow_runs | Select-Object id,path,event,head_sha,display_title,status,conclusion
    ```
    `deploy.yml@refs/heads/master`, `event=push`, 최신 `head_sha`가 있어야 배포가 실제로 시작된 것이다.

CLOUD_SERVER_SETUP.md

@@ -17,7 +17,7 @@
 | 3.3 | [주요 Python 패키지](#33-주요-python-패키지-시스템) | 시스템/venv 패키지 구분 |
 | 4 | [서비스 아키텍처](#4-서비스-아키텍처) | 포트 맵, Nginx 리버스 프록시 |
 | 4.1 | [포트 맵](#41-포트-맵) | 22, 80, 2222, 3000, 5000, 5432 |
-| 4.2 | [Nginx 리버스 프록시](#42-nginx-리버스-프록시) | 도메인 기반 가상 호스트 분기 (홈페이지, Gitea, Quant) |
+| 4.2 | [Nginx 리버스 프록시](#42-nginx-리버스-프록시) | `/` → Gitea, `/quant/` → Blazor |
 | 5 | [Gitea](#5-gitea) | Docker Compose 설정, 시크릿, 데이터 경로 |
 | 5.1 | [Docker Compose](#51-docker-compose) | `gitea:1.26.4`, PG 연동 |
 | 5.2 | [시크릿 관리](#52-시크릿-관리) | `/opt/stacks/gitea/.env` |
@@ -126,84 +126,16 @@ boto3, cryptography, Jinja2, jsonschema, fail2ban 등 시스템 레벨로 설치
 ### 4.2. Nginx 리버스 프록시
 
 ```nginx
-# /etc/nginx/sites-available/taxbaik-domains.conf
+# /etc/nginx/sites-enabled/gitea-ip.conf
 
-# 1. TaxBaik 홈페이지 (taxbaik.com, www.taxbaik.com)
 server {
-    server_name taxbaik.com www.taxbaik.com;
+    listen 80 default_server;
+    listen [::]:80 default_server;
+    server_name _;
     client_max_body_size 512M;
 
-
+    # QuantEngine Blazor Web App
-    # /admin 하위 요청을 /taxbaik/admin 으로 리다이렉트하여 Blazor Base Path 대응
+    location /quant/ {
-    location /admin {
-        return 301 $scheme://$host/taxbaik$request_uri;
-    }
-
-    # 루트 경로 요청을 /taxbaik 으로 프록싱하여 base href /taxbaik/ 에 대응
-    location / {
-        proxy_pass http://127.0.0.1:5001/taxbaik/;
-        proxy_http_version 1.1;
-        proxy_set_header Upgrade $http_upgrade;
-        proxy_set_header Connection "Upgrade";
-        proxy_set_header Host $host;
-        proxy_cache_bypass $http_upgrade;
-        proxy_set_header X-Real-IP $remote_addr;
-        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
-        proxy_set_header X-Forwarded-Proto $scheme;
-    }
-
-    # /taxbaik/ 하위로 들어오는 리소스 및 페이지 요청 처리
-    location /taxbaik {
-        proxy_pass http://127.0.0.1:5001;
-        proxy_http_version 1.1;
-        proxy_set_header Upgrade $http_upgrade;
-        proxy_set_header Connection "Upgrade";
-        proxy_set_header Host $host;
-        proxy_set_header X-Real-IP $remote_addr;
-        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
-        proxy_set_header X-Forwarded-Proto $scheme;
-        proxy_read_timeout 120s;
-    }
-
-    listen 443 ssl; # managed by Certbot
-    ssl_certificate /etc/letsencrypt/live/taxbaik.com/fullchain.pem; # managed by Certbot
-    ssl_certificate_key /etc/letsencrypt/live/taxbaik.com/privkey.pem; # managed by Certbot
-    include /etc/letsencrypt/options-ssl-nginx.conf; # managed by Certbot
-    ssl_dhparam /etc/letsencrypt/ssl-dhparams.pem; # managed by Certbot
-
-
-}
-
-# 2. Gitea (gitea.taxbaik.com)
-server {
-    server_name gitea.taxbaik.com;
-    client_max_body_size 512M;
-
-    location / {
-        proxy_pass http://127.0.0.1:3000;
-        proxy_http_version 1.1;
-        proxy_set_header Host $host;
-        proxy_set_header X-Real-IP $remote_addr;
-        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
-        proxy_set_header X-Forwarded-Proto $scheme;
-        proxy_read_timeout 300;
-        proxy_connect_timeout 300;
-        proxy_send_timeout 300;
-    }
-
-    listen 443 ssl; # managed by Certbot
-    ssl_certificate /etc/letsencrypt/live/taxbaik.com/fullchain.pem; # managed by Certbot
-    ssl_certificate_key /etc/letsencrypt/live/taxbaik.com/privkey.pem; # managed by Certbot
-    include /etc/letsencrypt/options-ssl-nginx.conf; # managed by Certbot
-    ssl_dhparam /etc/letsencrypt/ssl-dhparams.pem; # managed by Certbot
-
-}
-
-# 3. QuantEngine (quant.taxbaik.com)
-server {
-    server_name quant.taxbaik.com;
-
-    location / {
         proxy_pass http://127.0.0.1:5000/;
         proxy_http_version 1.1;
         proxy_set_header Upgrade $http_upgrade;
@@ -215,64 +147,25 @@ server {
         proxy_set_header X-Forwarded-Proto $scheme;
     }
 
-    listen 443 ssl; # managed by Certbot
+    # Gitea (기본)
-    ssl_certificate /etc/letsencrypt/live/taxbaik.com/fullchain.pem; # managed by Certbot
+    location / {
-    ssl_certificate_key /etc/letsencrypt/live/taxbaik.com/privkey.pem; # managed by Certbot
+        proxy_pass http://127.0.0.1:3000;
-    include /etc/letsencrypt/options-ssl-nginx.conf; # managed by Certbot
+        proxy_http_version 1.1;
-    ssl_dhparam /etc/letsencrypt/ssl-dhparams.pem; # managed by Certbot
+        proxy_set_header Host $host;
-
+        proxy_set_header X-Real-IP $remote_addr;
-}
+        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
-
+        proxy_set_header X-Forwarded-Proto $scheme;
-server {
+        proxy_read_timeout 300;
-    if ($host = www.taxbaik.com) {
+        proxy_connect_timeout 300;
-        return 301 https://$host$request_uri;
+        proxy_send_timeout 300;
-    } # managed by Certbot
+    }
-
-
-    if ($host = taxbaik.com) {
-        return 301 https://$host$request_uri;
-    } # managed by Certbot
-
-
-    listen 80;
-    server_name taxbaik.com www.taxbaik.com;
-    return 404; # managed by Certbot
-
-
-
-
-}
-server {
-    if ($host = gitea.taxbaik.com) {
-        return 301 https://$host$request_uri;
-    } # managed by Certbot
-
-
-    listen 80;
-    server_name gitea.taxbaik.com;
-    return 404; # managed by Certbot
-
-
-}
-server {
-    if ($host = quant.taxbaik.com) {
-        return 301 https://$host$request_uri;
-    } # managed by Certbot
-
-
-    listen 80;
-    server_name quant.taxbaik.com;
-    return 404; # managed by Certbot
-
-
 }
 ```
 
 **라우팅 요약**:
-- `http://taxbaik.com/` 또는 `http://www.taxbaik.com/` → TaxBaik 홈페이지 (내부 proxy: `http://127.0.0.1:5001/taxbaik/`)
+- `http://178.104.200.7/` → Gitea Web UI
-- `http://gitea.taxbaik.com/` → Gitea Web UI (내부 proxy: `http://127.0.0.1:3000`)
+- `http://178.104.200.7/quant/` → QuantEngine Blazor Admin
-- `http://quant.taxbaik.com/` → QuantEngine Blazor Admin (내부 proxy: `http://127.0.0.1:5000/`)
+- `ssh://178.104.200.7:2222` → Gitea Git SSH
-- `ssh://gitea.taxbaik.com:2222` → Gitea Git SSH
 
 ## 5. Gitea
 
@@ -491,7 +384,7 @@ ClientAliveCountMax 2
 | **CI Runner** | Synology Act Runner | 6× `act_runner:latest` (Docker) |
 | **DB** | SQLite (파일 기반) | PostgreSQL 18 + SQLite (하이브리드) |
 | **웹 Admin** | 없음 | QuantEngine Blazor (.NET 10, MudBlazor) |
-| **리버스 프록시** | Synology 내장 | Nginx (도메인 기반 분기 - 홈페이지, Gitea, Quant) |
+| **리버스 프록시** | Synology 내장 | Nginx (`/` → Gitea, `/quant/` → Blazor) |
 | **보안** | DSM 방화벽 | fail2ban + SSH 공개키 + 서비스 로컬바인드 |
 | **시크릿 관리** | `.secrets/kis_real.env` | `/opt/stacks/gitea/.env` |
 | **OS** | Synology DSM 7.x | Ubuntu 26.04 LTS |

DEPLOYMENT_GUIDE.md

@@ -19,46 +19,32 @@ GRANT ALL PRIVILEGES ON DATABASE taxbaikdb TO taxbaik;
 
 ### 2. 환경 변수 설정
 
-**Web 서비스** (`/etc/systemd/system/taxbaik.service`, 백엔드 전용):
+**Web 서비스** (`/etc/systemd/system/taxbaik.service`):
 ```ini
 [Service]
 Environment=ASPNETCORE_ENVIRONMENT=Production
-Environment=ASPNETCORE_URLS=http://127.0.0.1:5004
+Environment=ASPNETCORE_URLS=http://127.0.0.1:5001
 Environment=ConnectionStrings__Default=Host=localhost;Database=taxbaikdb;Username=taxbaik;Password=your_secure_password
 ```
 
-**프록시 서비스** (`/etc/systemd/system/taxbaik-proxy.service`, 5001 진입점):
-```ini
-[Service]
-ExecStart=/usr/bin/dotnet TaxBaik.Proxy.dll
-WorkingDirectory=/home/kjh2064/taxbaik_active
-Restart=always
-```
-
 ### 3. systemd 서비스 파일 설치
 
 ```bash
 sudo cp deploy/taxbaik.service /etc/systemd/system/
-sudo cp deploy/taxbaik-proxy.service /etc/systemd/system/
 sudo systemctl daemon-reload
 sudo systemctl enable taxbaik
-sudo systemctl enable taxbaik-proxy
 ```
 
 ### 4. Nginx 설정
 
 ```bash
-# Nginx 도메인 기반 가상 호스트 설정 복사
+# 현재 Nginx 설정 확인
-sudo cp deploy/nginx-taxbaik-domains.conf /etc/nginx/sites-available/taxbaik-domains.conf
+sudo cat /etc/nginx/sites-available/default | head -30
 
-# 기존 설정(IP 기반 및 default) 활성화 해제
+# location 블록 추가 (또는 기존 설정에 병합)
-sudo rm -f /etc/nginx/sites-enabled/default
+sudo cp deploy/nginx-taxbaik-locations.conf /etc/nginx/conf.d/taxbaik.conf
-sudo rm -f /etc/nginx/sites-enabled/gitea-ip.conf
 
-# 새 설정 활성화 (심링크 생성)
+# 테스트 및 재로드
-sudo ln -sfn /etc/nginx/sites-available/taxbaik-domains.conf /etc/nginx/sites-enabled/taxbaik-domains.conf
-
-# 설정 문법 테스트 및 Nginx 서비스 리로드
 sudo nginx -t
 sudo systemctl reload nginx
 ```
@@ -79,7 +65,7 @@ sudo systemctl reload nginx
    master 브랜치 push → build → test → publish → restart → health check → Playwright
    ```
 
-수동 배포는 사용하지 않습니다. `deploy_gb.sh`는 `TAXBAIK_DEPLOY_FROM_CI=1`이 없으면 즉시 종료하므로, 배포는 반드시 Gitea Actions에서만 실행됩니다.
+수동 배포는 비상 롤백 외에는 사용하지 않습니다. 배포 이슈는 Gitea Actions 로그로 해결합니다.
 
 ## 마이그레이션 자동 실행
 
@@ -142,7 +128,6 @@ ls -la ~/deployments/ | grep taxbaik
 
 # 심링크 변경 (예: 이전 버전이 taxbaik_20260626_140000)
 ln -sfn ~/deployments/taxbaik_20260626_140000 ~/taxbaik_active
-sudo systemctl restart taxbaik-proxy
 sudo systemctl restart taxbaik
 ```
 
@@ -154,10 +139,10 @@ sudo systemctl restart taxbaik
 ssh kjh2064@178.104.200.7
 
 # 서비스 상태
-systemctl status taxbaik taxbaik-proxy
+systemctl status taxbaik
 
 # 포트 확인
-netstat -tlnp | grep -E '5001|5004'
+netstat -tlnp | grep -E '5001'
 
 # 프로세스 확인
 ps aux | grep TaxBaik
@@ -180,27 +165,9 @@ journalctl -u taxbaik -f
 | 404 /taxbaik | Nginx 설정 미적용 | `sudo nginx -t && sudo systemctl reload nginx` |
 | Blazor WebSocket 안 됨 | `/taxbaik` location에 `proxy_http_version 1.1`, `Upgrade`, `Connection \"Upgrade\"` 헤더가 모두 있는지 확인 |
 | DB 연결 오류 | 환경 변수 미설정 | systemd service 파일의 ConnectionStrings__Default 확인 |
-| 503 Service Unavailable | 백엔드 또는 프록시 미시작 | `sudo systemctl restart taxbaik-proxy taxbaik` |
+| 503 Service Unavailable | 앱 미시작 | `sudo systemctl restart taxbaik` |
 | 마이그레이션 실패 | DB 권한 문제 | `GRANT ALL PRIVILEGES ON DATABASE taxbaikdb TO taxbaik;` |
 
-## 운영 복구 순서
-
-```bash
-ssh kjh2064@178.104.200.7
-sudo cp /home/kjh2064/taxbaik.service /etc/systemd/system/taxbaik.service
-sudo cp /home/kjh2064/taxbaik-proxy.service /etc/systemd/system/taxbaik-proxy.service
-sudo systemctl daemon-reload
-sudo systemctl restart taxbaik-proxy
-sudo systemctl restart taxbaik
-curl -I http://127.0.0.1:5001/taxbaik/admin/login
-```
-
-## 원라인 점검
-
-```bash
-ssh kjh2064@178.104.200.7 'systemctl status taxbaik taxbaik-proxy --no-pager --lines=3 && ss -tlnp | grep -E ":5001 |:5004 " && curl -fsSI http://127.0.0.1:5001/taxbaik/admin/login && curl -fsS http://127.0.0.1:5001/taxbaik/favicon.svg >/dev/null && curl -fsS http://127.0.0.1:5001/taxbaik/robots.txt >/dev/null'
-```
-
 ## 초기 데이터
 
 ### 관리자 계정

PRODUCTION_CHECKLIST.md

@@ -48,7 +48,29 @@ ssh kjh2064@178.104.200.7 'bash ~/SERVER_SETUP.sh'
 # ~/taxbaik_active
 ```
 
-### 2단계: Gitea Actions 설정
+### 2단계: 첫 배포 (수동)
+
+```bash
+# 로컬에서 실행
+TIMESTAMP=$(date +%Y%m%d_%H%M%S)
+
+# SSH 키 설정 (필요시)
+export DEPLOY_USER="kjh2064"
+export DEPLOY_HOST="178.104.200.7"
+
+# 배포
+rsync -avz --delete ./publish/ \
+  $DEPLOY_USER@$DEPLOY_HOST:~/deployments/taxbaik_${TIMESTAMP}/
+
+# 심링크 변경 및 시작
+ssh $DEPLOY_USER@$DEPLOY_HOST << EOF
+ln -sfn ~/deployments/taxbaik_${TIMESTAMP} ~/taxbaik_active
+sudo systemctl start taxbaik
+sudo systemctl status taxbaik
+EOF
+```
+
+### 3단계: Gitea Actions 설정 (선택)
 
 **Gitea 저장소 Settings → Secrets 추가**:
 - `DEPLOY_USER`: `kjh2064`
@@ -195,8 +217,8 @@ curl -I -H "Accept-Encoding: gzip" http://178.104.200.7/taxbaik/ | grep -i encod
 | 증상 | 원인 | 해결 방법 |
 |------|------|----------|
 | 404 /taxbaik | Nginx 설정 미적용 | `sudo nginx -t && sudo systemctl reload nginx` |
-| 502 Bad Gateway | 프록시 또는 백엔드 미실행 | `sudo systemctl restart taxbaik-proxy taxbaik` |
+| 502 Bad Gateway | 앱 미실행 | `sudo systemctl restart taxbaik` |
-| 503 Service Unavailable | 백엔드 충돌 또는 비밀값 누락 | 로그 확인: `journalctl -u taxbaik -n 50` |
+| 503 Service Unavailable | 앱 충돌 | 로그 확인: `journalctl -u taxbaik -n 50` |
 | DB 연결 오류 | 환경 변수 미설정 | systemd 파일의 ConnectionStrings__Default 확인 |
 | HTTPS 오류 | SSL 미구성 | 개발 환경에서는 HTTP 사용 (IP 기반) |
 | 마이그레이션 실패 | 테이블 존재 | `DROP DATABASE taxbaikdb;` 후 재시작 |
@@ -208,11 +230,11 @@ curl -I -H "Accept-Encoding: gzip" http://178.104.200.7/taxbaik/ | grep -i encod
 ### 실시간 모니터링
 
 ```bash
-# 터미널 1: 백엔드 로그
+# 터미널 1: 웹 서비스 로그
 ssh kjh2064@178.104.200.7 'journalctl -u taxbaik -f'
 
-# 터미널 2: 프록시 로그
+# 터미널 2: 통합 서비스 로그
-ssh kjh2064@178.104.200.7 'journalctl -u taxbaik-proxy -f'
+ssh kjh2064@178.104.200.7 'journalctl -u taxbaik -f'
 
 # 터미널 3: Nginx 로그
 ssh kjh2064@178.104.200.7 'sudo tail -f /var/log/nginx/access.log | grep taxbaik'
@@ -224,7 +246,13 @@ ssh kjh2064@178.104.200.7 'watch -n 1 "ps aux | grep TaxBaik"'
 ### 정기적 검사
 
 ```bash
-# 일일 체크는 CI 배포 후 자동 검증으로 대체
+# 일일 체크 (cron job)
+0 9 * * * /home/kjh2064/health-check.sh
+
+# 내용:
+#!/bin/bash
+curl -f http://127.0.0.1:5001/taxbaik || systemctl restart taxbaik
+curl -f http://127.0.0.1:5001/taxbaik/admin/login || systemctl restart taxbaik
 ```
 
 ---
@@ -240,6 +268,11 @@ git commit -m "기능: 새로운 기능 추가"
 git push origin master
 
 # 2. Gitea Actions가 자동으로 배포
+#    또는 수동 배포:
+TIMESTAMP=$(date +%Y%m%d_%H%M%S)
+dotnet publish TaxBaik.Web -c Release -o ./publish
+rsync -avz ./publish/ kjh2064@178.104.200.7:~/deployments/taxbaik_${TIMESTAMP}/
+ssh kjh2064@178.104.200.7 "ln -sfn ~/deployments/taxbaik_${TIMESTAMP} ~/taxbaik_active && sudo systemctl restart taxbaik"
 ```
 
 ### 롤백 절차
@@ -251,7 +284,6 @@ ssh kjh2064@178.104.200.7 'ls -la ~/deployments/ | grep taxbaik'
 # 롤백 (예: 이전 버전이 taxbaik_20260625_100000)
 ssh kjh2064@178.104.200.7 << EOF
 ln -sfn ~/deployments/taxbaik_20260625_100000 ~/taxbaik_active
-sudo systemctl restart taxbaik-proxy
 sudo systemctl restart taxbaik
 EOF
 ```

README.md

@@ -168,7 +168,7 @@ master 브랜치에 푸시하면 파이프라인이 다음 단계를 수행합
 - `TAXBAIK_ADMIN_TEST_PASSWORD`: 배포 검증용 관리자 비밀번호
 - `Admin__PasswordResetToken`: 관리자 비밀번호 재설정 API용 서버 비밀값
 
-배포는 Gitea Actions CI/CD로만 수행합니다. 수동 배포 경로는 CI 하네스로 차단되어 있으며, 실패 시 [DEPLOYMENT_GUIDE.md](./DEPLOYMENT_GUIDE.md)의 CI 점검 절차를 따릅니다.
+수동 배포는 비상 롤백 절차 외에는 사용하지 않습니다. 실패 시 [DEPLOYMENT_GUIDE.md](./DEPLOYMENT_GUIDE.md)의 CI 점검 절차를 따릅니다.
 
 ---
 
@@ -270,13 +270,7 @@ echo $ConnectionStrings__Default
 
 ## 문서
 
-- [docs/INDEX.md](./docs/INDEX.md) - 현재 개발 기준 인덱스
+- [CLAUDE.md](./CLAUDE.md) - LLM 개발 지침 (9개 섹션)
-- [docs/ENGINEERING_HARNESS.md](./docs/ENGINEERING_HARNESS.md) - 코드 품질, API-first, CI/CD 하네스
-- [docs/DOUZONE_UX_GUIDE.md](./docs/DOUZONE_UX_GUIDE.md) - 더존식 어드민 UX 원칙과 템플릿 기준
-- [docs/COMMON_CODE_POLICY.md](./docs/COMMON_CODE_POLICY.md) - 공통코드 저장값/컬럼 길이/하드코딩 금지 기준
-- [docs/COMBO_POLICY.md](./docs/COMBO_POLICY.md) - 콤보/검색/선택 입력 정책
-- [docs/ADMIN_PATTERN_CRITIQUE_WBS.md](./docs/ADMIN_PATTERN_CRITIQUE_WBS.md) - 어드민 패턴 비판 및 정량 WBS
-- [CLAUDE.md](./CLAUDE.md) - 보조 LLM 개발 지침
 - [DEPLOYMENT_GUIDE.md](./DEPLOYMENT_GUIDE.md) - 배포 완전 가이드
 - [SERVER_SETUP.sh](./SERVER_SETUP.sh) - 서버 자동 설치 스크립트
 

ROADMAP_WBS.md

@@ -425,9 +425,9 @@ Todo:
 - 텔레그램 전송 실패 시 로그만 남기고 앱 정상 운영 유지
 
 Todo:
-- [x] BackgroundService 또는 Hangfire 기반 스케줄러 추가
+- [ ] BackgroundService 또는 Hangfire 기반 스케줄러 추가
-- [x] 일간/주간 리포트 메시지 템플릿
+- [ ] 일간/주간 리포트 메시지 템플릿
-- [x] TelegramNotificationService에 리포트 메서드 추가
+- [ ] TelegramNotificationService에 리포트 메서드 추가
 
 ## WBS-CRM-07 고객 포털 (읽기 전용) — Phase 3
 
@@ -439,9 +439,9 @@ Todo:
 - 개인정보 열람 범위는 세무사가 허용한 항목만
 
 Todo:
-- [x] 고객 포털 설계 (인증 방식 결정 — WBS-CRM-08 선행)
+- [ ] 고객 포털 설계 (인증 방식 결정 — WBS-CRM-08 선행)
-- [x] 고객 전용 Razor Pages 추가
+- [ ] 고객 전용 Razor Pages 추가
-- [x] 세무사 허용 권한 설정 UI
+- [ ] 세무사 허용 권한 설정 UI
 
 ## WBS-CRM-08 고객 회원가입 · 소셜 로그인 — Phase 3
 
@@ -485,16 +485,16 @@ DB 스키마:
 - `GOOGLE_CLIENT_ID` / `GOOGLE_CLIENT_SECRET`
 
 Todo:
-- [x] WBS-CRM-07 고객 포털 기본 구조 완성 (선행)
+- [ ] WBS-CRM-07 고객 포털 기본 구조 완성 (선행)
-- [x] OAuth 앱 등록 (네이버·카카오·구글 개발자 콘솔)
+- [ ] OAuth 앱 등록 (네이버·카카오·구글 개발자 콘솔)
-- [x] V011__CreatePortalUsers.sql 마이그레이션 (실제 V016__CreatePortalUsers.sql로 대체됨)
+- [ ] V011__CreatePortalUsers.sql 마이그레이션
-- [x] PortalUser 엔티티 / IPortalUserRepository / PortalUserRepository
+- [ ] PortalUser 엔티티 / IPortalUserRepository / PortalUserRepository
-- [x] 네이버 OAuth Handler 구현
+- [ ] 네이버 OAuth Handler 구현
-- [x] 카카오·구글 패키지 추가 및 설정
+- [ ] 카카오·구글 패키지 추가 및 설정
-- [x] 기본 계정 회원가입 폼 (`/taxbaik/portal/register`)
+- [ ] 기본 계정 회원가입 폼 (`/taxbaik/portal/register`)
-- [x] 소셜 로그인 콜백 처리 → portal_users 자동 생성
+- [ ] 소셜 로그인 콜백 처리 → portal_users 자동 생성
-- [x] 신규 가입 시 clients 테이블 연결 또는 신규 생성
+- [ ] 신규 가입 시 clients 테이블 연결 또는 신규 생성
-- [x] 포털 로그인 페이지 (`/taxbaik/portal/login`) — 소셜 버튼 + 이메일 폼
+- [ ] 포털 로그인 페이지 (`/taxbaik/portal/login`) — 소셜 버튼 + 이메일 폼
 - [ ] Gitea Secrets에 OAuth 키 추가
 - [ ] 배포 후 소셜 로그인 3종 E2E 테스트
 
@@ -522,46 +522,3 @@ Todo:
 - WBS-UX-03/04 구현 완료
 - WBS-CRM-01/02/03/04/05 구현 완료 (배포 후 검증 필요)
 - WBS-CRM-06/07/08 (텔레그램·포털·소셜 로그인) Phase 3 미착수
-
----
-
-## ── 홈페이지 · 어드민 · 포털 프리미엄 UX/UI 개편 (2026-06-30) ──────────────────
-
-## WBS-UX-05 홈페이지 프리미엄 UI 및 마이크로 인터랙션
-
-목표: 홈페이지 디자인을 극도로 모던하고 신뢰성 있는 프리미엄 스타일로 전면 개편한다.
-
-성공 기준:
-- Hero 섹션에 유려한 배경 그라데이션 및 부드러운 CSS 애니메이션 효과 적용
-- 서비스 카드에 섀도우 및 보더 트랜지션, 골드/그린 그라데이션 호버 이펙트 추가
-- 신뢰도 스트립 카드에 입체감 및 돋보이는 레이아웃 설계
-- Noto Sans KR 외에 Outfit/Inter 등의 보조 영문 폰트 결합으로 타이포그래피 고급화
-
-Todo:
-- [x] `site.css` 내 Hero 섹션 그라데이션 및 CSS 애니메이션 보강
-- [x] 서비스 카드 및 신뢰도 스트립 컴포넌트 프리미엄 스타일로 개편
-- [x] 홈페이지 폰트 스택 확장 및 메인 레이아웃 적용
-
-## WBS-PORTAL-01 고객 포털 UI/UX 고도화 및 글래스모피즘
-
-목표: 고객 마이 포털 화면을 미려하고 현대적인 글래스모피즘 디자인으로 개편하여 이용 가치를 극대화한다.
-
-성공 기준:
-- 포털 메인 대시보드 카드를 Glassmorphism 스타일(blur, semi-transparent border)로 변경
-- 세무 신고 현황 테이블 및 상담 이력 타임라인 컴포넌트의 모던 디자인화
-
-Todo:
-- [x] `site.css` 내 포털 전용 모던 글래스모피즘 클래스군 추가
-- [x] `Portal/Index.cshtml` 레이아웃 및 컴포넌트 UI 고도화
-
-## WBS-MAINT-02 코드 품질 및 경고 결함 차단
-
-목표: 빌드 컴파일 타임 경고(Warnings)를 0으로 유지하여 미래 코드 결함을 방지한다.
-
-성공 기준:
-- `dotnet build` 수행 시 경고 0개 달성
-
-Todo:
-- [x] `CustomAuthenticationStateProvider.cs` Nullable 경고 수정
-- [x] `Dashboard.razor` 미사용 변수 제거 및 UI 연계 바인딩 처리
-

TaxBaik.Application.Tests/BlogServiceTests.cs

@@ -44,34 +44,15 @@ public class BlogServiceTests
         Assert.Equal("같은-제목-2", post.Slug);
     }
 
-    [Fact]
-    public async Task DeleteAsync_SoftDeletesPost_AndExcludesFromSlugLookup()
-    {
-        var repository = new FakeBlogPostRepository
-        {
-            Posts =
-            [
-                new BlogPost { Id = 1, Title = "삭제 대상", Content = "본문", Slug = "delete-me", IsPublished = true }
-            ]
-        };
-        var service = new BlogService(repository, new MemoryCache(new MemoryCacheOptions()));
-
-        await service.DeleteAsync(1);
-
-        Assert.NotNull(repository.Posts.Single().DeletedAt);
-        Assert.Null(await service.GetBySlugAsync("delete-me"));
-        Assert.Null(await service.GetByIdAsync(1));
-    }
-
     private sealed class FakeBlogPostRepository : IBlogPostRepository
     {
         public List<BlogPost> Posts { get; init; } = [];
 
         public Task<BlogPost?> GetByIdAsync(int id, CancellationToken cancellationToken = default) =>
-            Task.FromResult(Posts.FirstOrDefault(x => x.Id == id && x.DeletedAt == null));
+            Task.FromResult(Posts.FirstOrDefault(x => x.Id == id));
 
         public Task<BlogPost?> GetBySlugAsync(string slug, CancellationToken cancellationToken = default) =>
-            Task.FromResult(Posts.FirstOrDefault(x => x.Slug == slug && x.IsPublished && x.DeletedAt == null));
+            Task.FromResult(Posts.FirstOrDefault(x => x.Slug == slug && x.IsPublished));
 
         public Task<(IEnumerable<BlogPost> Items, int Total)> GetPublishedPagedAsync(
             int page, int pageSize, int? categoryId = null, CancellationToken cancellationToken = default)
@@ -102,15 +83,7 @@ public class BlogServiceTests
 
         public Task UpdateAsync(BlogPost post, CancellationToken cancellationToken = default) => Task.CompletedTask;
 
-        public Task DeleteAsync(int id, CancellationToken cancellationToken = default)
+        public Task DeleteAsync(int id, CancellationToken cancellationToken = default) => Task.CompletedTask;
-        {
-            var post = Posts.FirstOrDefault(x => x.Id == id);
-            if (post != null)
-                post.DeletedAt = DateTime.UtcNow;
-            return Task.CompletedTask;
-        }
-
-        public Task ArchiveAsync(int id, CancellationToken cancellationToken = default) => DeleteAsync(id, cancellationToken);
 
         public Task IncrementViewCountAsync(int id, CancellationToken cancellationToken = default) => Task.CompletedTask;
     }

TaxBaik.Application.Tests/BusinessDayCalculatorTests.cs

@@ -1,35 +0,0 @@
-namespace TaxBaik.Application.Tests;
-
-using TaxBaik.Web.Components.Admin.Shared;
-using Xunit;
-
-public class BusinessDayCalculatorTests
-{
-    [Theory]
-    [InlineData(2026, 2, 14, 2026, 2, 19)]
-    [InlineData(2026, 8, 15, 2026, 8, 18)]
-    [InlineData(2026, 9, 24, 2026, 9, 28)]
-    [InlineData(2026, 10, 3, 2026, 10, 6)]
-    [InlineData(2027, 2, 6, 2027, 2, 10)]
-    public void GetEffectiveDueDate_SkipsWeekendHolidayAndSubstituteHoliday(
-        int dueYear, int dueMonth, int dueDay,
-        int expectedYear, int expectedMonth, int expectedDay)
-    {
-        var effective = BusinessDayCalculator.GetEffectiveDueDate(new DateOnly(dueYear, dueMonth, dueDay));
-
-        Assert.Equal(new DateOnly(expectedYear, expectedMonth, expectedDay), effective);
-    }
-
-    [Theory]
-    [InlineData(2026, 2, 19, 0)]
-    [InlineData(2026, 2, 20, -1)]
-    [InlineData(2026, 2, 18, 1)]
-    public void GetDday_UsesEffectiveDueDate(
-        int refYear, int refMonth, int refDay,
-        int expectedDays)
-    {
-        var dday = BusinessDayCalculator.GetDday(new DateOnly(2026, 2, 14), new DateOnly(refYear, refMonth, refDay));
-
-        Assert.Equal(expectedDays, dday);
-    }
-}

TaxBaik.Application.Tests/CommonCodeServiceTests.cs

@@ -1,76 +0,0 @@
-namespace TaxBaik.Application.Tests;
-
-using TaxBaik.Application.Services;
-using TaxBaik.Domain.Entities;
-using TaxBaik.Domain.Interfaces;
-using Xunit;
-
-public class CommonCodeServiceTests
-{
-    [Fact]
-    public async Task UpsertAsync_TrimsAndRejectsWhitespaceInCodeValue()
-    {
-        var repository = new FakeCommonCodeRepository();
-        var service = new CommonCodeService(repository);
-
-        await Assert.ThrowsAsync<ValidationException>(() => service.UpsertAsync(new CommonCode
-        {
-            CodeGroup = " CLIENT_STATUS ",
-            CodeValue = "active code",
-            CodeName = " 활성 "
-        }));
-    }
-
-    [Fact]
-    public async Task UpsertAsync_TrimsAndPersistsNormalizedValues()
-    {
-        var repository = new FakeCommonCodeRepository();
-        var service = new CommonCodeService(repository);
-
-        await service.UpsertAsync(new CommonCode
-        {
-            CodeGroup = " CLIENT_STATUS ",
-            CodeValue = "active",
-            CodeName = " 활성 ",
-            SortOrder = 10
-        });
-
-        var saved = Assert.Single(repository.SavedCodes);
-        Assert.Equal("CLIENT_STATUS", saved.CodeGroup);
-        Assert.Equal("active", saved.CodeValue);
-        Assert.Equal("활성", saved.CodeName);
-    }
-
-    private sealed class FakeCommonCodeRepository : ICommonCodeRepository
-    {
-        public List<CommonCode> SavedCodes { get; } = [];
-
-        public Task<IEnumerable<string>> GetAllGroupsAsync(CancellationToken ct = default) =>
-            Task.FromResult<IEnumerable<string>>([]);
-
-        public Task<IEnumerable<CommonCode>> GetByGroupAsync(string codeGroup, CancellationToken ct = default) =>
-            Task.FromResult<IEnumerable<CommonCode>>([]);
-
-        public Task<IEnumerable<CommonCode>> GetAllActiveAsync(CancellationToken ct = default) =>
-            Task.FromResult<IEnumerable<CommonCode>>([]);
-
-        public Task<CommonCode?> GetAsync(string codeGroup, string codeValue, CancellationToken ct = default) =>
-            Task.FromResult<CommonCode?>(null);
-
-        public Task UpsertAsync(CommonCode code, CancellationToken ct = default)
-        {
-            SavedCodes.Add(new CommonCode
-            {
-                CodeGroup = code.CodeGroup,
-                CodeValue = code.CodeValue,
-                CodeName = code.CodeName,
-                SortOrder = code.SortOrder,
-                IsActive = code.IsActive
-            });
-            return Task.CompletedTask;
-        }
-
-        public Task DeleteAsync(string codeGroup, string codeValue, CancellationToken ct = default) =>
-            Task.CompletedTask;
-    }
-}

TaxBaik.Application.Tests/InquiryServiceTests.cs

@@ -80,22 +80,6 @@ public class InquiryServiceTests
             return Task.CompletedTask;
         }
 
-        public Task UpdateAsync(Inquiry inquiry, CancellationToken cancellationToken = default)
-        {
-            var existing = Inquiries.FirstOrDefault(x => x.Id == inquiry.Id);
-            if (existing != null)
-            {
-                existing.Name = inquiry.Name;
-                existing.Phone = inquiry.Phone;
-                existing.Email = inquiry.Email;
-                existing.ServiceType = inquiry.ServiceType;
-                existing.Message = inquiry.Message;
-                existing.Status = inquiry.Status;
-                existing.AdminMemo = inquiry.AdminMemo;
-            }
-            return Task.CompletedTask;
-        }
-
         public Task LinkClientAsync(int inquiryId, int clientId, CancellationToken cancellationToken = default)
         {
             var inquiry = Inquiries.FirstOrDefault(x => x.Id == inquiryId);

TaxBaik.Application.Tests/TaxBaik.Application.Tests.csproj

@@ -18,6 +18,5 @@
 
   <ItemGroup>
     <ProjectReference Include="..\TaxBaik.Application\TaxBaik.Application.csproj" />
-    <ProjectReference Include="..\TaxBaik.Web\TaxBaik.Web.csproj" />
   </ItemGroup>
 </Project>

TaxBaik.Application/DTOs/CreateBlogPostDto.cs

@@ -12,21 +12,3 @@ public class CreateBlogPostDto
     public bool IsPublished { get; set; }
     public int? AuthorId { get; set; }
 }
-
-public class BlogPostResponseDto
-{
-    public int Id { get; set; }
-    public string Title { get; set; } = string.Empty;
-    public string Content { get; set; } = string.Empty;
-    public int? CategoryId { get; set; }
-    public string? Tags { get; set; }
-    public string? SeoTitle { get; set; }
-    public string? SeoDescription { get; set; }
-    public string? ThumbnailUrl { get; set; }
-    public bool IsPublished { get; set; }
-    public int? AuthorId { get; set; }
-    public int ViewCount { get; set; }
-    public string Slug { get; set; } = string.Empty;
-    public DateTime CreatedAt { get; set; }
-    public DateTime? PublishedAt { get; set; }
-}

TaxBaik.Application/DTOs/SubmitInquiryDto.cs

@@ -1,11 +0,0 @@
-namespace TaxBaik.Application.DTOs;
-
-public class SubmitInquiryDto
-{
-    public string Name { get; set; } = string.Empty;
-    public string Phone { get; set; } = string.Empty;
-    public string? Email { get; set; }
-    public string ServiceType { get; set; } = string.Empty;
-    public string Message { get; set; } = string.Empty;
-    public bool SuppressNotification { get; set; }
-}

TaxBaik.Application/DTOs/UpdateInquiryDto.cs

@@ -1,12 +0,0 @@
-namespace TaxBaik.Application.DTOs;
-
-public class UpdateInquiryDto
-{
-    public string Name { get; set; } = string.Empty;
-    public string Phone { get; set; } = string.Empty;
-    public string? Email { get; set; }
-    public string ServiceType { get; set; } = string.Empty;
-    public string Message { get; set; } = string.Empty;
-    public string Status { get; set; } = string.Empty;
-    public string? AdminMemo { get; set; }
-}

TaxBaik.Application/DependencyInjection.cs

@@ -27,7 +27,6 @@ public static class DependencyInjection
         services.AddScoped<RevenueTrackingService>();
         services.AddScoped<TelegramReportService>();
         services.AddScoped<PortalUserService>();
-        services.AddScoped<CommonCodeService>();
         return services;
     }
 }

TaxBaik.Application/Services/BlogService.cs

@@ -110,12 +110,6 @@ public class BlogService(IBlogPostRepository repository, IMemoryCache memoryCach
         memoryCache.Remove(AdminDashboardService.CacheKey);
     }
 
-    public async Task ArchiveAsync(int id, CancellationToken ct = default)
-    {
-        await repository.ArchiveAsync(id, ct);
-        memoryCache.Remove(AdminDashboardService.CacheKey);
-    }
-
     public async Task IncrementViewCountAsync(int id, CancellationToken ct = default) =>
         await repository.IncrementViewCountAsync(id, ct);
 

TaxBaik.Application/Services/ClientService.cs

@@ -6,6 +6,15 @@ using TaxBaik.Domain.Interfaces;
 
 public class ClientService(IClientRepository repository)
 {
+    public static readonly string[] ServiceTypes =
+        ["기장", "부동산", "증여·상속", "종합소득세", "법인세", "부가가치세", "기타"];
+
+    public static readonly string[] TaxTypes =
+        ["개인사업자", "법인사업자", "면세사업자", "근로소득자", "기타"];
+
+    public static readonly string[] Sources =
+        ["홈페이지 문의", "소개", "직접 방문", "카카오 채널", "블로그", "기타"];
+
     public async Task<(IEnumerable<Client> Items, int Total)> GetPagedAsync(
         int page, int pageSize, string? status = null, string? search = null, CancellationToken ct = default) =>
         await repository.GetPagedAsync(Math.Max(1, page), Math.Clamp(pageSize, 1, 100), status, search, ct);
@@ -72,7 +81,7 @@ public class ClientService(IClientRepository repository)
             Phone = phone?.Trim(),
             ServiceType = serviceType,
             Status = "active",
-            Source = "홈페이지문의"
+            Source = "홈페이지 문의"
         };
         return await repository.CreateAsync(client, ct);
     }

TaxBaik.Application/Services/CommonCodeService.cs

@@ -1,67 +0,0 @@
-using System.Collections.Generic;
-using System.Threading;
-using System.Threading.Tasks;
-using TaxBaik.Domain.Entities;
-using TaxBaik.Domain.Interfaces;
-
-namespace TaxBaik.Application.Services;
-
-public class CommonCodeService(ICommonCodeRepository commonCodeRepository)
-{
-    private const int MaxCodeGroupLength = 80;
-    private const int MaxCodeValueLength = 120;
-    private const int MaxCodeNameLength = 200;
-
-    public async Task<IEnumerable<string>> GetAllGroupsAsync(CancellationToken ct = default)
-    {
-        return await commonCodeRepository.GetAllGroupsAsync(ct);
-    }
-
-    public async Task<IEnumerable<CommonCode>> GetByGroupAsync(string codeGroup, CancellationToken ct = default)
-    {
-        return await commonCodeRepository.GetByGroupAsync(codeGroup, ct);
-    }
-
-    public async Task<IEnumerable<CommonCode>> GetAllActiveAsync(CancellationToken ct = default)
-    {
-        return await commonCodeRepository.GetAllActiveAsync(ct);
-    }
-
-    public async Task<CommonCode?> GetAsync(string codeGroup, string codeValue, CancellationToken ct = default)
-    {
-        return await commonCodeRepository.GetAsync(codeGroup, codeValue, ct);
-    }
-
-    public async Task UpsertAsync(CommonCode code, CancellationToken ct = default)
-    {
-        Normalize(code);
-        await commonCodeRepository.UpsertAsync(code, ct);
-    }
-
-    public async Task DeleteAsync(string codeGroup, string codeValue, CancellationToken ct = default)
-    {
-        await commonCodeRepository.DeleteAsync(NormalizeToken(codeGroup, nameof(codeGroup), MaxCodeGroupLength), NormalizeToken(codeValue, nameof(codeValue), MaxCodeValueLength), ct);
-    }
-
-    private static void Normalize(CommonCode code)
-    {
-        code.CodeGroup = NormalizeToken(code.CodeGroup, nameof(code.CodeGroup), MaxCodeGroupLength);
-        code.CodeValue = NormalizeToken(code.CodeValue, nameof(code.CodeValue), MaxCodeValueLength, disallowWhitespace: true);
-        code.CodeName = NormalizeToken(code.CodeName, nameof(code.CodeName), MaxCodeNameLength);
-    }
-
-    private static string NormalizeToken(string value, string fieldName, int maxLength, bool disallowWhitespace = false)
-    {
-        var normalized = (value ?? string.Empty).Trim();
-        if (string.IsNullOrWhiteSpace(normalized))
-            throw new ValidationException($"{fieldName}은(는) 필수입니다.");
-
-        if (normalized.Length > maxLength)
-            throw new ValidationException($"{fieldName}은(는) 최대 {maxLength}자까지 입력할 수 있습니다.");
-
-        if (disallowWhitespace && normalized.Any(char.IsWhiteSpace))
-            throw new ValidationException($"{fieldName}에는 공백을 사용할 수 없습니다.");
-
-        return normalized;
-    }
-}

TaxBaik.Application/Services/ConsultingActivityService.cs

@@ -33,9 +33,6 @@ public class ConsultingActivityService(IConsultingActivityRepository repository)
     public async Task<IEnumerable<ConsultingActivity>> GetByClientIdAsync(int clientId, CancellationToken ct = default) =>
         await repository.GetByClientIdAsync(clientId, ct);
 
-    public async Task<IEnumerable<ConsultingActivity>> GetAllAsync(CancellationToken ct = default) =>
-        await repository.GetAllAsync(ct);
-
     public async Task<IEnumerable<ConsultingActivity>> GetPendingFollowupsAsync(CancellationToken ct = default) =>
         await repository.GetPendingFollowupsAsync(ct);
 

TaxBaik.Application/Services/ContractService.cs

@@ -36,9 +36,6 @@ public class ContractService(IContractRepository repository)
     public async Task<Contract?> GetByIdAsync(int id, CancellationToken ct = default) =>
         await repository.GetByIdAsync(id, ct);
 
-    public async Task<IEnumerable<Contract>> GetAllAsync(CancellationToken ct = default) =>
-        await repository.GetAllAsync(ct);
-
     public async Task<IEnumerable<Contract>> GetByClientIdAsync(int clientId, CancellationToken ct = default) =>
         await repository.GetByClientIdAsync(clientId, ct);
 

TaxBaik.Application/Services/FaqService.cs

@@ -6,7 +6,7 @@ using TaxBaik.Domain.Interfaces;
 public class FaqService(IFaqRepository repository)
 {
     public static readonly string[] Categories =
-        ["기장세금신고", "부동산", "증여상속", "기타"];
+        ["기장·세금신고", "부동산", "증여·상속", "기타"];
 
     public async Task<IEnumerable<Faq>> GetActiveAsync(CancellationToken ct = default) =>
         await repository.GetActiveAsync(ct);

TaxBaik.Application/Services/InquiryService.cs

@@ -2,7 +2,6 @@ namespace TaxBaik.Application.Services;
 
 using System.Text.RegularExpressions;
 using Microsoft.Extensions.Caching.Memory;
-using TaxBaik.Application.DTOs;
 using TaxBaik.Domain.Entities;
 using TaxBaik.Domain.Enums;
 using TaxBaik.Domain.Interfaces;
@@ -73,37 +72,6 @@ public class InquiryService(
     public async Task UpdateAdminMemoAsync(int id, string? adminMemo, CancellationToken ct = default) =>
         await repository.UpdateAdminMemoAsync(id, adminMemo, ct);
 
-    public async Task<Inquiry?> UpdateAsync(int id, UpdateInquiryDto dto, CancellationToken ct = default)
-    {
-        var inquiry = await repository.GetByIdAsync(id, ct);
-        if (inquiry == null)
-            return null;
-
-        if (string.IsNullOrWhiteSpace(dto.Name))
-            throw new ValidationException("이름을 입력하세요.");
-
-        if (!PhoneRegex.IsMatch(dto.Phone))
-            throw new ValidationException("올바른 전화번호를 입력하세요. (예: 010-1234-5678)");
-
-        if (string.IsNullOrWhiteSpace(dto.Message))
-            throw new ValidationException("문의 내용을 입력하세요.");
-
-        if (!InquiryStatusMapper.TryParse(dto.Status, out var parsedStatus))
-            throw new ValidationException("지원하지 않는 문의 상태입니다.");
-
-        inquiry.Name = dto.Name.Trim();
-        inquiry.Phone = dto.Phone.Trim();
-        inquiry.Email = string.IsNullOrWhiteSpace(dto.Email) ? null : dto.Email.Trim();
-        inquiry.ServiceType = string.IsNullOrWhiteSpace(dto.ServiceType) ? "기타" : dto.ServiceType.Trim();
-        inquiry.Message = dto.Message.Trim();
-        inquiry.Status = InquiryStatusMapper.ToStorageValue(parsedStatus);
-        inquiry.AdminMemo = dto.AdminMemo;
-
-        await repository.UpdateAsync(inquiry, ct);
-        memoryCache.Remove(AdminDashboardService.CacheKey);
-        return inquiry;
-    }
-
     public async Task LinkClientAsync(int inquiryId, int clientId, CancellationToken ct = default) =>
         await repository.LinkClientAsync(inquiryId, clientId, ct);
 

TaxBaik.Application/Services/RevenueTrackingService.cs

@@ -34,9 +34,6 @@ public class RevenueTrackingService(IRevenueTrackingRepository repository)
     public async Task<IEnumerable<RevenueTracking>> GetByClientIdAsync(int clientId, CancellationToken ct = default) =>
         await repository.GetByClientIdAsync(clientId, ct);
 
-    public async Task<IEnumerable<RevenueTracking>> GetAllAsync(CancellationToken ct = default) =>
-        await repository.GetAllAsync(ct);
-
     public async Task<IEnumerable<RevenueTracking>> GetPendingPaymentsAsync(CancellationToken ct = default) =>
         await repository.GetPendingPaymentsAsync(ct);
 

TaxBaik.Application/Services/TaxFilingScheduleService.cs

@@ -33,9 +33,6 @@ public class TaxFilingScheduleService(ITaxFilingScheduleRepository repository)
     public async Task<TaxFilingSchedule?> GetByIdAsync(int id, CancellationToken ct = default) =>
         await repository.GetByIdAsync(id, ct);
 
-    public async Task<IEnumerable<TaxFilingSchedule>> GetAllAsync(CancellationToken ct = default) =>
-        await repository.GetAllAsync(ct);
-
     public async Task<IEnumerable<TaxFilingSchedule>> GetByClientIdAsync(int clientId, CancellationToken ct = default) =>
         await repository.GetByClientIdAsync(clientId, ct);
 

TaxBaik.Application/Services/TaxFilingService.cs

@@ -5,6 +5,9 @@ using TaxBaik.Domain.Interfaces;
 
 public class TaxFilingService(ITaxFilingRepository repository)
 {
+    public static readonly string[] FilingTypes =
+        ["부가가치세", "종합소득세", "법인세", "원천징수", "종합부동산세", "증여세", "상속세", "기타"];
+
     public static readonly string[] Statuses =
         ["pending", "filed", "overdue"];
 

TaxBaik.Application/Services/TaxProfileService.cs

@@ -31,16 +31,10 @@ public class TaxProfileService(ITaxProfileRepository repository)
     public async Task<TaxProfile?> GetByClientIdAsync(int clientId, CancellationToken ct = default) =>
         await repository.GetByClientIdAsync(clientId, ct);
 
-    public async Task<IEnumerable<TaxProfile>> GetAllAsync(CancellationToken ct = default) =>
-        await repository.GetAllAsync(ct);
-
     public async Task UpdateAsync(int profileId, string? businessType, string? accountingMethod,
         DateTime? nextFilingDueDate, string taxRiskLevel = "normal", CancellationToken ct = default)
     {
-        var profile = await repository.GetByIdAsync(profileId, ct);
+        var profile = new TaxProfile { Id = profileId };
-        if (profile == null)
-            throw new ValidationException("세무 프로필을 찾을 수 없습니다.");
-
         if (!string.IsNullOrWhiteSpace(businessType))
             profile.BusinessType = businessType.Trim();
         if (!string.IsNullOrWhiteSpace(accountingMethod))

TaxBaik.Domain/Entities/BlogPost.cs

@@ -17,7 +17,6 @@ public class BlogPost
     public bool IsPublished { get; set; }
     public DateTime CreatedAt { get; set; }
     public DateTime UpdatedAt { get; set; }
-    public DateTime? DeletedAt { get; set; }
 
     // Navigation property (populated via LEFT JOIN, not stored in DB)
     public string? CategoryName { get; set; }

TaxBaik.Domain/Entities/CommonCode.cs

@@ -1,10 +0,0 @@
-namespace TaxBaik.Domain.Entities;
-
-public class CommonCode
-{
-    public string CodeGroup { get; set; } = string.Empty;
-    public string CodeValue { get; set; } = string.Empty;
-    public string CodeName { get; set; } = string.Empty;
-    public int SortOrder { get; set; }
-    public bool IsActive { get; set; } = true;
-}

TaxBaik.Domain/Interfaces/IBlogPostRepository.cs

@@ -15,6 +15,5 @@ public interface IBlogPostRepository
     Task<int> CreateAsync(BlogPost post, CancellationToken cancellationToken = default);
     Task UpdateAsync(BlogPost post, CancellationToken cancellationToken = default);
     Task DeleteAsync(int id, CancellationToken cancellationToken = default);
-    Task ArchiveAsync(int id, CancellationToken cancellationToken = default);
     Task IncrementViewCountAsync(int id, CancellationToken cancellationToken = default);
 }

TaxBaik.Domain/Interfaces/ICommonCodeRepository.cs

@@ -1,16 +0,0 @@
-using System.Collections.Generic;
-using System.Threading;
-using System.Threading.Tasks;
-using TaxBaik.Domain.Entities;
-
-namespace TaxBaik.Domain.Interfaces;
-
-public interface ICommonCodeRepository
-{
-    Task<IEnumerable<string>> GetAllGroupsAsync(CancellationToken ct = default);
-    Task<IEnumerable<CommonCode>> GetByGroupAsync(string codeGroup, CancellationToken ct = default);
-    Task<IEnumerable<CommonCode>> GetAllActiveAsync(CancellationToken ct = default);
-    Task<CommonCode?> GetAsync(string codeGroup, string codeValue, CancellationToken ct = default);
-    Task UpsertAsync(CommonCode code, CancellationToken ct = default);
-    Task DeleteAsync(string codeGroup, string codeValue, CancellationToken ct = default);
-}

TaxBaik.Domain/Interfaces/IConsultingActivityRepository.cs

@@ -5,7 +5,6 @@ using TaxBaik.Domain.Entities;
 public interface IConsultingActivityRepository
 {
     Task<int> CreateAsync(ConsultingActivity activity, CancellationToken cancellationToken = default);
-    Task<IEnumerable<ConsultingActivity>> GetAllAsync(CancellationToken cancellationToken = default);
     Task<IEnumerable<ConsultingActivity>> GetByClientIdAsync(int clientId, CancellationToken cancellationToken = default);
     Task<IEnumerable<ConsultingActivity>> GetPendingFollowupsAsync(CancellationToken cancellationToken = default);
     Task<IEnumerable<ConsultingActivity>> GetByConsultantAsync(int consultantId, DateTime fromDate, CancellationToken cancellationToken = default);

TaxBaik.Domain/Interfaces/IContractRepository.cs

@@ -5,7 +5,6 @@ using TaxBaik.Domain.Entities;
 public interface IContractRepository
 {
     Task<int> CreateAsync(Contract contract, CancellationToken cancellationToken = default);
-    Task<IEnumerable<Contract>> GetAllAsync(CancellationToken cancellationToken = default);
     Task<Contract?> GetByIdAsync(int id, CancellationToken cancellationToken = default);
     Task<IEnumerable<Contract>> GetByClientIdAsync(int clientId, CancellationToken cancellationToken = default);
     Task<IEnumerable<Contract>> GetActiveContractsAsync(CancellationToken cancellationToken = default);

TaxBaik.Domain/Interfaces/IInquiryRepository.cs

@@ -15,7 +15,6 @@ public interface IInquiryRepository
     Task<int> CountByStatusAndDateAsync(string status, DateTime startDate, DateTime endDate, CancellationToken cancellationToken = default);
     Task UpdateStatusAsync(int id, string status, CancellationToken cancellationToken = default);
     Task UpdateAdminMemoAsync(int id, string? adminMemo, CancellationToken cancellationToken = default);
-    Task UpdateAsync(Inquiry inquiry, CancellationToken cancellationToken = default);
     Task LinkClientAsync(int inquiryId, int clientId, CancellationToken cancellationToken = default);
     Task DeleteAsync(int id, CancellationToken cancellationToken = default);
 }

TaxBaik.Domain/Interfaces/IRevenueTrackingRepository.cs

@@ -5,7 +5,6 @@ using TaxBaik.Domain.Entities;
 public interface IRevenueTrackingRepository
 {
     Task<int> CreateAsync(RevenueTracking revenue, CancellationToken cancellationToken = default);
-    Task<IEnumerable<RevenueTracking>> GetAllAsync(CancellationToken cancellationToken = default);
     Task<IEnumerable<RevenueTracking>> GetByClientIdAsync(int clientId, CancellationToken cancellationToken = default);
     Task<IEnumerable<RevenueTracking>> GetPendingPaymentsAsync(CancellationToken cancellationToken = default);
     Task<IEnumerable<RevenueTracking>> GetByDateRangeAsync(DateTime startDate, DateTime endDate, CancellationToken cancellationToken = default);

TaxBaik.Domain/Interfaces/ITaxFilingScheduleRepository.cs

@@ -5,7 +5,6 @@ using TaxBaik.Domain.Entities;
 public interface ITaxFilingScheduleRepository
 {
     Task<int> CreateAsync(TaxFilingSchedule schedule, CancellationToken cancellationToken = default);
-    Task<IEnumerable<TaxFilingSchedule>> GetAllAsync(CancellationToken cancellationToken = default);
     Task<TaxFilingSchedule?> GetByIdAsync(int id, CancellationToken cancellationToken = default);
     Task<IEnumerable<TaxFilingSchedule>> GetByClientIdAsync(int clientId, CancellationToken cancellationToken = default);
     Task<IEnumerable<TaxFilingSchedule>> GetUpcomingDuesAsync(int daysAhead = 30, CancellationToken cancellationToken = default);

TaxBaik.Domain/Interfaces/ITaxProfileRepository.cs

@@ -5,8 +5,6 @@ using TaxBaik.Domain.Entities;
 public interface ITaxProfileRepository
 {
     Task<int> CreateAsync(TaxProfile profile, CancellationToken cancellationToken = default);
-    Task<TaxProfile?> GetByIdAsync(int id, CancellationToken cancellationToken = default);
-    Task<IEnumerable<TaxProfile>> GetAllAsync(CancellationToken cancellationToken = default);
     Task<TaxProfile?> GetByClientIdAsync(int clientId, CancellationToken cancellationToken = default);
     Task UpdateAsync(TaxProfile profile, CancellationToken cancellationToken = default);
     Task<IEnumerable<TaxProfile>> GetByRiskLevelAsync(string riskLevel, CancellationToken cancellationToken = default);

TaxBaik.Infrastructure/DependencyInjection.cs

@@ -27,7 +27,6 @@ public static class DependencyInjection
         services.AddScoped<IConsultingActivityRepository, ConsultingActivityRepository>();
         services.AddScoped<IContractRepository, ContractRepository>();
         services.AddScoped<IRevenueTrackingRepository, RevenueTrackingRepository>();
-        services.AddScoped<ICommonCodeRepository, CommonCodeRepository>();
 
         return services;
     }

TaxBaik.Infrastructure/Repositories/BlogPostRepository.cs

@@ -15,7 +15,7 @@ public class BlogPostRepository(IDbConnectionFactory connectionFactory) : BaseRe
                      bp.is_published, bp.created_at, bp.updated_at, c.name AS category_name
               FROM blog_posts bp
               LEFT JOIN categories c ON bp.category_id = c.id
-              WHERE bp.id = @Id AND bp.deleted_at IS NULL",
+              WHERE bp.id = @Id",
             new { Id = id });
     }
 
@@ -28,7 +28,7 @@ public class BlogPostRepository(IDbConnectionFactory connectionFactory) : BaseRe
                      bp.is_published, bp.created_at, bp.updated_at, c.name AS category_name
               FROM blog_posts bp
               LEFT JOIN categories c ON bp.category_id = c.id
-              WHERE bp.slug = @Slug AND bp.is_published = TRUE AND bp.deleted_at IS NULL",
+              WHERE bp.slug = @Slug AND bp.is_published = TRUE",
             new { Slug = slug });
     }
 
@@ -44,12 +44,12 @@ public class BlogPostRepository(IDbConnectionFactory connectionFactory) : BaseRe
                      bp.is_published, bp.created_at, bp.updated_at, c.name AS category_name
               FROM blog_posts bp
               LEFT JOIN categories c ON bp.category_id = c.id
-              WHERE bp.is_published = TRUE AND bp.deleted_at IS NULL AND (@CategoryId::int IS NULL OR bp.category_id = @CategoryId)
+              WHERE bp.is_published = TRUE AND (@CategoryId::int IS NULL OR bp.category_id = @CategoryId)
               ORDER BY bp.published_at DESC
               LIMIT @PageSize OFFSET @Offset;
 
               SELECT COUNT(*) FROM blog_posts
-              WHERE is_published = TRUE AND deleted_at IS NULL AND (@CategoryId::int IS NULL OR category_id = @CategoryId);",
+              WHERE is_published = TRUE AND (@CategoryId::int IS NULL OR category_id = @CategoryId);",
             new { CategoryId = categoryId, PageSize = pageSize, Offset = offset });
 
         var items = (await reader.ReadAsync<BlogPost>()).ToList();
@@ -67,7 +67,7 @@ public class BlogPostRepository(IDbConnectionFactory connectionFactory) : BaseRe
                      bp.is_published, bp.created_at, bp.updated_at, c.name AS category_name
               FROM blog_posts bp
               LEFT JOIN categories c ON bp.category_id = c.id
-              WHERE bp.is_published = TRUE AND bp.deleted_at IS NULL AND c.slug = @CategorySlug
+              WHERE bp.is_published = TRUE AND c.slug = @CategorySlug
               ORDER BY bp.published_at DESC
               LIMIT @Limit",
             new { CategorySlug = categorySlug, Limit = limit });
@@ -82,7 +82,6 @@ public class BlogPostRepository(IDbConnectionFactory connectionFactory) : BaseRe
                      bp.is_published, bp.created_at, bp.updated_at, c.name AS category_name
               FROM blog_posts bp
               LEFT JOIN categories c ON bp.category_id = c.id
-              WHERE bp.deleted_at IS NULL
               ORDER BY bp.created_at DESC");
     }
 
@@ -98,11 +97,10 @@ public class BlogPostRepository(IDbConnectionFactory connectionFactory) : BaseRe
                      bp.is_published, bp.created_at, bp.updated_at, c.name AS category_name
               FROM blog_posts bp
               LEFT JOIN categories c ON bp.category_id = c.id
-              WHERE bp.deleted_at IS NULL
               ORDER BY bp.created_at DESC
               LIMIT @PageSize OFFSET @Offset;
 
-              SELECT COUNT(*) FROM blog_posts WHERE deleted_at IS NULL;",
+              SELECT COUNT(*) FROM blog_posts;",
             new { PageSize = pageSize, Offset = offset });
 
         var items = (await reader.ReadAsync<BlogPost>()).ToList();
@@ -132,26 +130,19 @@ public class BlogPostRepository(IDbConnectionFactory connectionFactory) : BaseRe
                   tags = @Tags, author_id = @AuthorId, published_at = @PublishedAt,
                   seo_title = @SeoTitle, seo_description = @SeoDescription,
                   thumbnail_url = @ThumbnailUrl, is_published = @IsPublished, updated_at = NOW()
-              WHERE id = @Id AND deleted_at IS NULL",
+              WHERE id = @Id",
             post);
     }
 
     public async Task DeleteAsync(int id, CancellationToken cancellationToken = default)
-    {
-        await ArchiveAsync(id, cancellationToken);
-    }
-
-    public async Task ArchiveAsync(int id, CancellationToken cancellationToken = default)
     {
         using var conn = Conn();
-        await conn.ExecuteAsync(
+        await conn.ExecuteAsync("DELETE FROM blog_posts WHERE id = @Id", new { Id = id });
-            "UPDATE blog_posts SET deleted_at = NOW(), updated_at = NOW() WHERE id = @Id AND deleted_at IS NULL",
-            new { Id = id });
     }
 
     public async Task IncrementViewCountAsync(int id, CancellationToken cancellationToken = default)
     {
         using var conn = Conn();
-        await conn.ExecuteAsync("UPDATE blog_posts SET view_count = view_count + 1 WHERE id = @Id AND deleted_at IS NULL", new { Id = id });
+        await conn.ExecuteAsync("UPDATE blog_posts SET view_count = view_count + 1 WHERE id = @Id", new { Id = id });
     }
 }

TaxBaik.Infrastructure/Repositories/CommonCodeRepository.cs

@@ -1,72 +0,0 @@
-using System.Collections.Generic;
-using System.Data;
-using System.Threading;
-using System.Threading.Tasks;
-using Dapper;
-using TaxBaik.Domain.Entities;
-using TaxBaik.Domain.Interfaces;
-
-namespace TaxBaik.Infrastructure.Repositories;
-
-public class CommonCodeRepository(IDbConnectionFactory connectionFactory) : BaseRepository(connectionFactory), ICommonCodeRepository
-{
-    public async Task<IEnumerable<string>> GetAllGroupsAsync(CancellationToken ct = default)
-    {
-        using var conn = Conn();
-        return await conn.QueryAsync<string>(
-            "SELECT DISTINCT code_group FROM common_codes WHERE is_active = TRUE ORDER BY code_group");
-    }
-
-    public async Task<IEnumerable<CommonCode>> GetByGroupAsync(string codeGroup, CancellationToken ct = default)
-    {
-        using var conn = Conn();
-        return await conn.QueryAsync<CommonCode>(
-            @"SELECT code_group as CodeGroup, code_value as CodeValue, code_name as CodeName, sort_order as SortOrder, is_active as IsActive
-              FROM common_codes 
-              WHERE code_group = @CodeGroup AND is_active = TRUE 
-              ORDER BY sort_order",
-            new { CodeGroup = codeGroup });
-    }
-
-    public async Task<IEnumerable<CommonCode>> GetAllActiveAsync(CancellationToken ct = default)
-    {
-        using var conn = Conn();
-        return await conn.QueryAsync<CommonCode>(
-            @"SELECT code_group as CodeGroup, code_value as CodeValue, code_name as CodeName, sort_order as SortOrder, is_active as IsActive
-              FROM common_codes 
-              WHERE is_active = TRUE 
-              ORDER BY code_group, sort_order");
-    }
-
-    public async Task<CommonCode?> GetAsync(string codeGroup, string codeValue, CancellationToken ct = default)
-    {
-        using var conn = Conn();
-        return await conn.QuerySingleOrDefaultAsync<CommonCode>(
-            @"SELECT code_group as CodeGroup, code_value as CodeValue, code_name as CodeName, sort_order as SortOrder, is_active as IsActive
-              FROM common_codes
-              WHERE code_group = @CodeGroup AND code_value = @CodeValue",
-            new { CodeGroup = codeGroup, CodeValue = codeValue });
-    }
-
-    public async Task UpsertAsync(CommonCode code, CancellationToken ct = default)
-    {
-        using var conn = Conn();
-        await conn.ExecuteAsync(
-            @"INSERT INTO common_codes (code_group, code_value, code_name, sort_order, is_active)
-              VALUES (@CodeGroup, @CodeValue, @CodeName, @SortOrder, @IsActive)
-              ON CONFLICT (code_group, code_value) DO UPDATE
-              SET code_name = EXCLUDED.code_name,
-                  sort_order = EXCLUDED.sort_order,
-                  is_active = EXCLUDED.is_active",
-            code);
-    }
-
-    public async Task DeleteAsync(string codeGroup, string codeValue, CancellationToken ct = default)
-    {
-        using var conn = Conn();
-        await conn.ExecuteAsync(
-            @"DELETE FROM common_codes
-              WHERE code_group = @CodeGroup AND code_value = @CodeValue",
-            new { CodeGroup = codeGroup, CodeValue = codeValue });
-    }
-}

TaxBaik.Infrastructure/Repositories/ConsultingActivityRepository.cs

@@ -16,14 +16,6 @@ public class ConsultingActivityRepository(IDbConnectionFactory connectionFactory
             activity);
     }
 
-    public async Task<IEnumerable<ConsultingActivity>> GetAllAsync(CancellationToken cancellationToken = default)
-    {
-        using var conn = Conn();
-        return await conn.QueryAsync<ConsultingActivity>(
-            @"SELECT id, client_id, activity_type, activity_date, activity_time, assigned_consultant, description, outcome, next_followup_date, notes, created_at, updated_at
-              FROM consulting_activities ORDER BY activity_date DESC");
-    }
-
     public async Task<IEnumerable<ConsultingActivity>> GetByClientIdAsync(int clientId, CancellationToken cancellationToken = default)
     {
         using var conn = Conn();

TaxBaik.Infrastructure/Repositories/ContractRepository.cs

@@ -16,14 +16,6 @@ public class ContractRepository(IDbConnectionFactory connectionFactory) : BaseRe
             contract);
     }
 
-    public async Task<IEnumerable<Contract>> GetAllAsync(CancellationToken cancellationToken = default)
-    {
-        using var conn = Conn();
-        return await conn.QueryAsync<Contract>(
-            @"SELECT id, client_id, contract_number, service_type, contract_date, start_date, end_date, monthly_fee, total_amount, payment_status, status, notes, created_at, updated_at
-              FROM contracts ORDER BY contract_date DESC");
-    }
-
     public async Task<Contract?> GetByIdAsync(int id, CancellationToken cancellationToken = default)
     {
         using var conn = Conn();

TaxBaik.Infrastructure/Repositories/InquiryRepository.cs

@@ -112,23 +112,6 @@ public class InquiryRepository(IDbConnectionFactory connectionFactory) : BaseRep
             new { Id = id, AdminMemo = adminMemo });
     }
 
-    public async Task UpdateAsync(Inquiry inquiry, CancellationToken cancellationToken = default)
-    {
-        using var conn = Conn();
-        await conn.ExecuteAsync(
-            @"UPDATE inquiries
-              SET name = @Name,
-                  phone = @Phone,
-                  email = @Email,
-                  service_type = @ServiceType,
-                  message = @Message,
-                  status = @Status,
-                  admin_memo = @AdminMemo,
-                  updated_at = NOW()
-              WHERE id = @Id",
-            inquiry);
-    }
-
     public async Task LinkClientAsync(int inquiryId, int clientId, CancellationToken cancellationToken = default)
     {
         using var conn = Conn();

TaxBaik.Infrastructure/Repositories/RevenueTrackingRepository.cs

@@ -16,14 +16,6 @@ public class RevenueTrackingRepository(IDbConnectionFactory connectionFactory) :
             revenue);
     }
 
-    public async Task<IEnumerable<RevenueTracking>> GetAllAsync(CancellationToken cancellationToken = default)
-    {
-        using var conn = Conn();
-        return await conn.QueryAsync<RevenueTracking>(
-            @"SELECT id, client_id, invoice_number, invoice_date, service_type, amount, payment_status, payment_date, due_date, notes, created_at, updated_at
-              FROM revenue_tracking ORDER BY invoice_date DESC");
-    }
-
     public async Task<IEnumerable<RevenueTracking>> GetByClientIdAsync(int clientId, CancellationToken cancellationToken = default)
     {
         using var conn = Conn();

TaxBaik.Infrastructure/Repositories/TaxFilingScheduleRepository.cs

@@ -16,14 +16,6 @@ public class TaxFilingScheduleRepository(IDbConnectionFactory connectionFactory)
             schedule);
     }
 
-    public async Task<IEnumerable<TaxFilingSchedule>> GetAllAsync(CancellationToken cancellationToken = default)
-    {
-        using var conn = Conn();
-        return await conn.QueryAsync<TaxFilingSchedule>(
-            @"SELECT id, client_id, filing_type, due_date, filing_year, status, assigned_to, completed_date, notes, created_at, updated_at
-              FROM tax_filing_schedules ORDER BY due_date DESC");
-    }
-
     public async Task<TaxFilingSchedule?> GetByIdAsync(int id, CancellationToken cancellationToken = default)
     {
         using var conn = Conn();

TaxBaik.Infrastructure/Repositories/TaxProfileRepository.cs

@@ -20,27 +20,6 @@ public class TaxProfileRepository(IDbConnectionFactory connectionFactory) : Base
             profile);
     }
 
-    public async Task<TaxProfile?> GetByIdAsync(int id, CancellationToken cancellationToken = default)
-    {
-        using var conn = Conn();
-        return await conn.QueryFirstOrDefaultAsync<TaxProfile>(
-            @"SELECT id, client_id, business_registration, business_type, establishment_date,
-              annual_revenue_range, employee_count, accounting_method, fiscal_year_end, last_filing_date,
-              next_filing_due_date, tax_risk_level, previous_audit_history, special_notes, created_at, updated_at
-              FROM tax_profiles WHERE id = @Id",
-            new { Id = id });
-    }
-
-    public async Task<IEnumerable<TaxProfile>> GetAllAsync(CancellationToken cancellationToken = default)
-    {
-        using var conn = Conn();
-        return await conn.QueryAsync<TaxProfile>(
-            @"SELECT id, client_id, business_registration, business_type, establishment_date,
-              annual_revenue_range, employee_count, accounting_method, fiscal_year_end, last_filing_date,
-              next_filing_due_date, tax_risk_level, previous_audit_history, special_notes, created_at, updated_at
-              FROM tax_profiles ORDER BY id DESC");
-    }
-
     public async Task<TaxProfile?> GetByClientIdAsync(int clientId, CancellationToken cancellationToken = default)
     {
         using var conn = Conn();

TaxBaik.Proxy/Program.cs

@@ -1,93 +0,0 @@
-using System;
-using System.IO;
-using System.Net;
-using System.Net.Sockets;
-using System.Threading;
-using System.Threading.Tasks;
-
-class Program
-{
-    private const string PortFile = "/home/kjh2064/taxbaik_port";
-    private static int _fallbackPort = 5003;
-
-    static async Task Main(string[] args)
-    {
-        // Allow setting fallback port via args
-        if (args.Length > 0 && int.TryParse(args[0], out var port))
-        {
-            _fallbackPort = port;
-        }
-
-        var listener = new TcpListener(IPAddress.Loopback, 5001);
-        listener.Start();
-        Console.WriteLine($"[TaxBaik Proxy] Listening on 127.0.0.1:5001 (Forwarding to target in {PortFile})");
-
-        while (true)
-        {
-            try
-            {
-                var client = await listener.AcceptTcpClientAsync();
-                _ = HandleClientAsync(client);
-            }
-            catch (Exception ex)
-            {
-                Console.WriteLine($"[TaxBaik Proxy] Accept error: {ex.Message}");
-                await Task.Delay(100);
-            }
-        }
-    }
-
-    private static int GetTargetPort()
-    {
-        try
-        {
-            if (File.Exists(PortFile))
-            {
-                var content = File.ReadAllText(PortFile).Trim();
-                if (int.TryParse(content, out var port) && port > 1024 && port < 65535)
-                {
-                    return port;
-                }
-            }
-        }
-        catch { }
-        return _fallbackPort;
-    }
-
-    private static async Task HandleClientAsync(TcpClient client)
-    {
-        client.NoDelay = true;
-        int targetPort = GetTargetPort();
-        using var backend = new TcpClient();
-        backend.NoDelay = true;
-
-        try
-        {
-            using var cts = new CancellationTokenSource(TimeSpan.FromSeconds(5));
-            await backend.ConnectAsync(IPAddress.Loopback, targetPort, cts.Token);
-        }
-        catch (Exception ex)
-        {
-            Console.WriteLine($"[TaxBaik Proxy] Failed to connect to backend on port {targetPort}: {ex.Message}");
-            client.Close();
-            return;
-        }
-
-        try
-        {
-            using var clientStream = client.GetStream();
-            using var backendStream = backend.GetStream();
-
-            var toBackend = clientStream.CopyToAsync(backendStream);
-            var toClient = backendStream.CopyToAsync(clientStream);
-
-            await Task.WhenAny(toBackend, toClient);
-        }
-        catch { }
-        finally
-        {
-            client.Close();
-            backend.Close();
-        }
-    }
-}

TaxBaik.Proxy/TaxBaik.Proxy.csproj

@@ -1,10 +0,0 @@
-<Project Sdk="Microsoft.NET.Sdk">
-
-  <PropertyGroup>
-    <OutputType>Exe</OutputType>
-    <TargetFramework>net10.0</TargetFramework>
-    <ImplicitUsings>enable</ImplicitUsings>
-    <Nullable>enable</Nullable>
-  </PropertyGroup>
-
-</Project>

TaxBaik.Web.Client.runtimeconfig.json

@@ -1,52 +0,0 @@
-{
-  "runtimeOptions": {
-    "tfm": "net10.0",
-    "includedFrameworks": [
-      {
-        "name": "Microsoft.NETCore.App",
-        "version": "10.0.0"
-      }
-    ],
-    "wasmHostProperties": {
-      "perHostConfig": [
-        {
-          "name": "browser",
-          "host": "browser"
-        }
-      ]
-    },
-    "configProperties": {
-      "Microsoft.AspNetCore.Components.Routing.RegexConstraintSupport": false,
-      "Microsoft.Extensions.DependencyInjection.VerifyOpenGenericServiceTrimmability": true,
-      "System.ComponentModel.DefaultValueAttribute.IsSupported": false,
-      "System.ComponentModel.Design.IDesignerHost.IsSupported": false,
-      "System.ComponentModel.TypeConverter.EnableUnsafeBinaryFormatterInDesigntimeLicenseContextSerialization": false,
-      "System.ComponentModel.TypeDescriptor.IsComObjectDescriptorSupported": false,
-      "System.Data.DataSet.XmlSerializationIsSupported": false,
-      "System.Diagnostics.Debugger.IsSupported": false,
-      "System.Diagnostics.Metrics.Meter.IsSupported": false,
-      "System.Diagnostics.Tracing.EventSource.IsSupported": false,
-      "System.GC.Server": true,
-      "System.Globalization.Invariant": false,
-      "System.TimeZoneInfo.Invariant": false,
-      "System.Linq.Enumerable.IsSizeOptimized": true,
-      "System.Net.Http.EnableActivityPropagation": false,
-      "System.Net.Http.WasmEnableStreamingResponse": true,
-      "System.Net.SocketsHttpHandler.Http3Support": false,
-      "System.Reflection.Metadata.MetadataUpdater.IsSupported": false,
-      "System.Resources.ResourceManager.AllowCustomResourceTypes": false,
-      "System.Resources.UseSystemResourceKeys": true,
-      "System.Runtime.CompilerServices.RuntimeFeature.IsDynamicCodeSupported": true,
-      "System.Runtime.InteropServices.BuiltInComInterop.IsSupported": false,
-      "System.Runtime.InteropServices.EnableConsumingManagedCodeFromNativeHosting": false,
-      "System.Runtime.InteropServices.EnableCppCLIHostActivation": false,
-      "System.Runtime.InteropServices.Marshalling.EnableGeneratedComInterfaceComImportInterop": false,
-      "System.Runtime.Serialization.EnableUnsafeBinaryFormatterSerialization": false,
-      "System.StartupHookProvider.IsSupported": false,
-      "System.Text.Encoding.EnableUnsafeUTF7Encoding": false,
-      "System.Text.Json.JsonSerializer.IsReflectionEnabledByDefault": true,
-      "System.Threading.Thread.EnableAutoreleasePool": false,
-      "Microsoft.AspNetCore.Components.Endpoints.NavigationManager.DisableThrowNavigationException": false
-    }
-  }
-}

TaxBaik.Web.Client/GlobalUsings.cs

@@ -1,2 +0,0 @@
-global using System.Net.Http;
-global using System.Net.Http.Json;

TaxBaik.Web.Client/Pages/WasmPing.razor

@@ -1,13 +0,0 @@
-@* WASM 기반(M3) 검증용 컴포넌트. 라우팅/렌더모드 전면 적용은 M4에서 처리한다. *@
-@rendermode InteractiveWebAssembly
-
-<MudPaper Class="pa-6 ma-4" Elevation="2">
-    <MudText Typo="Typo.h5" GutterBottom="true">WebAssembly 렌더 모드 점검</MudText>
-    <MudText Typo="Typo.body2" Class="mb-4">이 컴포넌트가 클릭에 반응하면 Interactive WebAssembly 기반이 정상 동작하는 것입니다.</MudText>
-    <MudButton Variant="Variant.Filled" Color="Color.Primary" OnClick="Increment">카운트: @count</MudButton>
-</MudPaper>
-
-@code {
-    private int count;
-    private void Increment() => count++;
-}

TaxBaik.Web.Client/Program.cs

@@ -1,53 +0,0 @@
-using Microsoft.AspNetCore.Components.Authorization;
-using Microsoft.AspNetCore.Components.WebAssembly.Hosting;
-using MudBlazor.Services;
-using TaxBaik.Application.Services;
-using TaxBaik.Web.Services;
-using TaxBaik.Web.Services.AdminClients;
-
-var builder = WebAssemblyHostBuilder.CreateDefault(args);
-
-// MudBlazor (WASM 측 인터랙티브 컴포넌트용)
-builder.Services.AddMudServices(config =>
-{
-    config.SnackbarConfiguration.HideTransitionDuration = 400;
-    config.SnackbarConfiguration.ShowTransitionDuration = 300;
-    config.PopoverOptions.ThrowOnDuplicateProvider = false;
-});
-
-// API Base Url 동적 구성 (호스트 기준 /taxbaik/api/)
-var apiBaseUrl = builder.HostEnvironment.BaseAddress.TrimEnd('/') + "/taxbaik/api/";
-
-// HTTP Client for API (with automatic token refresh)
-builder.Services.AddScoped<ITokenStore, TokenStore>();
-builder.Services.AddScoped<TokenRefreshHandler>();
-
-builder.Services.AddHttpClient<IApiClient, ApiClient>(client =>
-{
-    client.BaseAddress = new Uri(apiBaseUrl);
-}).AddHttpMessageHandler<TokenRefreshHandler>();
-
-// 각 Browser API Client 등록
-builder.Services.AddHttpClient<IAdminDashboardClient, AdminDashboardClient>(client => client.BaseAddress = new Uri(apiBaseUrl)).AddHttpMessageHandler<TokenRefreshHandler>();
-builder.Services.AddHttpClient<IBlogBrowserClient, BlogBrowserClient>(client => client.BaseAddress = new Uri(apiBaseUrl)).AddHttpMessageHandler<TokenRefreshHandler>();
-builder.Services.AddHttpClient<ICategoryBrowserClient, CategoryBrowserClient>(client => client.BaseAddress = new Uri(apiBaseUrl));
-builder.Services.AddHttpClient<IInquiryBrowserClient, InquiryBrowserClient>(client => client.BaseAddress = new Uri(apiBaseUrl)).AddHttpMessageHandler<TokenRefreshHandler>();
-builder.Services.AddHttpClient<IClientBrowserClient, ClientBrowserClient>(client => client.BaseAddress = new Uri(apiBaseUrl)).AddHttpMessageHandler<TokenRefreshHandler>();
-builder.Services.AddHttpClient<ITaxFilingBrowserClient, TaxFilingBrowserClient>(client => client.BaseAddress = new Uri(apiBaseUrl)).AddHttpMessageHandler<TokenRefreshHandler>();
-builder.Services.AddHttpClient<IFaqBrowserClient, FaqBrowserClient>(client => client.BaseAddress = new Uri(apiBaseUrl)).AddHttpMessageHandler<TokenRefreshHandler>();
-builder.Services.AddHttpClient<IAnnouncementBrowserClient, AnnouncementBrowserClient>(client => client.BaseAddress = new Uri(apiBaseUrl)).AddHttpMessageHandler<TokenRefreshHandler>();
-builder.Services.AddHttpClient<ITaxProfileBrowserClient, TaxProfileBrowserClient>(client => client.BaseAddress = new Uri(apiBaseUrl)).AddHttpMessageHandler<TokenRefreshHandler>();
-builder.Services.AddHttpClient<ITaxFilingScheduleBrowserClient, TaxFilingScheduleBrowserClient>(client => client.BaseAddress = new Uri(apiBaseUrl)).AddHttpMessageHandler<TokenRefreshHandler>();
-builder.Services.AddHttpClient<IConsultingActivityBrowserClient, ConsultingActivityBrowserClient>(client => client.BaseAddress = new Uri(apiBaseUrl)).AddHttpMessageHandler<TokenRefreshHandler>();
-builder.Services.AddHttpClient<IContractBrowserClient, ContractBrowserClient>(client => client.BaseAddress = new Uri(apiBaseUrl)).AddHttpMessageHandler<TokenRefreshHandler>();
-builder.Services.AddHttpClient<IRevenueTrackingBrowserClient, RevenueTrackingBrowserClient>(client => client.BaseAddress = new Uri(apiBaseUrl)).AddHttpMessageHandler<TokenRefreshHandler>();
-builder.Services.AddHttpClient<ICommonCodeBrowserClient, CommonCodeBrowserClient>(client => client.BaseAddress = new Uri(apiBaseUrl)).AddHttpMessageHandler<TokenRefreshHandler>();
-
-// Blazor 인증 (WASM 측 클라이언트)
-builder.Services.AddScoped<CustomAuthenticationStateProvider>();
-builder.Services.AddScoped<AuthenticationStateProvider>(sp => sp.GetRequiredService<CustomAuthenticationStateProvider>());
-builder.Services.AddScoped<ILocalStorageService, LocalStorageService>();
-builder.Services.AddCascadingAuthenticationState();
-builder.Services.AddAuthorizationCore();
-
-await builder.Build().RunAsync();

TaxBaik.Web.Client/Services/AdminClients/ICommonCodeBrowserClient.cs

@@ -1,118 +0,0 @@
-namespace TaxBaik.Web.Services.AdminClients;
-
-using System.Collections.Generic;
-using System.Net.Http.Json;
-using System.Text.Json;
-using System.Threading;
-using System.Threading.Tasks;
-using TaxBaik.Domain.Entities;
-using Microsoft.Extensions.Logging;
-
-public interface ICommonCodeBrowserClient
-{
-    Task<List<string>> GetGroupsAsync(CancellationToken ct = default);
-    Task<List<CommonCode>> GetAllActiveAsync(CancellationToken ct = default);
-    Task<List<CommonCode>> GetByGroupAsync(string group, CancellationToken ct = default);
-    Task<CommonCode?> GetAsync(string group, string value, CancellationToken ct = default);
-    Task<bool> UpsertAsync(CommonCode code, CancellationToken ct = default);
-    Task<bool> DeleteAsync(string group, string value, CancellationToken ct = default);
-}
-
-public class CommonCodeBrowserClient(HttpClient httpClient, ITokenStore tokenStore, ILogger<CommonCodeBrowserClient> logger) : ICommonCodeBrowserClient
-{
-    private const string BaseUrl = "/api/commoncode";
-
-    private void EnsureAuthHeader()
-    {
-        if (!string.IsNullOrEmpty(tokenStore.AccessToken))
-            httpClient.DefaultRequestHeaders.Authorization = new("Bearer", tokenStore.AccessToken);
-        else
-            httpClient.DefaultRequestHeaders.Authorization = null;
-    }
-
-    public async Task<List<CommonCode>> GetAllActiveAsync(CancellationToken ct = default)
-    {
-        try
-        {
-            EnsureAuthHeader();
-            return await httpClient.GetFromJsonAsync<List<CommonCode>>($"{BaseUrl}", ct) ?? [];
-        }
-        catch (Exception ex)
-        {
-            logger.LogError(ex, "Failed to get all active common codes");
-            return [];
-        }
-    }
-
-    public async Task<List<CommonCode>> GetByGroupAsync(string group, CancellationToken ct = default)
-    {
-        try
-        {
-            EnsureAuthHeader();
-            return await httpClient.GetFromJsonAsync<List<CommonCode>>($"{BaseUrl}/group/{group}", ct) ?? [];
-        }
-        catch (Exception ex)
-        {
-            logger.LogError(ex, "Failed to get common codes for group {Group}", group);
-            return [];
-        }
-    }
-
-    public async Task<List<string>> GetGroupsAsync(CancellationToken ct = default)
-    {
-        try
-        {
-            EnsureAuthHeader();
-            return await httpClient.GetFromJsonAsync<List<string>>($"{BaseUrl}/groups", ct) ?? [];
-        }
-        catch (Exception ex)
-        {
-            logger.LogError(ex, "Failed to get common code groups");
-            return [];
-        }
-    }
-
-    public async Task<CommonCode?> GetAsync(string group, string value, CancellationToken ct = default)
-    {
-        try
-        {
-            EnsureAuthHeader();
-            return await httpClient.GetFromJsonAsync<CommonCode>($"{BaseUrl}/{group}/{value}", ct);
-        }
-        catch (Exception ex)
-        {
-            logger.LogError(ex, "Failed to get common code {Group}/{Value}", group, value);
-            return null;
-        }
-    }
-
-    public async Task<bool> UpsertAsync(CommonCode code, CancellationToken ct = default)
-    {
-        try
-        {
-            EnsureAuthHeader();
-            var response = await httpClient.PostAsJsonAsync(BaseUrl, code, ct);
-            return response.IsSuccessStatusCode;
-        }
-        catch (Exception ex)
-        {
-            logger.LogError(ex, "Failed to upsert common code {Group}/{Value}", code.CodeGroup, code.CodeValue);
-            return false;
-        }
-    }
-
-    public async Task<bool> DeleteAsync(string group, string value, CancellationToken ct = default)
-    {
-        try
-        {
-            EnsureAuthHeader();
-            var response = await httpClient.DeleteAsync($"{BaseUrl}/{group}/{value}", ct);
-            return response.IsSuccessStatusCode;
-        }
-        catch (Exception ex)
-        {
-            logger.LogError(ex, "Failed to delete common code {Group}/{Value}", group, value);
-            return false;
-        }
-    }
-}

TaxBaik.Web.Client/Services/BlogBrowserClient.cs

@@ -1,88 +0,0 @@
-namespace TaxBaik.Web.Services;
-
-using System.Net.Http.Json;
-using TaxBaik.Application.DTOs;
-
-public interface IBlogBrowserClient
-{
-    Task<(IEnumerable<BlogPostResponseDto> Items, int Total)> GetAdminPagedAsync(int page = 1, int pageSize = 20, CancellationToken ct = default);
-    Task<BlogPostResponseDto?> GetByIdAsync(int id, CancellationToken ct = default);
-    Task<BlogPostResponseDto?> CreateAsync(CreateBlogPostDto dto, CancellationToken ct = default);
-    Task<BlogPostResponseDto?> UpdateAsync(int id, CreateBlogPostDto dto, CancellationToken ct = default);
-    Task<bool> DeleteAsync(int id, CancellationToken ct = default);
-    Task<bool> TogglePublishAsync(int id, CreateBlogPostDto dto, CancellationToken ct = default);
-}
-
-public class BlogBrowserClient : IBlogBrowserClient
-{
-    private readonly HttpClient _http;
-    private readonly ILogger<BlogBrowserClient> _logger;
-    private readonly ITokenStore _tokenStore;
-
-    public BlogBrowserClient(HttpClient http, ILogger<BlogBrowserClient> logger, ITokenStore tokenStore)
-    {
-        _http = http;
-        _logger = logger;
-        _tokenStore = tokenStore;
-    }
-
-    private void EnsureAuthHeader()
-    {
-        if (!string.IsNullOrEmpty(_tokenStore.AccessToken))
-            _http.DefaultRequestHeaders.Authorization = new("Bearer", _tokenStore.AccessToken);
-        else
-            _http.DefaultRequestHeaders.Authorization = null;
-    }
-
-    public async Task<(IEnumerable<BlogPostResponseDto> Items, int Total)> GetAdminPagedAsync(int page = 1, int pageSize = 20, CancellationToken ct = default)
-    {
-        EnsureAuthHeader();
-        var result = await _http.GetFromJsonAsync<PagedResponse>($"blog/admin?page={page}&pageSize={pageSize}", ct);
-        return result != null ? (result.Data, result.Total) : ([], 0);
-    }
-
-    public async Task<BlogPostResponseDto?> GetByIdAsync(int id, CancellationToken ct = default)
-    {
-        EnsureAuthHeader();
-        return await _http.GetFromJsonAsync<BlogPostResponseDto>($"blog/{id}", ct);
-    }
-
-    public async Task<BlogPostResponseDto?> CreateAsync(CreateBlogPostDto dto, CancellationToken ct = default)
-    {
-        EnsureAuthHeader();
-        var response = await _http.PostAsJsonAsync("blog", dto, ct);
-        if (!response.IsSuccessStatusCode)
-            return null;
-        var content = await response.Content.ReadAsStringAsync(ct);
-        return System.Text.Json.JsonSerializer.Deserialize<BlogPostResponseDto>(content, new System.Text.Json.JsonSerializerOptions { PropertyNameCaseInsensitive = true });
-    }
-
-    public async Task<BlogPostResponseDto?> UpdateAsync(int id, CreateBlogPostDto dto, CancellationToken ct = default)
-    {
-        EnsureAuthHeader();
-        var response = await _http.PutAsJsonAsync($"blog/{id}", dto, ct);
-        if (!response.IsSuccessStatusCode)
-            return null;
-        var content = await response.Content.ReadAsStringAsync(ct);
-        return System.Text.Json.JsonSerializer.Deserialize<BlogPostResponseDto>(content, new System.Text.Json.JsonSerializerOptions { PropertyNameCaseInsensitive = true });
-    }
-
-    public async Task<bool> DeleteAsync(int id, CancellationToken ct = default)
-    {
-        EnsureAuthHeader();
-        var response = await _http.DeleteAsync($"blog/{id}", ct);
-        return response.IsSuccessStatusCode;
-    }
-
-    public async Task<bool> TogglePublishAsync(int id, CreateBlogPostDto dto, CancellationToken ct = default)
-    {
-        var result = await UpdateAsync(id, dto, ct);
-        return result != null;
-    }
-
-    private sealed class PagedResponse
-    {
-        public List<BlogPostResponseDto> Data { get; set; } = [];
-        public int Total { get; set; }
-    }
-}

TaxBaik.Web.Client/Services/CategoryBrowserClient.cs

@@ -1,35 +0,0 @@
-namespace TaxBaik.Web.Services;
-
-using System.Net.Http.Json;
-using TaxBaik.Domain.Entities;
-
-public interface ICategoryBrowserClient
-{
-    Task<IReadOnlyList<Category>> GetAllAsync(CancellationToken ct = default);
-}
-
-public class CategoryBrowserClient : ICategoryBrowserClient
-{
-    private readonly HttpClient _http;
-    private readonly ILogger<CategoryBrowserClient> _logger;
-
-    public CategoryBrowserClient(HttpClient http, ILogger<CategoryBrowserClient> logger)
-    {
-        _http = http;
-        _logger = logger;
-    }
-
-    public async Task<IReadOnlyList<Category>> GetAllAsync(CancellationToken ct = default)
-    {
-        try
-        {
-            var result = await _http.GetFromJsonAsync<List<Category>>("category", cancellationToken: ct);
-            return result ?? [];
-        }
-        catch (HttpRequestException ex)
-        {
-            _logger.LogError(ex, "Failed to fetch categories");
-            throw;
-        }
-    }
-}

TaxBaik.Web.Client/TaxBaik.Web.Client.csproj

@@ -1,24 +0,0 @@
-<Project Sdk="Microsoft.NET.Sdk.BlazorWebAssembly">
-
-  <PropertyGroup>
-    <TargetFramework>net10.0</TargetFramework>
-    <Nullable>enable</Nullable>
-    <ImplicitUsings>enable</ImplicitUsings>
-    <RootNamespace>TaxBaik.WasmClient</RootNamespace>
-  </PropertyGroup>
-
-  <ItemGroup>
-    <ProjectReference Include="..\TaxBaik.Application\TaxBaik.Application.csproj" />
-  </ItemGroup>
-
-  <ItemGroup>
-    <PackageReference Include="Microsoft.AspNetCore.Components.WebAssembly" Version="10.0.9" />
-    <PackageReference Include="Microsoft.AspNetCore.Components.WebAssembly.DevServer" Version="10.0.9" PrivateAssets="all" />
-    <PackageReference Include="Microsoft.AspNetCore.Components.Authorization" Version="10.0.9" />
-    <PackageReference Include="Microsoft.Extensions.Http" Version="10.0.9" />
-    <PackageReference Include="Microsoft.IdentityModel.Tokens" Version="8.19.1" />
-    <PackageReference Include="MudBlazor" Version="6.10.0" />
-    <PackageReference Include="System.IdentityModel.Tokens.Jwt" Version="8.19.1" />
-  </ItemGroup>
-
-</Project>

TaxBaik.Web.Client/_Imports.razor

@@ -1,13 +0,0 @@
-@using System.Net.Http
-@using System.Net.Http.Json
-@using Microsoft.AspNetCore.Authorization
-@using Microsoft.AspNetCore.Components.Authorization
-@using Microsoft.AspNetCore.Components.Forms
-@using Microsoft.AspNetCore.Components.Routing
-@using Microsoft.AspNetCore.Components.Web
-@using Microsoft.AspNetCore.Components.Web.Virtualization
-@using Microsoft.AspNetCore.Components.WebAssembly.Http
-@using Microsoft.JSInterop
-@using MudBlazor
-@using TaxBaik.WasmClient
-@using static Microsoft.AspNetCore.Components.Web.RenderMode

TaxBaik.Web.deps.json

@@ -1,573 +0,0 @@
-{
-  "runtimeTarget": {
-    "name": ".NETCoreApp,Version=v10.0",
-    "signature": ""
-  },
-  "compilationOptions": {},
-  "targets": {
-    ".NETCoreApp,Version=v10.0": {
-      "TaxBaik.Web/1.0.0": {
-        "dependencies": {
-          "BCrypt.Net-Next": "4.0.3",
-          "Microsoft.AspNetCore.Authentication.Google": "10.0.9",
-          "Microsoft.AspNetCore.Authentication.JwtBearer": "10.0.9",
-          "Microsoft.AspNetCore.Components.WebAssembly.Server": "10.0.9",
-          "Microsoft.IdentityModel.Tokens": "8.19.1",
-          "MudBlazor": "6.10.0",
-          "Serilog.AspNetCore": "8.0.1",
-          "Serilog.Sinks.Console": "6.0.0",
-          "Serilog.Sinks.File": "5.0.0",
-          "System.IdentityModel.Tokens.Jwt": "8.19.1",
-          "TaxBaik.Application": "1.0.0",
-          "TaxBaik.Infrastructure": "1.0.0",
-          "TaxBaik.Web.Client": "1.0.0"
-        },
-        "runtime": {
-          "TaxBaik.Web.dll": {}
-        }
-      },
-      "BCrypt.Net-Next/4.0.3": {
-        "runtime": {
-          "lib/net6.0/BCrypt.Net-Next.dll": {
-            "assemblyVersion": "4.0.3.0",
-            "fileVersion": "4.0.3.0"
-          }
-        }
-      },
-      "Dapper/2.1.15": {
-        "runtime": {
-          "lib/net5.0/Dapper.dll": {
-            "assemblyVersion": "2.0.0.0",
-            "fileVersion": "2.1.15.52653"
-          }
-        }
-      },
-      "Microsoft.AspNetCore.Authentication.Google/10.0.9": {
-        "runtime": {
-          "lib/net10.0/Microsoft.AspNetCore.Authentication.Google.dll": {
-            "assemblyVersion": "10.0.9.0",
-            "fileVersion": "10.0.926.27113"
-          }
-        }
-      },
-      "Microsoft.AspNetCore.Authentication.JwtBearer/10.0.9": {
-        "dependencies": {
-          "Microsoft.IdentityModel.Protocols.OpenIdConnect": "8.0.1"
-        },
-        "runtime": {
-          "lib/net10.0/Microsoft.AspNetCore.Authentication.JwtBearer.dll": {
-            "assemblyVersion": "10.0.9.0",
-            "fileVersion": "10.0.926.27113"
-          }
-        }
-      },
-      "Microsoft.AspNetCore.Components.WebAssembly/10.0.9": {
-        "dependencies": {
-          "Microsoft.JSInterop.WebAssembly": "10.0.9"
-        },
-        "runtime": {
-          "lib/net10.0/Microsoft.AspNetCore.Components.WebAssembly.dll": {
-            "assemblyVersion": "10.0.9.0",
-            "fileVersion": "10.0.926.27113"
-          }
-        }
-      },
-      "Microsoft.AspNetCore.Components.WebAssembly.Server/10.0.9": {
-        "dependencies": {
-          "Microsoft.AspNetCore.Components.WebAssembly": "10.0.9"
-        },
-        "runtime": {
-          "lib/net10.0/Microsoft.AspNetCore.Components.WebAssembly.Server.dll": {
-            "assemblyVersion": "10.0.9.0",
-            "fileVersion": "10.0.926.27113"
-          }
-        }
-      },
-      "Microsoft.Bcl.Cryptography/10.0.2": {
-        "runtime": {
-          "lib/net10.0/Microsoft.Bcl.Cryptography.dll": {
-            "assemblyVersion": "10.0.0.2",
-            "fileVersion": "10.0.225.61305"
-          }
-        }
-      },
-      "Microsoft.Extensions.DependencyModel/8.0.0": {
-        "runtime": {
-          "lib/net8.0/Microsoft.Extensions.DependencyModel.dll": {
-            "assemblyVersion": "8.0.0.0",
-            "fileVersion": "8.0.23.53103"
-          }
-        }
-      },
-      "Microsoft.IdentityModel.Abstractions/8.19.1": {
-        "runtime": {
-          "lib/net10.0/Microsoft.IdentityModel.Abstractions.dll": {
-            "assemblyVersion": "8.19.1.0",
-            "fileVersion": "8.19.1.26153"
-          }
-        }
-      },
-      "Microsoft.IdentityModel.JsonWebTokens/8.19.1": {
-        "dependencies": {
-          "Microsoft.IdentityModel.Tokens": "8.19.1"
-        },
-        "runtime": {
-          "lib/net10.0/Microsoft.IdentityModel.JsonWebTokens.dll": {
-            "assemblyVersion": "8.19.1.0",
-            "fileVersion": "8.19.1.26153"
-          }
-        }
-      },
-      "Microsoft.IdentityModel.Logging/8.19.1": {
-        "dependencies": {
-          "Microsoft.IdentityModel.Abstractions": "8.19.1"
-        },
-        "runtime": {
-          "lib/net10.0/Microsoft.IdentityModel.Logging.dll": {
-            "assemblyVersion": "8.19.1.0",
-            "fileVersion": "8.19.1.26153"
-          }
-        }
-      },
-      "Microsoft.IdentityModel.Protocols/8.0.1": {
-        "dependencies": {
-          "Microsoft.IdentityModel.Tokens": "8.19.1"
-        },
-        "runtime": {
-          "lib/net9.0/Microsoft.IdentityModel.Protocols.dll": {
-            "assemblyVersion": "8.0.1.0",
-            "fileVersion": "8.0.1.50722"
-          }
-        }
-      },
-      "Microsoft.IdentityModel.Protocols.OpenIdConnect/8.0.1": {
-        "dependencies": {
-          "Microsoft.IdentityModel.Protocols": "8.0.1",
-          "System.IdentityModel.Tokens.Jwt": "8.19.1"
-        },
-        "runtime": {
-          "lib/net9.0/Microsoft.IdentityModel.Protocols.OpenIdConnect.dll": {
-            "assemblyVersion": "8.0.1.0",
-            "fileVersion": "8.0.1.50722"
-          }
-        }
-      },
-      "Microsoft.IdentityModel.Tokens/8.19.1": {
-        "dependencies": {
-          "Microsoft.Bcl.Cryptography": "10.0.2",
-          "Microsoft.IdentityModel.Logging": "8.19.1"
-        },
-        "runtime": {
-          "lib/net10.0/Microsoft.IdentityModel.Tokens.dll": {
-            "assemblyVersion": "8.19.1.0",
-            "fileVersion": "8.19.1.26153"
-          }
-        }
-      },
-      "Microsoft.JSInterop.WebAssembly/10.0.9": {
-        "runtime": {
-          "lib/net10.0/Microsoft.JSInterop.WebAssembly.dll": {
-            "assemblyVersion": "10.0.9.0",
-            "fileVersion": "10.0.926.27113"
-          }
-        }
-      },
-      "MudBlazor/6.10.0": {
-        "runtime": {
-          "lib/net7.0/MudBlazor.dll": {
-            "assemblyVersion": "6.10.0.0",
-            "fileVersion": "6.10.0.0"
-          }
-        }
-      },
-      "Npgsql/10.0.3": {
-        "runtime": {
-          "lib/net10.0/Npgsql.dll": {
-            "assemblyVersion": "10.0.3.0",
-            "fileVersion": "10.0.3.0"
-          }
-        }
-      },
-      "Serilog/4.0.0": {
-        "runtime": {
-          "lib/net8.0/Serilog.dll": {
-            "assemblyVersion": "4.0.0.0",
-            "fileVersion": "4.0.0.0"
-          }
-        }
-      },
-      "Serilog.AspNetCore/8.0.1": {
-        "dependencies": {
-          "Serilog": "4.0.0",
-          "Serilog.Extensions.Hosting": "8.0.0",
-          "Serilog.Extensions.Logging": "8.0.0",
-          "Serilog.Formatting.Compact": "2.0.0",
-          "Serilog.Settings.Configuration": "8.0.0",
-          "Serilog.Sinks.Console": "6.0.0",
-          "Serilog.Sinks.Debug": "2.0.0",
-          "Serilog.Sinks.File": "5.0.0"
-        },
-        "runtime": {
-          "lib/net8.0/Serilog.AspNetCore.dll": {
-            "assemblyVersion": "8.0.1.0",
-            "fileVersion": "8.0.1.0"
-          }
-        }
-      },
-      "Serilog.Extensions.Hosting/8.0.0": {
-        "dependencies": {
-          "Serilog": "4.0.0",
-          "Serilog.Extensions.Logging": "8.0.0"
-        },
-        "runtime": {
-          "lib/net8.0/Serilog.Extensions.Hosting.dll": {
-            "assemblyVersion": "7.0.0.0",
-            "fileVersion": "8.0.0.0"
-          }
-        }
-      },
-      "Serilog.Extensions.Logging/8.0.0": {
-        "dependencies": {
-          "Serilog": "4.0.0"
-        },
-        "runtime": {
-          "lib/net8.0/Serilog.Extensions.Logging.dll": {
-            "assemblyVersion": "7.0.0.0",
-            "fileVersion": "8.0.0.0"
-          }
-        }
-      },
-      "Serilog.Formatting.Compact/2.0.0": {
-        "dependencies": {
-          "Serilog": "4.0.0"
-        },
-        "runtime": {
-          "lib/net7.0/Serilog.Formatting.Compact.dll": {
-            "assemblyVersion": "2.0.0.0",
-            "fileVersion": "2.0.0.0"
-          }
-        }
-      },
-      "Serilog.Settings.Configuration/8.0.0": {
-        "dependencies": {
-          "Microsoft.Extensions.DependencyModel": "8.0.0",
-          "Serilog": "4.0.0"
-        },
-        "runtime": {
-          "lib/net8.0/Serilog.Settings.Configuration.dll": {
-            "assemblyVersion": "8.0.0.0",
-            "fileVersion": "8.0.0.0"
-          }
-        }
-      },
-      "Serilog.Sinks.Console/6.0.0": {
-        "dependencies": {
-          "Serilog": "4.0.0"
-        },
-        "runtime": {
-          "lib/net8.0/Serilog.Sinks.Console.dll": {
-            "assemblyVersion": "6.0.0.0",
-            "fileVersion": "6.0.0.0"
-          }
-        }
-      },
-      "Serilog.Sinks.Debug/2.0.0": {
-        "dependencies": {
-          "Serilog": "4.0.0"
-        },
-        "runtime": {
-          "lib/netstandard2.1/Serilog.Sinks.Debug.dll": {
-            "assemblyVersion": "2.0.0.0",
-            "fileVersion": "2.0.0.0"
-          }
-        }
-      },
-      "Serilog.Sinks.File/5.0.0": {
-        "dependencies": {
-          "Serilog": "4.0.0"
-        },
-        "runtime": {
-          "lib/net5.0/Serilog.Sinks.File.dll": {
-            "assemblyVersion": "5.0.0.0",
-            "fileVersion": "5.0.0.0"
-          }
-        }
-      },
-      "System.IdentityModel.Tokens.Jwt/8.19.1": {
-        "dependencies": {
-          "Microsoft.IdentityModel.JsonWebTokens": "8.19.1",
-          "Microsoft.IdentityModel.Tokens": "8.19.1"
-        },
-        "runtime": {
-          "lib/net10.0/System.IdentityModel.Tokens.Jwt.dll": {
-            "assemblyVersion": "8.19.1.0",
-            "fileVersion": "8.19.1.26153"
-          }
-        }
-      },
-      "TaxBaik.Application/1.0.0": {
-        "dependencies": {
-          "TaxBaik.Domain": "1.0.0"
-        },
-        "runtime": {
-          "TaxBaik.Application.dll": {
-            "assemblyVersion": "1.0.0.0",
-            "fileVersion": "1.0.0.0"
-          }
-        }
-      },
-      "TaxBaik.Domain/1.0.0": {
-        "runtime": {
-          "TaxBaik.Domain.dll": {
-            "assemblyVersion": "1.0.0.0",
-            "fileVersion": "1.0.0.0"
-          }
-        }
-      },
-      "TaxBaik.Infrastructure/1.0.0": {
-        "dependencies": {
-          "Dapper": "2.1.15",
-          "Npgsql": "10.0.3",
-          "TaxBaik.Domain": "1.0.0"
-        },
-        "runtime": {
-          "TaxBaik.Infrastructure.dll": {
-            "assemblyVersion": "1.0.0.0",
-            "fileVersion": "1.0.0.0"
-          }
-        }
-      },
-      "TaxBaik.Web.Client/1.0.0": {
-        "dependencies": {
-          "Microsoft.AspNetCore.Components.WebAssembly": "10.0.9",
-          "Microsoft.IdentityModel.Tokens": "8.19.1",
-          "MudBlazor": "6.10.0",
-          "System.IdentityModel.Tokens.Jwt": "8.19.1",
-          "TaxBaik.Application": "1.0.0"
-        },
-        "runtime": {
-          "TaxBaik.Web.Client.dll": {
-            "assemblyVersion": "1.0.0.0",
-            "fileVersion": "1.0.0.0"
-          }
-        }
-      }
-    }
-  },
-  "libraries": {
-    "TaxBaik.Web/1.0.0": {
-      "type": "project",
-      "serviceable": false,
-      "sha512": ""
-    },
-    "BCrypt.Net-Next/4.0.3": {
-      "type": "package",
-      "serviceable": true,
-      "sha512": "sha512-W+U9WvmZQgi5cX6FS5GDtDoPzUCV4LkBLkywq/kRZhuDwcbavOzcDAr3LXJFqHUi952Yj3LEYoWW0jbEUQChsA==",
-      "path": "bcrypt.net-next/4.0.3",
-      "hashPath": "bcrypt.net-next.4.0.3.nupkg.sha512"
-    },
-    "Dapper/2.1.15": {
-      "type": "package",
-      "serviceable": true,
-      "sha512": "sha512-1aWSAosZymEM+mRwfrXteRIN74/JTUjqj9B/KqEbanH6vfUKy9D9cemRN0q1ZOEfSB7d1PpFTpVOCbf2Uv70Og==",
-      "path": "dapper/2.1.15",
-      "hashPath": "dapper.2.1.15.nupkg.sha512"
-    },
-    "Microsoft.AspNetCore.Authentication.Google/10.0.9": {
-      "type": "package",
-      "serviceable": true,
-      "sha512": "sha512-xqjTc8/ap0dwKmdaqSlV8RxjXb02uQ8rynDtTuHRU2gmOYaNm6O+uUjobp4Ararzq0ndKNXiWnQErxjWEGFGiA==",
-      "path": "microsoft.aspnetcore.authentication.google/10.0.9",
-      "hashPath": "microsoft.aspnetcore.authentication.google.10.0.9.nupkg.sha512"
-    },
-    "Microsoft.AspNetCore.Authentication.JwtBearer/10.0.9": {
-      "type": "package",
-      "serviceable": true,
-      "sha512": "sha512-Hs5NDsGm8YicDDNx5RoBIT+H2AB9R27MvZ2gHoupTiHr+nnH3VxzY7DcmlbJ3b5DvvOhK35lWt/9Odtrq9sjtA==",
-      "path": "microsoft.aspnetcore.authentication.jwtbearer/10.0.9",
-      "hashPath": "microsoft.aspnetcore.authentication.jwtbearer.10.0.9.nupkg.sha512"
-    },
-    "Microsoft.AspNetCore.Components.WebAssembly/10.0.9": {
-      "type": "package",
-      "serviceable": true,
-      "sha512": "sha512-tBv68AsZ3r6z2QdV2m3cSSKUCbvEscN8REpHxcUs22vlR6UjTz6IKdInKNREkJ/3G1AQrBKrRTdrfrHVffE8Iw==",
-      "path": "microsoft.aspnetcore.components.webassembly/10.0.9",
-      "hashPath": "microsoft.aspnetcore.components.webassembly.10.0.9.nupkg.sha512"
-    },
-    "Microsoft.AspNetCore.Components.WebAssembly.Server/10.0.9": {
-      "type": "package",
-      "serviceable": true,
-      "sha512": "sha512-ZTtYvBILwGxhIiXi1L03ETBBOgMmizStu7dO/YblK6rPTa27wpEgYKp5Z9bUfr+wsFvHIDWd/ZMGb9on41f6yw==",
-      "path": "microsoft.aspnetcore.components.webassembly.server/10.0.9",
-      "hashPath": "microsoft.aspnetcore.components.webassembly.server.10.0.9.nupkg.sha512"
-    },
-    "Microsoft.Bcl.Cryptography/10.0.2": {
-      "type": "package",
-      "serviceable": true,
-      "sha512": "sha512-LG9Yll3B5aNpxv0+D47g6LiOiKBIlodhcHdQwcYzo8VeexFLGqx5ymetmA2aBRyo9cCcWsQWrFsdbsr8LvmWDw==",
-      "path": "microsoft.bcl.cryptography/10.0.2",
-      "hashPath": "microsoft.bcl.cryptography.10.0.2.nupkg.sha512"
-    },
-    "Microsoft.Extensions.DependencyModel/8.0.0": {
-      "type": "package",
-      "serviceable": true,
-      "sha512": "sha512-NSmDw3K0ozNDgShSIpsZcbFIzBX4w28nDag+TfaQujkXGazBm+lid5onlWoCBy4VsLxqnnKjEBbGSJVWJMf43g==",
-      "path": "microsoft.extensions.dependencymodel/8.0.0",
-      "hashPath": "microsoft.extensions.dependencymodel.8.0.0.nupkg.sha512"
-    },
-    "Microsoft.IdentityModel.Abstractions/8.19.1": {
-      "type": "package",
-      "serviceable": true,
-      "sha512": "sha512-gFA8THIk23uNF/vMdOHnjIdXD1LyA2g12cHzMJ+Xag6WpgWLw6E/6uCXxvA0gp9d2yAvkRt3xzFzMUiO/hofnQ==",
-      "path": "microsoft.identitymodel.abstractions/8.19.1",
-      "hashPath": "microsoft.identitymodel.abstractions.8.19.1.nupkg.sha512"
-    },
-    "Microsoft.IdentityModel.JsonWebTokens/8.19.1": {
-      "type": "package",
-      "serviceable": true,
-      "sha512": "sha512-6eeY+y2QFyjj3XnCz/8gJdoP5smYHTS9ow1bw2nsZzDIPjPhBZlackYTIduSMipVpxnoT/B62LkrXX2jPggOXg==",
-      "path": "microsoft.identitymodel.jsonwebtokens/8.19.1",
-      "hashPath": "microsoft.identitymodel.jsonwebtokens.8.19.1.nupkg.sha512"
-    },
-    "Microsoft.IdentityModel.Logging/8.19.1": {
-      "type": "package",
-      "serviceable": true,
-      "sha512": "sha512-H+sMrMpdbWnwkQnpb/ESkQovtOgdefmj0ecGCcP40mDKzE5i4dUYkH6599M9mWYFNGNJnTp92l/9wLubYXWimw==",
-      "path": "microsoft.identitymodel.logging/8.19.1",
-      "hashPath": "microsoft.identitymodel.logging.8.19.1.nupkg.sha512"
-    },
-    "Microsoft.IdentityModel.Protocols/8.0.1": {
-      "type": "package",
-      "serviceable": true,
-      "sha512": "sha512-uA2vpKqU3I2mBBEaeJAWPTjT9v1TZrGWKdgK6G5qJd03CLx83kdiqO9cmiK8/n1erkHzFBwU/RphP83aAe3i3g==",
-      "path": "microsoft.identitymodel.protocols/8.0.1",
-      "hashPath": "microsoft.identitymodel.protocols.8.0.1.nupkg.sha512"
-    },
-    "Microsoft.IdentityModel.Protocols.OpenIdConnect/8.0.1": {
-      "type": "package",
-      "serviceable": true,
-      "sha512": "sha512-AQDbfpL+yzuuGhO/mQhKNsp44pm5Jv8/BI4KiFXR7beVGZoSH35zMV3PrmcfvSTsyI6qrcR898NzUauD6SRigg==",
-      "path": "microsoft.identitymodel.protocols.openidconnect/8.0.1",
-      "hashPath": "microsoft.identitymodel.protocols.openidconnect.8.0.1.nupkg.sha512"
-    },
-    "Microsoft.IdentityModel.Tokens/8.19.1": {
-      "type": "package",
-      "serviceable": true,
-      "sha512": "sha512-KDiuSLXud2AFVNAOottd8ztVysfPeHyr4r8gofU3/VKUXlI7oytzGTnPsNJ/B3nui17rgz8wAdWNJOtzPjkUxw==",
-      "path": "microsoft.identitymodel.tokens/8.19.1",
-      "hashPath": "microsoft.identitymodel.tokens.8.19.1.nupkg.sha512"
-    },
-    "Microsoft.JSInterop.WebAssembly/10.0.9": {
-      "type": "package",
-      "serviceable": true,
-      "sha512": "sha512-4G0A7GuQrtCAes8PuJPTDUcy+lCrxHWjr8ZlkDOa4h8a2Txj1XdhbXKLnld2vMY5EyZNC5jZXxa1xTD/AOCUlw==",
-      "path": "microsoft.jsinterop.webassembly/10.0.9",
-      "hashPath": "microsoft.jsinterop.webassembly.10.0.9.nupkg.sha512"
-    },
-    "MudBlazor/6.10.0": {
-      "type": "package",
-      "serviceable": true,
-      "sha512": "sha512-Dpjouo3MVva4p8Nh2VCzHzvzReWhnzmCBNlrhymeXjn6oBEtT3Oi9z/R2sHOg/jYrW/hIPKMhfZHnptilHScsw==",
-      "path": "mudblazor/6.10.0",
-      "hashPath": "mudblazor.6.10.0.nupkg.sha512"
-    },
-    "Npgsql/10.0.3": {
-      "type": "package",
-      "serviceable": true,
-      "sha512": "sha512-7nb5YzXuvWWJxB0J8DiyL3we+X4FOctZrt0fIBnucOIaIevFEEwGQVZKtiu9olXdlNAK1eNgqSral6r/jlhI4w==",
-      "path": "npgsql/10.0.3",
-      "hashPath": "npgsql.10.0.3.nupkg.sha512"
-    },
-    "Serilog/4.0.0": {
-      "type": "package",
-      "serviceable": true,
-      "sha512": "sha512-2jDkUrSh5EofOp7Lx5Zgy0EB+7hXjjxE2ktTb1WVQmU00lDACR2TdROGKU0K1pDTBSJBN1PqgYpgOZF8mL7NJw==",
-      "path": "serilog/4.0.0",
-      "hashPath": "serilog.4.0.0.nupkg.sha512"
-    },
-    "Serilog.AspNetCore/8.0.1": {
-      "type": "package",
-      "serviceable": true,
-      "sha512": "sha512-B/X+wAfS7yWLVOTD83B+Ip9yl4MkhioaXj90JSoWi1Ayi8XHepEnsBdrkojg08eodCnmOKmShFUN2GgEc6c0CQ==",
-      "path": "serilog.aspnetcore/8.0.1",
-      "hashPath": "serilog.aspnetcore.8.0.1.nupkg.sha512"
-    },
-    "Serilog.Extensions.Hosting/8.0.0": {
-      "type": "package",
-      "serviceable": true,
-      "sha512": "sha512-db0OcbWeSCvYQkHWu6n0v40N4kKaTAXNjlM3BKvcbwvNzYphQFcBR+36eQ/7hMMwOkJvAyLC2a9/jNdUL5NjtQ==",
-      "path": "serilog.extensions.hosting/8.0.0",
-      "hashPath": "serilog.extensions.hosting.8.0.0.nupkg.sha512"
-    },
-    "Serilog.Extensions.Logging/8.0.0": {
-      "type": "package",
-      "serviceable": true,
-      "sha512": "sha512-YEAMWu1UnWgf1c1KP85l1SgXGfiVo0Rz6x08pCiPOIBt2Qe18tcZLvdBUuV5o1QHvrs8FAry9wTIhgBRtjIlEg==",
-      "path": "serilog.extensions.logging/8.0.0",
-      "hashPath": "serilog.extensions.logging.8.0.0.nupkg.sha512"
-    },
-    "Serilog.Formatting.Compact/2.0.0": {
-      "type": "package",
-      "serviceable": true,
-      "sha512": "sha512-ob6z3ikzFM3D1xalhFuBIK1IOWf+XrQq+H4KeH4VqBcPpNcmUgZlRQ2h3Q7wvthpdZBBoY86qZOI2LCXNaLlNA==",
-      "path": "serilog.formatting.compact/2.0.0",
-      "hashPath": "serilog.formatting.compact.2.0.0.nupkg.sha512"
-    },
-    "Serilog.Settings.Configuration/8.0.0": {
-      "type": "package",
-      "serviceable": true,
-      "sha512": "sha512-nR0iL5HwKj5v6ULo3/zpP8NMcq9E2pxYA6XKTSWCbugVs4YqPyvaqaKOY+OMpPivKp7zMEpax2UKHnDodbRB0Q==",
-      "path": "serilog.settings.configuration/8.0.0",
-      "hashPath": "serilog.settings.configuration.8.0.0.nupkg.sha512"
-    },
-    "Serilog.Sinks.Console/6.0.0": {
-      "type": "package",
-      "serviceable": true,
-      "sha512": "sha512-fQGWqVMClCP2yEyTXPIinSr5c+CBGUvBybPxjAGcf7ctDhadFhrQw03Mv8rJ07/wR5PDfFjewf2LimvXCDzpbA==",
-      "path": "serilog.sinks.console/6.0.0",
-      "hashPath": "serilog.sinks.console.6.0.0.nupkg.sha512"
-    },
-    "Serilog.Sinks.Debug/2.0.0": {
-      "type": "package",
-      "serviceable": true,
-      "sha512": "sha512-Y6g3OBJ4JzTyyw16fDqtFcQ41qQAydnEvEqmXjhwhgjsnG/FaJ8GUqF5ldsC/bVkK8KYmqrPhDO+tm4dF6xx4A==",
-      "path": "serilog.sinks.debug/2.0.0",
-      "hashPath": "serilog.sinks.debug.2.0.0.nupkg.sha512"
-    },
-    "Serilog.Sinks.File/5.0.0": {
-      "type": "package",
-      "serviceable": true,
-      "sha512": "sha512-uwV5hdhWPwUH1szhO8PJpFiahqXmzPzJT/sOijH/kFgUx+cyoDTMM8MHD0adw9+Iem6itoibbUXHYslzXsLEAg==",
-      "path": "serilog.sinks.file/5.0.0",
-      "hashPath": "serilog.sinks.file.5.0.0.nupkg.sha512"
-    },
-    "System.IdentityModel.Tokens.Jwt/8.19.1": {
-      "type": "package",
-      "serviceable": true,
-      "sha512": "sha512-2VHcRtT95GAcW1E3aVBLvL2rAAMxKHXKMXKXFyWzwgkdFXZPMMvP8tVOfnRydL4vTr1RirNuGC6T8VSEF2YsPQ==",
-      "path": "system.identitymodel.tokens.jwt/8.19.1",
-      "hashPath": "system.identitymodel.tokens.jwt.8.19.1.nupkg.sha512"
-    },
-    "TaxBaik.Application/1.0.0": {
-      "type": "project",
-      "serviceable": false,
-      "sha512": ""
-    },
-    "TaxBaik.Domain/1.0.0": {
-      "type": "project",
-      "serviceable": false,
-      "sha512": ""
-    },
-    "TaxBaik.Infrastructure/1.0.0": {
-      "type": "project",
-      "serviceable": false,
-      "sha512": ""
-    },
-    "TaxBaik.Web.Client/1.0.0": {
-      "type": "project",
-      "serviceable": false,
-      "sha512": ""
-    }
-  }
-}

TaxBaik.Web.runtimeconfig.json

@@ -1,20 +0,0 @@
-{
-  "runtimeOptions": {
-    "tfm": "net10.0",
-    "frameworks": [
-      {
-        "name": "Microsoft.NETCore.App",
-        "version": "10.0.0"
-      },
-      {
-        "name": "Microsoft.AspNetCore.App",
-        "version": "10.0.0"
-      }
-    ],
-    "configProperties": {
-      "System.GC.Server": true,
-      "System.Reflection.Metadata.MetadataUpdater.IsSupported": false,
-      "System.Runtime.Serialization.EnableUnsafeBinaryFormatterSerialization": false
-    }
-  }
-}

TaxBaik.Web/Components/Admin/App.razor

@@ -6,8 +6,6 @@
     <meta name="viewport" content="width=device-width, initial-scale=1.0" />
     <title>백원숙 세무회계 - 관리자</title>
     <base href="/taxbaik/" />
-    <link rel="icon" type="image/svg+xml" href="/taxbaik/favicon.svg" />
-    <link rel="alternate icon" href="/taxbaik/favicon.ico" />
     <link href="https://fonts.googleapis.com/css2?family=Noto+Sans+KR:wght@400;500;700&display=swap" rel="stylesheet" />
     <link href="https://fonts.googleapis.com/icon?family=Material+Icons" rel="stylesheet" />
     <link href="_content/MudBlazor/MudBlazor.min.css" rel="stylesheet" />
@@ -27,18 +25,19 @@
             <span style="font-size: 0.85rem; margin-top: 0.5rem; opacity: 0.8;">자동으로 페이지를 새로고침합니다. 잠시만 기다려주세요.</span>
         </div>
     </div>
-    <div id="blazor-loading" class="blazor-loading-overlay">
+    <div id="blazor-loading" class="blazor-loading-overlay show">
         <div class="blazor-loading-spinner">
             <div class="spinner"></div>
             <p>로드 중...</p>
         </div>
     </div>
     <MudThemeProvider @bind-IsDarkMode="isDarkMode" Theme="mudTheme" />
-    <Routes @rendermode="new InteractiveServerRenderMode(prerender: true)" />
+    <MudDialogProvider />
+    <MudSnackbarProvider />
+    <Routes @rendermode="new InteractiveServerRenderMode(prerender: false)" />
     <script src="_content/MudBlazor/MudBlazor.min.js"></script>
     <script src="js/admin-session.js"></script>
     <script src="_framework/blazor.web.js"></script>
-    <script>window.taxbaikAdminSession?.bindLoginForm();</script>
     <script>window.taxbaikAdminSession?.watchReconnect();</script>
 </body>
 </html>
@@ -80,49 +79,49 @@
         },
         LayoutProperties = new LayoutProperties()
         {
-            DefaultBorderRadius = "6px"
+            DefaultBorderRadius = "8px"
         },
         Typography = new Typography()
         {
             Default = new Default()
             {
-                FontSize = ".8125rem",
+                FontSize = ".875rem",
                 FontWeight = 400,
                 LineHeight = 1.5
             },
             H1 = new H1()
             {
-                FontSize = "1.75rem",
+                FontSize = "2.5rem",
                 FontWeight = 600,
                 LineHeight = 1.2
             },
             H2 = new H2()
             {
-                FontSize = "1.5rem",
+                FontSize = "2rem",
                 FontWeight = 600,
                 LineHeight = 1.3
             },
             H3 = new H3()
             {
-                FontSize = "1.25rem",
+                FontSize = "1.75rem",
                 FontWeight = 600,
                 LineHeight = 1.3
             },
             H4 = new H4()
             {
-                FontSize = "1.1rem",
+                FontSize = "1.5rem",
                 FontWeight = 600,
                 LineHeight = 1.4
             },
             H5 = new H5()
             {
-                FontSize = "0.95rem",
+                FontSize = "1.25rem",
                 FontWeight = 500,
                 LineHeight = 1.4
             },
             H6 = new H6()
             {
-                FontSize = "0.85rem",
+                FontSize = "1rem",
                 FontWeight = 500,
                 LineHeight = 1.5
             }

TaxBaik.Web/Components/Admin/Forms/InquiryForm.razor

@@ -1,6 +1,5 @@
 @using TaxBaik.Application.DTOs
 @using TaxBaik.Application.Services
-@using TaxBaik.Web.Components.Admin.Shared
 
 <MudForm @ref="form">
     <MudTextField @bind-Value="model.Name" Label="이름"
@@ -12,12 +11,25 @@
     <MudTextField @bind-Value="model.Email" Label="이메일"
         Variant="Variant.Outlined" Class="mb-4" InputType="InputType.Email" />
 
-    <CommonCodeSelect @bind-Value="model.ServiceType" Group="INQUIRY_SERVICE_TYPE" Label="문의 유형" Class="mb-4" />
+    <MudSelect @bind-Value="model.ServiceType" Label="문의 유형"
+        Variant="Variant.Outlined" Class="mb-4">
+        <MudSelectItem Value="@("사업자세무")">사업자세무</MudSelectItem>
+        <MudSelectItem Value="@("부동산세금")">부동산세금</MudSelectItem>
+        <MudSelectItem Value="@("가족자산")">가족자산</MudSelectItem>
+        <MudSelectItem Value="@("기타")">기타</MudSelectItem>
+    </MudSelect>
 
     <MudTextField @bind-Value="model.Message" Label="문의 내용"
         Variant="Variant.Outlined" Lines="5" Class="mb-4" Required="true" />
 
-    <CommonCodeSelect @bind-Value="model.Status" Group="INQUIRY_STATUS" Label="상태" Class="mb-4" />
+    <MudSelect @bind-Value="model.Status" Label="상태"
+        Variant="Variant.Outlined" Class="mb-4">
+        <MudSelectItem Value="@("new")">신규</MudSelectItem>
+        <MudSelectItem Value="@("consulting")">상담중</MudSelectItem>
+        <MudSelectItem Value="@("contracted")">계약완료</MudSelectItem>
+        <MudSelectItem Value="@("rejected")">거절</MudSelectItem>
+        <MudSelectItem Value="@("closed")">종결</MudSelectItem>
+    </MudSelect>
 
     <MudTextField @bind-Value="model.AdminMemo" Label="관리 메모"
         Variant="Variant.Outlined" Lines="3" Class="mb-4" />
@@ -45,7 +57,8 @@
 
     private MudForm? form;
     private InquiryFormModel model = new();
-    protected override async Task OnInitializedAsync()
+
+    protected override void OnInitialized()
     {
         if (InitialData != null)
         {
@@ -60,7 +73,6 @@
                 AdminMemo = InitialData.AdminMemo
             };
         }
-
     }
 
     private async Task HandleSubmit()

TaxBaik.Web/Components/Admin/Layout/MainLayout.razor

@@ -1,13 +1,7 @@
 @inherits LayoutComponentBase
 @inject NavigationManager Navigation
 @inject IJSRuntime JS
-@inject VersionInfo VersionInfo
 @implements IDisposable
-@rendermode @(new InteractiveWebAssemblyRenderMode(prerender: true))
-
-<MudPopoverProvider />
-<MudDialogProvider />
-<MudSnackbarProvider />
 
 <MudLayout Class="admin-shell">
     <MudAppBar Elevation="0" Class="admin-topbar">
@@ -16,9 +10,9 @@
                        Edge="Edge.Start"
                        Class="admin-menu-button"
                        OnClick="@ToggleDrawer" />
-        <div class="admin-topbar-title" style="display: flex; align-items: center; gap: 8px;">
+        <div class="admin-topbar-title">
-            <MudText Typo="Typo.body2" Class="font-weight-bold" Style="color: var(--primary-color);">[TaxBaik]</MudText>
+            <MudText Typo="Typo.caption" Color="Color.Secondary">TaxBaik Admin</MudText>
-            <MudText Typo="Typo.body2" Style="font-weight: bold; color: #1E293B;">세무회계 관리 대시보드</MudText>
+            <MudText Typo="Typo.h6">세무회계 관리 대시보드</MudText>
         </div>
         <MudSpacer />
 
@@ -88,14 +82,7 @@
 
             <MudNavLink Href="/taxbaik/admin/inquiries" Icon="@Icons.Material.Filled.Forum">문의 관리</MudNavLink>
             <MudNavLink Href="/taxbaik/admin/settings" Icon="@Icons.Material.Filled.Tune">설정</MudNavLink>
-            <MudNavLink Href="/taxbaik/admin/common-codes" Icon="@Icons.Material.Filled.Category">공통관리</MudNavLink>
         </MudNavMenu>
-
-        <div class="admin-drawer-version">
-            <div class="admin-drawer-version-label">Version</div>
-            <div class="admin-drawer-version-value">v@(VersionInfo.Version)</div>
-            <div class="admin-drawer-version-built">@VersionInfo.Built</div>
-        </div>
     </MudDrawer>
 
     <MudMainContent Class="admin-main">
@@ -128,7 +115,7 @@
 
     private void OnLocationChanged(object? sender, LocationChangedEventArgs args)
     {
-        _ = InvokeAsync(() => JS.InvokeVoidAsync("taxbaikAdminSession.hideLoading"));
+        _ = InvokeAsync(() => JS.InvokeVoidAsync("taxbaikAdminSession.showLoading"));
     }
 
     private void ToggleDrawer()

TaxBaik.Web/Components/Admin/Pages/Announcements/AnnouncementEdit.razor

@@ -3,7 +3,6 @@
 @attribute [Authorize]
 @using TaxBaik.Application.DTOs
 @using TaxBaik.Web.Services
-@using TaxBaik.Web.Components.Admin.Shared
 @inject IAnnouncementBrowserClient AnnouncementClient
 @inject NavigationManager Navigation
 @inject ISnackbar Snackbar
@@ -38,10 +37,13 @@
             </MudItem>
 
             <MudItem xs="12" sm="6">
-                <CommonCodeSelect @bind-Value="model.DisplayType"
+                <MudSelect @bind-Value="model.DisplayType"
-                                  Group="ANNOUNCEMENT_DISPLAY_TYPE"
+                           Label="유형"
-                                  Label="유형"
+                           Variant="Variant.Outlined">
-                                  Class="mb-0" />
+                    <MudSelectItem Value="@("info")">일반 (파란색)</MudSelectItem>
+                    <MudSelectItem Value="@("banner")">배너 (주황색) — 중요 이벤트</MudSelectItem>
+                    <MudSelectItem Value="@("urgent")">긴급 (빨간색) — 마감 임박</MudSelectItem>
+                </MudSelect>
             </MudItem>
 
             <MudItem xs="12" sm="6">

TaxBaik.Web/Components/Admin/Pages/Announcements/AnnouncementList.razor

@@ -22,22 +22,14 @@
     </MudButton>
 </section>
 
-<div class="d-flex pa-4 gap-4 align-center">
-    <MudTextField @bind-Value="searchQuery" Placeholder="공지사항 제목 검색..." Adornment="Adornment.Start" 
-                  AdornmentIcon="@Icons.Material.Filled.Search" IconSize="Size.Medium" Class="flex-grow-1" Immediate="true" Clearable="true" />
-</div>
-
 <MudPaper Class="admin-surface" Elevation="0">
     @if (announcements is null)
     {
         <MudProgressLinear Indeterminate="true" />
     }
-    else if (!FilteredAnnouncements.Any())
+    else if (!announcements.Any())
     {
-        <div class="pa-6 text-center">
+        <MudText Class="pa-4 text-muted">등록된 공지사항이 없습니다.</MudText>
-            <MudIcon Icon="@Icons.Material.Filled.Campaign" Style="font-size:3rem; opacity:.3;" />
-            <MudText Class="mt-2 text-muted">검색 조건에 맞는 공지사항이 없습니다.</MudText>
-        </div>
     }
     else
     {
@@ -53,7 +45,7 @@
                 </tr>
             </thead>
             <tbody>
-                @foreach (var item in FilteredAnnouncements)
+                @foreach (var item in announcements)
                 {
                     <tr>
                         <td>@item.Title</td>
@@ -94,34 +86,15 @@
                 }
             </tbody>
         </MudSimpleTable>
-        <MudText Typo="Typo.caption" Class="pa-2 text-muted">
-            검색 결과 @(FilteredAnnouncements.Count())개 · 총 @(announcements.Count)개
-        </MudText>
     }
 </MudPaper>
 
 @code {
-    [CascadingParameter]
-    private Task<AuthenticationState>? AuthStateTask { get; set; }
-
     private List<Announcement>? announcements;
-    private string searchQuery = "";
-
-    private IEnumerable<Announcement> FilteredAnnouncements => announcements?
-        .Where(a => string.IsNullOrEmpty(searchQuery) || 
-                    a.Title.Contains(searchQuery, StringComparison.OrdinalIgnoreCase))
-        .OrderBy(a => a.SortOrder) ?? Enumerable.Empty<Announcement>();
 
     protected override async Task OnInitializedAsync()
     {
-        if (AuthStateTask != null)
+        await LoadAsync();
-        {
-            var authState = await AuthStateTask;
-            if (authState.User.Identity?.IsAuthenticated == true)
-            {
-                await LoadAsync();
-            }
-        }
     }
 
     private async Task LoadAsync()

TaxBaik.Web/Components/Admin/Pages/Blog/BlogCreate.razor

@@ -1,9 +1,10 @@
 @page "/admin/blog/create"
 @attribute [Authorize]
 @using TaxBaik.Application.DTOs
-@using TaxBaik.Web.Components.Admin.Pages.Blog
+@using TaxBaik.Application.Services
-@inject IBlogBrowserClient BlogClient
+@using TaxBaik.Domain.Interfaces
-@inject ICategoryBrowserClient CategoryClient
+@inject BlogService BlogService
+@inject ICategoryRepository CategoryRepository
 @inject NavigationManager Navigation
 @inject ISnackbar Snackbar
 
@@ -19,16 +20,47 @@
 </section>
 
 <MudPaper Class="pa-4 mt-4" Elevation="1">
-    <BlogForm Model="model" Categories="categories" SubmitText="저장" OnSubmit="SavePost" OnCancel="GoBack" />
+    <MudForm @ref="form">
+        <MudTextField @bind-Value="model.Title" Label="제목"
+            Variant="Variant.Outlined" Class="mb-4" Required="true" />
+
+        <MudSelect @bind-Value="model.CategoryId" Label="카테고리"
+            Variant="Variant.Outlined" Class="mb-4">
+            @foreach (var category in categories)
+            {
+                <MudSelectItem Value="@category.Id">@category.Name</MudSelectItem>
+            }
+        </MudSelect>
+
+        <MudTextField @bind-Value="model.Content" Label="본문"
+            Variant="Variant.Outlined" Lines="10" Class="mb-4" Required="true" />
+
+        <MudTextField @bind-Value="model.Tags" Label="태그 (쉼표로 구분)"
+            Variant="Variant.Outlined" Class="mb-4" />
+
+        <MudTextField @bind-Value="model.SeoTitle" Label="SEO 제목"
+            Variant="Variant.Outlined" Class="mb-4" />
+
+        <MudTextField @bind-Value="model.SeoDescription" Label="SEO 설명"
+            Variant="Variant.Outlined" Lines="3" Class="mb-4" />
+
+        <MudCheckBox @bind-Checked="model.IsPublished" Label="즉시 발행" Class="mb-4" />
+
+        <div class="d-flex gap-2">
+            <MudButton Variant="Variant.Filled" Color="Color.Primary"
+                @onclick="SavePost">저장</MudButton>
+        </div>
+    </MudForm>
 </MudPaper>
 
 @code {
-    private IReadOnlyList<Domain.Entities.Category> categories = [];
+    private MudForm? form;
-    private BlogForm.BlogFormModel model = new();
+    private List<Domain.Entities.Category> categories = [];
+    private CreatePostModel model = new();
 
     protected override async Task OnInitializedAsync()
     {
-        categories = await CategoryClient.GetAllAsync();
+        categories = (await CategoryRepository.GetAllAsync()).ToList();
     }
 
     private void GoBack()
@@ -38,9 +70,16 @@
 
     private async Task SavePost()
     {
+        if (form == null)
+            return;
+
+        await form.Validate();
+        if (!form.IsValid)
+            return;
+
         try
         {
-            var result = await BlogClient.CreateAsync(new CreateBlogPostDto
+            await BlogService.CreateAsync(new CreateBlogPostDto
             {
                 Title = model.Title,
                 Content = model.Content,
@@ -51,12 +90,6 @@
                 IsPublished = model.IsPublished
             });
 
-            if (result == null)
-            {
-                Snackbar.Add("포스트 저장에 실패했습니다.", Severity.Error);
-                return;
-            }
-
             Snackbar.Add("포스트가 저장되었습니다.", Severity.Success);
             Navigation.NavigateTo("/taxbaik/admin/blog");
         }
@@ -65,4 +98,15 @@
             Snackbar.Add(ex.Message, Severity.Error);
         }
     }
+
+    private class CreatePostModel
+    {
+        public string Title { get; set; } = "";
+        public string Content { get; set; } = "";
+        public int? CategoryId { get; set; }
+        public string? Tags { get; set; }
+        public string? SeoTitle { get; set; }
+        public string? SeoDescription { get; set; }
+        public bool IsPublished { get; set; }
+    }
 }

TaxBaik.Web/Components/Admin/Pages/Blog/BlogEdit.razor

@@ -1,9 +1,10 @@
 @page "/admin/blog/{id:int}/edit"
 @attribute [Authorize]
 @using TaxBaik.Application.DTOs
-@using TaxBaik.Web.Components.Admin.Pages.Blog
+@using TaxBaik.Application.Services
-@inject IBlogBrowserClient BlogClient
+@using TaxBaik.Domain.Interfaces
-@inject ICategoryBrowserClient CategoryClient
+@inject BlogService BlogService
+@inject ICategoryRepository CategoryRepository
 @inject NavigationManager Navigation
 @inject ISnackbar Snackbar
 @inject IDialogService DialogService
@@ -30,10 +31,39 @@ else if (post == null)
 else
 {
     <MudPaper Class="pa-4 mt-4" Elevation="1">
-        <BlogForm Model="model" Categories="categories" SubmitText="저장" OnSubmit="SavePost" />
+        <MudForm @ref="form">
-        <div class="mt-4">
+            <MudTextField @bind-Value="model.Title" Label="제목"
-            <MudButton Variant="Variant.Outlined" Color="Color.Error" @onclick="DeletePost">삭제</MudButton>
+                Variant="Variant.Outlined" Class="mb-4" Required="true" />
-        </div>
+
+            <MudSelect @bind-Value="model.CategoryId" Label="카테고리"
+                Variant="Variant.Outlined" Class="mb-4">
+                @foreach (var category in categories)
+                {
+                    <MudSelectItem Value="@category.Id">@category.Name</MudSelectItem>
+                }
+            </MudSelect>
+
+            <MudTextField @bind-Value="model.Content" Label="본문"
+                Variant="Variant.Outlined" Lines="10" Class="mb-4" Required="true" />
+
+            <MudTextField @bind-Value="model.Tags" Label="태그 (쉼표로 구분)"
+                Variant="Variant.Outlined" Class="mb-4" />
+
+            <MudTextField @bind-Value="model.SeoTitle" Label="SEO 제목"
+                Variant="Variant.Outlined" Class="mb-4" />
+
+            <MudTextField @bind-Value="model.SeoDescription" Label="SEO 설명"
+                Variant="Variant.Outlined" Lines="3" Class="mb-4" />
+
+            <MudCheckBox @bind-Checked="model.IsPublished" Label="발행" Class="mb-4" />
+
+            <div class="d-flex gap-2">
+                <MudButton Variant="Variant.Filled" Color="Color.Primary"
+                    @onclick="SavePost">저장</MudButton>
+                <MudButton Variant="Variant.Outlined" Color="Color.Error"
+                    @onclick="DeletePost">삭제</MudButton>
+            </div>
+        </MudForm>
     </MudPaper>
 }
 
@@ -41,19 +71,20 @@ else
     [Parameter]
     public int Id { get; set; }
 
-    private TaxBaik.Application.DTOs.BlogPostResponseDto? post;
+    private MudForm? form;
-    private IReadOnlyList<Domain.Entities.Category> categories = [];
+    private Domain.Entities.BlogPost? post;
-    private BlogForm.BlogFormModel model = new();
+    private List<Domain.Entities.Category> categories = [];
+    private EditPostModel model = new();
     private bool isLoading = true;
 
     protected override async Task OnInitializedAsync()
     {
         try
         {
-            post = await BlogClient.GetByIdAsync(Id);
+            post = await BlogService.GetByIdAsync(Id);
             if (post != null)
             {
-                categories = await CategoryClient.GetAllAsync();
+                categories = (await CategoryRepository.GetAllAsync()).ToList();
                 MapPostToModel(post);
             }
         }
@@ -67,7 +98,7 @@ else
         }
     }
 
-    private void MapPostToModel(TaxBaik.Application.DTOs.BlogPostResponseDto post)
+    private void MapPostToModel(Domain.Entities.BlogPost post)
     {
         model.Title = post.Title;
         model.Content = post.Content;
@@ -85,12 +116,16 @@ else
 
     private async Task SavePost()
     {
-        if (post == null)
+        if (form == null || post == null)
+            return;
+
+        await form.Validate();
+        if (!form.IsValid)
             return;
 
         try
         {
-            var result = await BlogClient.UpdateAsync(post.Id, new CreateBlogPostDto
+            await BlogService.UpdateAsync(post.Id, new CreateBlogPostDto
             {
                 Title = model.Title,
                 Content = model.Content,
@@ -101,12 +136,6 @@ else
                 IsPublished = model.IsPublished
             });
 
-            if (result == null)
-            {
-                Snackbar.Add("저장 실패: 포스트를 저장하지 못했습니다.", Severity.Error);
-                return;
-            }
-
             Snackbar.Add("포스트가 저장되었습니다.", Severity.Success);
             Navigation.NavigateTo("/taxbaik/admin/blog");
         }
@@ -135,12 +164,7 @@ else
 
         try
         {
-            var deleted = await BlogClient.DeleteAsync(post.Id);
+            await BlogService.DeleteAsync(post.Id);
-            if (!deleted)
-            {
-                Snackbar.Add("삭제 실패: 포스트를 삭제하지 못했습니다.", Severity.Error);
-                return;
-            }
             Snackbar.Add("포스트가 삭제되었습니다.", Severity.Success);
             Navigation.NavigateTo("/taxbaik/admin/blog");
         }
@@ -149,4 +173,15 @@ else
             Snackbar.Add($"삭제 실패: {ex.Message}", Severity.Error);
         }
     }
+
+    private class EditPostModel
+    {
+        public string Title { get; set; } = "";
+        public string Content { get; set; } = "";
+        public int? CategoryId { get; set; }
+        public string? Tags { get; set; }
+        public string? SeoTitle { get; set; }
+        public string? SeoDescription { get; set; }
+        public bool IsPublished { get; set; }
+    }
 }

TaxBaik.Web/Components/Admin/Pages/Blog/BlogForm.razor

@@ -1,80 +0,0 @@
-@using TaxBaik.Application.DTOs
-@using TaxBaik.Domain.Entities
-
-<MudForm @ref="form">
-    <MudTextField @bind-Value="Model.Title" Label="제목 *"
-        Variant="Variant.Outlined" Class="mb-4" Required="true" RequiredError="제목을 입력하세요." Counter="100" MaxLength="100" />
-
-    <MudSelect T="int?" @bind-Value="Model.CategoryId" Label="카테고리"
-        Variant="Variant.Outlined" Class="mb-4">
-        @foreach (var category in Categories)
-        {
-            <MudSelectItem T="int?" Value="@((int?)category.Id)">@category.Name</MudSelectItem>
-        }
-    </MudSelect>
-
-    <MudTextField @bind-Value="Model.Content" Label="본문 내용 *"
-        Variant="Variant.Outlined" Lines="16" Required="true" RequiredError="본문 내용을 입력하세요."
-        Class="mb-4" />
-
-    <MudTextField @bind-Value="Model.Tags" Label="태그 (쉼표로 구분)"
-        Variant="Variant.Outlined" Class="mb-4" />
-
-    <MudTextField @bind-Value="Model.SeoTitle" Label="SEO 제목"
-        Variant="Variant.Outlined" Class="mb-4" />
-
-    <MudTextField @bind-Value="Model.SeoDescription" Label="SEO 설명"
-        Variant="Variant.Outlined" Lines="3" Class="mb-4" />
-
-    <MudCheckBox @bind-Checked="Model.IsPublished" Label="즉시 발행" Class="mb-4" />
-
-    <div class="d-flex gap-2">
-        <MudButton Variant="Variant.Filled" Color="Color.Primary" @onclick="HandleSubmit">@SubmitText</MudButton>
-        @if (OnCancel.HasDelegate)
-        {
-            <MudButton Variant="Variant.Outlined" @onclick="OnCancel">취소</MudButton>
-        }
-    </div>
-</MudForm>
-
-@code {
-    [Parameter, EditorRequired]
-    public BlogFormModel Model { get; set; } = new();
-
-    [Parameter]
-    public IReadOnlyList<Category> Categories { get; set; } = [];
-
-    [Parameter]
-    public string SubmitText { get; set; } = "저장";
-
-    [Parameter]
-    public EventCallback OnSubmit { get; set; }
-
-    [Parameter]
-    public EventCallback OnCancel { get; set; }
-
-    private MudForm? form;
-
-    private async Task HandleSubmit()
-    {
-        if (form == null)
-            return;
-
-        await form.Validate();
-        if (!form.IsValid)
-            return;
-
-        await OnSubmit.InvokeAsync();
-    }
-
-    public class BlogFormModel
-    {
-        public string Title { get; set; } = "";
-        public string Content { get; set; } = "";
-        public int? CategoryId { get; set; }
-        public string? Tags { get; set; }
-        public string? SeoTitle { get; set; }
-        public string? SeoDescription { get; set; }
-        public bool IsPublished { get; set; }
-    }
-}

TaxBaik.Web/Components/Admin/Pages/Blog/BlogList.razor

@@ -1,30 +1,28 @@
 @page "/admin/blog"
 @attribute [Authorize]
-@inject IBlogBrowserClient BlogClient
+@inject IApiClient ApiClient
 @inject ISnackbar Snackbar
 
 <PageTitle>블로그 관리</PageTitle>
 
-<AdminPageHeader Title="블로그 관리" Eyebrow="Content" Subtitle="검색 유입 콘텐츠의 발행 상태와 성과를 관리합니다.">
+<section class="admin-page-hero">
-    <ChildContent>
+    <div>
-        <MudButton Variant="Variant.Filled" Color="Color.Primary" StartIcon="@Icons.Material.Filled.EditNote"
+        <MudText Typo="Typo.caption" Class="admin-eyebrow">Content</MudText>
-                   Href="/taxbaik/admin/blog/create">새 포스트 작성</MudButton>
+        <MudText Typo="Typo.h4" Class="admin-page-title">블로그 관리</MudText>
-    </ChildContent>
+        <MudText Typo="Typo.body2" Class="admin-page-subtitle">검색 유입 콘텐츠의 발행 상태와 성과를 관리합니다.</MudText>
-</AdminPageHeader>
+    </div>
-
+    <MudButton Variant="Variant.Filled" Color="Color.Primary" StartIcon="@Icons.Material.Filled.EditNote"
-<div class="d-flex pa-4 gap-4 align-center">
+        Href="/taxbaik/admin/blog/create">새 포스트 작성</MudButton>
-    <MudTextField @bind-Value="searchQuery" Placeholder="블로그 제목 또는 본문 검색..." Adornment="Adornment.Start" 
+</section>
-                  AdornmentIcon="@Icons.Material.Filled.Search" IconSize="Size.Medium" Class="flex-grow-1" Immediate="true" Clearable="true" />
-</div>
 
 <MudPaper Class="admin-surface mb-4" Elevation="0">
     <MudStack Row="true" AlignItems="AlignItems.Center" Justify="Justify.SpaceBetween">
-        <MudText Typo="Typo.subtitle1">@($"검색 결과 {FilteredPosts.Count()}개 / 전체 포스트 {totalPosts}개")</MudText>
+        <MudText Typo="Typo.subtitle1">@($"전체 포스트 {totalPosts}개")</MudText>
         <MudText Typo="Typo.body2">페이지 @currentPage / @totalPages</MudText>
     </MudStack>
 </MudPaper>
 
-<MudDataGrid Items="@FilteredPosts" Striped="true" Hoverable="true" Loading="@isLoading" Class="admin-grid">
+<MudDataGrid Items="@posts" Striped="true" Hoverable="true" Loading="@isLoading" Class="admin-grid">
     <Columns>
         <PropertyColumn Property="x => x.Title" Title="제목" />
         <PropertyColumn Property="x => x.IsPublished" Title="발행">
@@ -52,32 +50,16 @@
 </MudStack>
 
 @code {
-    [CascadingParameter]
+    private List<TaxBaik.Domain.Entities.BlogPost> posts = [];
-    private Task<AuthenticationState>? AuthStateTask { get; set; }
-
-    private List<TaxBaik.Application.DTOs.BlogPostResponseDto> posts = [];
-    private string searchQuery = "";
     private bool isLoading = true;
     private int currentPage = 1;
     private int totalPages = 1;
     private int totalPosts = 0;
     private const int PageSize = 20;
 
-    private IEnumerable<TaxBaik.Application.DTOs.BlogPostResponseDto> FilteredPosts => posts
-        .Where(p => string.IsNullOrEmpty(searchQuery) ||
-                    p.Title.Contains(searchQuery, StringComparison.OrdinalIgnoreCase) ||
-                    (p.Content != null && p.Content.Contains(searchQuery, StringComparison.OrdinalIgnoreCase)));
-
     protected override async Task OnInitializedAsync()
     {
-        if (AuthStateTask != null)
+        await LoadPosts();
-        {
-            var authState = await AuthStateTask;
-            if (authState.User.Identity?.IsAuthenticated == true)
-            {
-                await LoadPosts();
-            }
-        }
     }
 
     private async Task LoadPosts()
@@ -85,9 +67,9 @@
         isLoading = true;
         try
         {
-            var result = await BlogClient.GetAdminPagedAsync(currentPage, PageSize);
+            var result = await ApiClient.GetAsync<PagedBlogResponse>($"blog/admin?page={currentPage}&pageSize={PageSize}");
-            posts = result.Items.ToList();
+            posts = result?.Data ?? [];
-            totalPosts = result.Total;
+            totalPosts = result?.Total ?? 0;
             totalPages = Math.Max(1, (int)Math.Ceiling(totalPosts / (double)PageSize));
         }
         catch
@@ -117,21 +99,21 @@
         await LoadPosts();
     }
 
-    private async Task TogglePublish(TaxBaik.Application.DTOs.BlogPostResponseDto post, bool isPublished)
+    private async Task TogglePublish(TaxBaik.Domain.Entities.BlogPost post, bool isPublished)
     {
         var previous = post.IsPublished;
         post.IsPublished = isPublished;
-        var result = await BlogClient.UpdateAsync(post.Id, new TaxBaik.Application.DTOs.CreateBlogPostDto
+        var result = await ApiClient.PutAsync<TaxBaik.Domain.Entities.BlogPost>($"blog/{post.Id}", new
         {
-            Title = post.Title,
+            post.Title,
-            Content = post.Content,
+            post.Content,
-            CategoryId = post.CategoryId,
+            post.CategoryId,
-            Tags = post.Tags,
+            post.Tags,
-            SeoTitle = post.SeoTitle,
+            post.SeoTitle,
-            SeoDescription = post.SeoDescription,
+            post.SeoDescription,
-            ThumbnailUrl = post.ThumbnailUrl,
+            post.ThumbnailUrl,
             IsPublished = isPublished,
-            AuthorId = post.AuthorId
+            post.AuthorId
         });
 
         if (result == null)
@@ -146,13 +128,14 @@
 
     private async Task DeletePost(int postId)
     {
-        var deleted = await BlogClient.DeleteAsync(postId);
+        await ApiClient.DeleteAsync($"blog/{postId}");
-        if (!deleted)
-        {
-            Snackbar.Add("포스트 삭제에 실패했습니다.", Severity.Error);
-            return;
-        }
         Snackbar.Add("포스트가 삭제되었습니다.", Severity.Success);
         await LoadPosts();
     }
+
+    private class PagedBlogResponse
+    {
+        public List<TaxBaik.Domain.Entities.BlogPost> Data { get; set; } = [];
+        public int Total { get; set; }
+    }
 }

TaxBaik.Web/Components/Admin/Pages/Clients/ClientDetail.razor

@@ -1,10 +1,8 @@
 @page "/admin/clients/{ClientId:int}"
 @attribute [Authorize]
-@using TaxBaik.Web.Services
+@using TaxBaik.Application.Services
-@using TaxBaik.Web.Services.AdminClients
+@inject ClientService ClientService
-@using TaxBaik.Web.Components.Admin.Shared
+@inject ConsultationService ConsultationService
-@inject IClientBrowserClient ClientClient
-@inject IConsultingActivityBrowserClient ConsultingClient
 @inject NavigationManager Navigation
 @inject ISnackbar Snackbar
 
@@ -104,7 +102,12 @@
                             <MudDatePicker @bind-Date="newDate" Label="상담일" DateFormat="yyyy-MM-dd" />
                         </MudItem>
                         <MudItem xs="12" sm="6">
-                        <CommonCodeSelect @bind-Value="newServiceType" Group="CONSULTING_ACTIVITY_TYPE" Label="서비스 분야" Placeholder="선택" Clearable="true" />
+                            <MudSelect T="string" @bind-Value="newServiceType" Label="서비스 분야">
+                                @foreach (var t in ClientService.ServiceTypes)
+                                {
+                                    <MudSelectItem Value="@t">@t</MudSelectItem>
+                                }
+                            </MudSelect>
                         </MudItem>
                         <MudItem xs="12">
                             <MudTextField T="string" @bind-Value="newSummary" Label="상담 내용 *"
@@ -113,7 +116,7 @@
                         <MudItem xs="12" sm="6">
                             <MudSelect T="string" @bind-Value="newResult" Label="결과">
                                 <MudSelectItem Value="@("")">-</MudSelectItem>
-                                @foreach (var r in results)
+                                @foreach (var r in ConsultationService.Results)
                                 {
                                     <MudSelectItem Value="@r">@r</MudSelectItem>
                                 }
@@ -179,7 +182,6 @@
 
     private Domain.Entities.Client? client;
     private List<Domain.Entities.Consultation> consultations = [];
-    private static readonly string[] results = ["", "상담완료", "추가자료 요청", "견적발송", "계약전환", "보류"];
 
     private bool showAddForm;
     private DateTime? newDate = DateTime.Today;
@@ -195,19 +197,8 @@
 
     private async Task LoadAll()
     {
-        client = await ClientClient.GetByIdAsync(ClientId);
+        client = await ClientService.GetByIdAsync(ClientId);
-        consultations = (await ConsultingClient.GetByClientIdAsync(ClientId))
+        consultations = (await ConsultationService.GetByClientIdAsync(ClientId)).ToList();
-            .Select(c => new Domain.Entities.Consultation
-            {
-                Id = c.Id,
-                ClientId = c.ClientId,
-                ConsultationDate = c.ActivityDate,
-                ServiceType = c.ActivityType,
-                Summary = c.Description,
-                Result = null,
-                Fee = null
-            })
-            .ToList();
     }
 
     private void OpenAddConsultation()
@@ -224,35 +215,30 @@
     {
         try
         {
-            var newId = await ConsultingClient.CreateAsync(
+            var c = new Domain.Entities.Consultation
-                ClientId,
+            {
-                string.IsNullOrWhiteSpace(newServiceType) ? "기타" : newServiceType,
+                ClientId = ClientId,
-                newDate?.ToUniversalTime() ?? DateTime.UtcNow,
+                ConsultationDate = newDate?.ToUniversalTime() ?? DateTime.UtcNow,
-                newSummary,
+                ServiceType = string.IsNullOrWhiteSpace(newServiceType) ? null : newServiceType,
-                null,
+                Summary = newSummary,
-                null);
+                Result = string.IsNullOrWhiteSpace(newResult) ? null : newResult,
-
+                Fee = newFee
-            if (newId <= 0)
+            };
-                throw new Exception("상담 생성 실패");
+            await ConsultationService.CreateAsync(c);
-
             showAddForm = false;
-            await LoadAll();
+            consultations = (await ConsultationService.GetByClientIdAsync(ClientId)).ToList();
             Snackbar.Add("상담이 추가되었습니다.", Severity.Success);
         }
         catch (ValidationException ex)
         {
             Snackbar.Add(ex.Message, Severity.Error);
         }
-        catch (Exception ex)
-        {
-            Snackbar.Add(ex.Message, Severity.Error);
-        }
     }
 
     private async Task DeleteConsultation(int id)
     {
-        await ConsultingClient.DeleteAsync(id);
+        await ConsultationService.DeleteAsync(id);
-        await LoadAll();
+        consultations = (await ConsultationService.GetByClientIdAsync(ClientId)).ToList();
         Snackbar.Add("삭제되었습니다.", Severity.Info);
     }
 }

TaxBaik.Web/Components/Admin/Pages/Clients/ClientEdit.razor

@@ -4,7 +4,6 @@
 @using TaxBaik.Application.DTOs
 @using TaxBaik.Web.Services
 @using TaxBaik.Domain.Entities
-@using TaxBaik.Web.Components.Admin.Shared
 @inject IClientBrowserClient ClientClient
 @inject NavigationManager Navigation
 @inject ISnackbar Snackbar
@@ -55,10 +54,20 @@
                     <MudDivider />
                 </MudItem>
                 <MudItem xs="12" md="6">
-                    <CommonCodeSelect @bind-Value="dto.ServiceType" Group="CLIENT_SERVICE_TYPE" Label="서비스 유형" Clearable="true" />
+                    <MudSelect @bind-Value="dto.ServiceType" Label="서비스 유형" T="string" Clearable="true">
+                        @foreach (var t in ClientService.ServiceTypes)
+                        {
+                            <MudSelectItem Value="@t">@t</MudSelectItem>
+                        }
+                    </MudSelect>
                 </MudItem>
                 <MudItem xs="12" md="6">
-                    <CommonCodeSelect @bind-Value="dto.TaxType" Group="CLIENT_TAX_TYPE" Label="세금 유형" Clearable="true" />
+                    <MudSelect @bind-Value="dto.TaxType" Label="세금 유형" T="string" Clearable="true">
+                        @foreach (var t in ClientService.TaxTypes)
+                        {
+                            <MudSelectItem Value="@t">@t</MudSelectItem>
+                        }
+                    </MudSelect>
                 </MudItem>
 
                 @* 관리 정보 *@
@@ -67,10 +76,18 @@
                     <MudDivider />
                 </MudItem>
                 <MudItem xs="12" md="6">
-                    <CommonCodeSelect @bind-Value="dto.Status" Group="CLIENT_STATUS" Label="상태 *" Required="true" />
+                    <MudSelect @bind-Value="dto.Status" Label="상태 *" T="string" Required="true">
+                        <MudSelectItem Value="@("active")">활성</MudSelectItem>
+                        <MudSelectItem Value="@("inactive")">비활성</MudSelectItem>
+                    </MudSelect>
                 </MudItem>
                 <MudItem xs="12" md="6">
-                    <CommonCodeSelect @bind-Value="dto.Source" Group="CLIENT_SOURCE" Label="유입 경로" Clearable="true" />
+                    <MudSelect @bind-Value="dto.Source" Label="유입 경로" T="string" Clearable="true">
+                        @foreach (var s in ClientService.Sources)
+                        {
+                            <MudSelectItem Value="@s">@s</MudSelectItem>
+                        }
+                    </MudSelect>
                 </MudItem>
                 <MudItem xs="12">
                     <MudTextField @bind-Value="dto.Memo" Label="메모"
@@ -102,6 +119,7 @@
     private bool isValid;
     private bool isLoading = true;
     private bool isSaving;
+
     protected override async Task OnInitializedAsync()
     {
         if (Id.HasValue)

TaxBaik.Web/Components/Admin/Pages/Clients/ClientList.razor

@@ -9,15 +9,18 @@
 
 <PageTitle>고객 관리</PageTitle>
 
-<AdminPageHeader Title="고객 관리" Eyebrow="CRM" Subtitle="고객 카드를 등록하고 상담 이력을 관리합니다.">
+<section class="admin-page-hero">
-    <ChildContent>
+    <div>
-        <MudButton Variant="Variant.Filled" Color="Color.Primary"
+        <MudText Typo="Typo.caption" Class="admin-eyebrow">CRM</MudText>
-                   StartIcon="@Icons.Material.Filled.PersonAdd"
+        <MudText Typo="Typo.h4" Class="admin-page-title">고객 관리</MudText>
-                   Href="/taxbaik/admin/clients/create">
+        <MudText Typo="Typo.body2" Class="admin-page-subtitle">고객 카드를 등록하고 상담 이력을 관리합니다.</MudText>
-            고객 등록
+    </div>
-        </MudButton>
+    <MudButton Variant="Variant.Filled" Color="Color.Primary"
-    </ChildContent>
+               StartIcon="@Icons.Material.Filled.PersonAdd"
-</AdminPageHeader>
+               Href="/taxbaik/admin/clients/create">
+        고객 등록
+    </MudButton>
+</section>
 
 @* 검색/필터 바 *@
 <MudPaper Class="admin-surface mb-3 pa-3" Elevation="0">
@@ -28,7 +31,11 @@
                           Immediate="false" OnKeyUp="@OnSearchKeyUp" />
         </MudItem>
         <MudItem xs="12" md="3">
-            <CommonCodeSelect @bind-Value="statusFilter" Group="CLIENT_STATUS" Label="상태" Placeholder="전체" Clearable="true" />
+            <MudSelect @bind-Value="statusFilter" Label="상태" T="string">
+                <MudSelectItem Value="@("")">전체</MudSelectItem>
+                <MudSelectItem Value="@("active")">활성</MudSelectItem>
+                <MudSelectItem Value="@("inactive")">비활성</MudSelectItem>
+            </MudSelect>
         </MudItem>
         <MudItem xs="12" md="2" Class="d-flex align-center">
             <MudButton Variant="Variant.Outlined" OnClick="@SearchAsync" FullWidth="true">검색</MudButton>
@@ -46,7 +53,10 @@
     }
     else if (!clients.Any())
     {
-        <AdminEmptyState Icon="@Icons.Material.Filled.PeopleAlt" Message="등록된 고객이 없습니다." />
+        <div class="pa-6 text-center">
+            <MudIcon Icon="@Icons.Material.Filled.PeopleAlt" Style="font-size:3rem; opacity:.3;" />
+            <MudText Class="mt-2 text-muted">등록된 고객이 없습니다.</MudText>
+        </div>
     }
     else
     {
@@ -119,9 +129,6 @@
 </MudPaper>
 
 @code {
-    [CascadingParameter]
-    private Task<AuthenticationState>? AuthStateTask { get; set; }
-
     private List<Client>? clients;
     private string searchText = "";
     private string statusFilter = "";
@@ -130,17 +137,7 @@
     private int totalPages;
     private const int PageSize = 20;
 
-    protected override async Task OnInitializedAsync()
+    protected override async Task OnInitializedAsync() => await LoadAsync();
-    {
-        if (AuthStateTask != null)
-        {
-            var authState = await AuthStateTask;
-            if (authState.User.Identity?.IsAuthenticated == true)
-            {
-                await LoadAsync();
-            }
-        }
-    }
 
     private async Task LoadAsync()
     {

TaxBaik.Web/Components/Admin/Pages/CommonCodes.razor

@@ -1,177 +0,0 @@
-@page "/admin/common-codes"
-@using TaxBaik.Web.Services.AdminClients
-@using TaxBaik.Domain.Entities
-@attribute [Authorize]
-@inject ICommonCodeBrowserClient CommonCodeClient
-@inject ISnackbar Snackbar
-
-<PageTitle>공통관리</PageTitle>
-
-<section class="admin-page-hero">
-    <div>
-        <MudText Typo="Typo.caption" Class="admin-eyebrow">System</MudText>
-        <MudText Typo="Typo.h4" Class="admin-page-title">공통관리</MudText>
-        <MudText Typo="Typo.body2" Class="admin-page-subtitle">공통코드 그룹과 항목을 일관된 기준으로 관리합니다.</MudText>
-    </div>
-</section>
-
-<MudGrid Spacing="2">
-    <MudItem XS="12" MD="4">
-        <MudPaper Class="admin-surface pa-4" Elevation="0">
-            <MudText Typo="Typo.h6" Class="mb-3">그룹</MudText>
-            <MudSelect T="string" Value="@selectedGroup" ValueChanged="OnGroupChanged" Label="코드 그룹" Variant="Variant.Outlined" FullWidth="true">
-                @foreach (var group in groups)
-                {
-                    <MudSelectItem Value="@group">@group</MudSelectItem>
-                }
-            </MudSelect>
-            <MudButton Class="mt-3" Variant="Variant.Filled" Color="Color.Primary" OnClick="PrepareCreate">새 코드 추가</MudButton>
-        </MudPaper>
-    </MudItem>
-
-    <MudItem XS="12" MD="8">
-        <MudPaper Class="admin-surface pa-4" Elevation="0">
-            @if (isLoading)
-            {
-                <MudProgressLinear Indeterminate="true" />
-            }
-            else
-            {
-                <MudTable Items="@codes" Dense="true" Hover="true">
-                    <HeaderContent>
-                        <MudTh>그룹</MudTh>
-                        <MudTh>값</MudTh>
-                        <MudTh>이름</MudTh>
-                        <MudTh>순서</MudTh>
-                        <MudTh>상태</MudTh>
-                        <MudTh>작업</MudTh>
-                    </HeaderContent>
-                    <RowTemplate>
-                        <MudTd>@context.CodeGroup</MudTd>
-                        <MudTd>@context.CodeValue</MudTd>
-                        <MudTd>@context.CodeName</MudTd>
-                        <MudTd>@context.SortOrder</MudTd>
-                        <MudTd>@(context.IsActive ? "활성" : "비활성")</MudTd>
-                        <MudTd>
-                            <MudButton Size="Size.Small" Variant="Variant.Text" OnClick="@(() => EditCode(context))">수정</MudButton>
-                            <MudButton Size="Size.Small" Variant="Variant.Text" Color="Color.Error" OnClick="@(() => DeleteCode(context))">삭제</MudButton>
-                        </MudTd>
-                    </RowTemplate>
-                </MudTable>
-
-                <MudDivider Class="my-4" />
-
-                <MudForm @ref="form">
-                    <MudTextField @bind-Value="editModel.CodeGroup" Label="그룹" Variant="Variant.Outlined" FullWidth="true" Required="true" Disabled="@(!isCreateMode)" Class="mb-3" />
-                    <MudTextField @bind-Value="editModel.CodeValue" Label="값" Variant="Variant.Outlined" FullWidth="true" Required="true" Disabled="@(!isCreateMode)" Class="mb-3" />
-                    <MudTextField @bind-Value="editModel.CodeName" Label="이름" Variant="Variant.Outlined" FullWidth="true" Required="true" Class="mb-3" />
-                    <MudNumericField T="int" @bind-Value="editModel.SortOrder" Label="순서" Variant="Variant.Outlined" FullWidth="true" Class="mb-3" />
-                    <MudSwitch @bind-Checked="editModel.IsActive" Color="Color.Primary">활성</MudSwitch>
-                    <div class="d-flex gap-2 mt-4">
-                        <MudButton Variant="Variant.Filled" Color="Color.Primary" OnClick="SaveCode">저장</MudButton>
-                        <MudButton Variant="Variant.Outlined" OnClick="PrepareCreate">초기화</MudButton>
-                    </div>
-                </MudForm>
-            }
-        </MudPaper>
-    </MudItem>
-</MudGrid>
-
-@code {
-    private List<string> groups = [];
-    private List<CommonCode> codes = [];
-    private string selectedGroup = "";
-    private bool isLoading = true;
-    private MudForm? form;
-    private CommonCode editModel = new();
-    private bool isCreateMode = true;
-
-    protected override async Task OnInitializedAsync()
-    {
-        groups = await CommonCodeClient.GetGroupsAsync();
-        selectedGroup = groups.FirstOrDefault() ?? "";
-        await LoadCodes();
-        PrepareCreate();
-    }
-
-    private async Task OnGroupChanged(string value)
-    {
-        selectedGroup = value;
-        await LoadCodes();
-        PrepareCreate();
-    }
-
-    private async Task LoadCodes()
-    {
-        isLoading = true;
-        codes = string.IsNullOrWhiteSpace(selectedGroup)
-            ? []
-            : await CommonCodeClient.GetByGroupAsync(selectedGroup);
-        isLoading = false;
-    }
-
-    private void PrepareCreate()
-    {
-        isCreateMode = true;
-        editModel = new CommonCode
-        {
-            CodeGroup = selectedGroup,
-            IsActive = true
-        };
-    }
-
-    private void EditCode(CommonCode code)
-    {
-        isCreateMode = false;
-        editModel = new CommonCode
-        {
-            CodeGroup = code.CodeGroup,
-            CodeValue = code.CodeValue,
-            CodeName = code.CodeName,
-            SortOrder = code.SortOrder,
-            IsActive = code.IsActive
-        };
-    }
-
-    private async Task SaveCode()
-    {
-        if (form != null)
-        {
-            await form.Validate();
-            if (!form.IsValid)
-            {
-                Snackbar.Add("필수 항목을 입력하세요.", Severity.Warning);
-                return;
-            }
-        }
-
-        if (editModel.CodeValue.Contains(' '))
-        {
-            Snackbar.Add("code_value에는 공백을 넣을 수 없습니다.", Severity.Error);
-            return;
-        }
-
-        if (!await CommonCodeClient.UpsertAsync(editModel))
-        {
-            Snackbar.Add("저장 실패", Severity.Error);
-            return;
-        }
-
-        Snackbar.Add("저장되었습니다.", Severity.Success);
-        await LoadCodes();
-        PrepareCreate();
-    }
-
-    private async Task DeleteCode(CommonCode code)
-    {
-        if (!await CommonCodeClient.DeleteAsync(code.CodeGroup, code.CodeValue))
-        {
-            Snackbar.Add("삭제 실패", Severity.Error);
-            return;
-        }
-
-        Snackbar.Add("삭제되었습니다.", Severity.Success);
-        await LoadCodes();
-        PrepareCreate();
-    }
-}

TaxBaik.Web/Components/Admin/Pages/ConsultingActivities.razor

@@ -1,6 +1,5 @@
 @page "/admin/consulting-activities"
 @using TaxBaik.Web.Services.AdminClients
-@using TaxBaik.Web.Components.Admin.Shared
 @inject IConsultingActivityBrowserClient ActivityClient
 @inject IClientBrowserClient ClientClient
 @inject ISnackbar Snackbar
@@ -101,10 +100,10 @@
             <MudSelect T="int" @bind-Value="activityForm.ClientId" Label="고객" Required="true" Variant="Variant.Outlined" FullWidth="true" Class="mb-4">
                 @foreach (var client in clients)
                 {
-                    <MudSelectItem Value="@client.Id">@GetClientDisplayName(client)</MudSelectItem>
+                    <MudSelectItem Value="@client.Id">@client.CompanyName</MudSelectItem>
                 }
             </MudSelect>
-            <CommonCodeSelect @bind-Value="activityForm.ActivityType" Group="CONSULTING_ACTIVITY_TYPE" Label="활동 유형" Class="mb-4" Required="true" />
+            <MudTextField T="string" @bind-Value="activityForm.ActivityType" Label="활동 유형" Variant="Variant.Outlined" FullWidth="true" Class="mb-4" Required="true" />
             <MudDatePicker @bind-Date="activityForm.ActivityDate" Label="활동일" Variant="Variant.Outlined" FullWidth="true" Class="mb-4" Required="true" />
             <MudTextField T="string" @bind-Value="activityForm.Description" Label="설명" Variant="Variant.Outlined" FullWidth="true" Lines="3" Class="mb-4" Required="true" />
             <MudDatePicker @bind-Date="activityForm.NextFollowupDate" Label="다음 팔로업일" Variant="Variant.Outlined" FullWidth="true" Class="mb-4" />
@@ -117,9 +116,6 @@
 </MudDialog>
 
 @code {
-    [CascadingParameter]
-    private Task<AuthenticationState>? AuthStateTask { get; set; }
-
     private List<ConsultingActivity>? activities;
     private List<Client> clients = [];
     private Dictionary<int, string> clientMap = new();
@@ -130,14 +126,7 @@
 
     protected override async Task OnInitializedAsync()
     {
-        if (AuthStateTask != null)
+        await LoadData();
-        {
-            var authState = await AuthStateTask;
-            if (authState.User.Identity?.IsAuthenticated == true)
-            {
-                await LoadData();
-            }
-        }
     }
 
     private async Task LoadData()
@@ -145,9 +134,9 @@
         try
         {
             activities = await ActivityClient.GetAllAsync();
-            var (clientItems, _) = await ClientClient.GetPagedAsync(pageSize: 1000);
+            var (clientItems, _) = await ClientClient.GetPagedAsync();
             clients = clientItems.ToList();
-            clientMap = clients.ToDictionary(c => c.Id, GetClientDisplayName);
+            clientMap = clients.ToDictionary(c => c.Id, c => c.CompanyName ?? "");
         }
         catch (Exception ex)
         {
@@ -158,11 +147,7 @@
     private void OpenCreateDialog()
     {
         editingActivity = null;
-        activityForm = new ConsultingActivityForm
+        activityForm = new ConsultingActivityForm { ActivityDate = DateTime.Now };
-        {
-            ActivityDate = DateTime.Now,
-            ClientId = clients.FirstOrDefault()?.Id ?? 0
-        };
         isDialogOpen = true;
     }
 
@@ -182,16 +167,6 @@
 
     private async Task SaveActivity()
     {
-        if (form != null)
-        {
-            await form.Validate();
-            if (!form.IsValid)
-            {
-                Snackbar.Add("필수 항목을 입력해주세요.", Severity.Warning);
-                return;
-            }
-        }
-
         try
         {
             if (editingActivity == null)
@@ -263,12 +238,6 @@
         activityForm = new();
     }
 
-    private static string GetClientDisplayName(Client client)
-        => !string.IsNullOrWhiteSpace(client.CompanyName)
-            ? client.CompanyName
-            : !string.IsNullOrWhiteSpace(client.Name)
-                ? client.Name
-                : $"Client #{client.Id}";
     private class ConsultingActivityForm
     {
         public int ClientId { get; set; }

TaxBaik.Web/Components/Admin/Pages/Contracts.razor

@@ -1,6 +1,5 @@
 @page "/admin/contracts"
 @using TaxBaik.Web.Services.AdminClients
-@using TaxBaik.Web.Components.Admin.Shared
 @inject IContractBrowserClient ContractClient
 @inject IClientBrowserClient ClientClient
 @inject ISnackbar Snackbar
@@ -22,151 +21,122 @@
             </MudText>
         }
     </div>
-    <MudButton Variant="Variant.Filled" Color="Color.Primary" OnClick="PrepareCreate" StartIcon="@Icons.Material.Filled.Add" id="btn-add-contract">
+    <MudButton Variant="Variant.Filled" Color="Color.Primary" OnClick="OpenCreateDialog" StartIcon="@Icons.Material.Filled.Add">
         새 계약 추가
     </MudButton>
 </section>
 
-@if (contracts is null)
+<MudPaper Class="admin-surface" Elevation="0">
-{
+    @if (contracts is null)
-    <MudProgressLinear Indeterminate="true" />
+    {
-}
+        <MudProgressLinear Indeterminate="true" />
-else
+    }
-{
+    else if (contracts.Count == 0)
-    <MudGrid Spacing="2" Class="mt-2">
+    {
-        <!-- Left: Dense Grid List -->
+        <MudAlert Severity="Severity.Info" Class="mt-4">
-        <MudItem XS="12" MD="8">
+            <MudIcon Icon="@Icons.Material.Filled.Description" Class="me-2" />
-            @if (contracts.Count == 0)
+            계약이 없습니다.
-            {
+        </MudAlert>
-                <MudAlert Severity="Severity.Info">
+    }
-                    <MudIcon Icon="@Icons.Material.Filled.Description" Class="me-2" />
+    else
-                    계약이 없습니다.
+    {
-                </MudAlert>
+        <MudDataGrid T="Contract"
-            }
+            Items="@contracts"
-            else
+            Dense="true"
-            {
+            Hover="true"
-                <MudDataGrid T="Contract"
+            Striped="true"
-                    Items="@contracts"
+            Virtualize="true"
-                    Dense="true"
+            RowsPerPage="30"
-                    Hover="true"
+            Class="admin-grid">
-                    Striped="true"
+            <Columns>
-                    Virtualize="true"
+                <PropertyColumn Property="x => x.Id" Title="ID" Sortable="true" />
-                    RowsPerPage="30"
+                <TemplateColumn Title="고객">
-                    SelectedItem="@selectedContract"
+                    <CellTemplate>
-                    SelectedItemChanged="OnRowSelected"
+                        @if (clientMap.TryGetValue(context.Item.ClientId, out var clientName))
-                    Class="admin-grid">
-                    <Columns>
-                        <PropertyColumn Property="x => x.Id" Title="ID" Sortable="true" />
-                        <TemplateColumn Title="고객">
-                            <CellTemplate>
-                                @if (clientMap.TryGetValue(context.Item.ClientId, out var clientName))
-                                {
-                                    @clientName
-                                }
-                            </CellTemplate>
-                        </TemplateColumn>
-                        <PropertyColumn Property="x => x.ContractNumber" Title="계약번호" />
-                        <PropertyColumn Property="x => x.ServiceType" Title="서비스 유형" />
-                        <PropertyColumn Property="x => x.MonthlyFee" Title="월 수수료" Format="C" />
-                        <TemplateColumn Title="계약기간">
-                            <CellTemplate>
-                                @context.Item.StartDate.ToString("yyyy-MM-dd")
-                                @if (context.Item.EndDate.HasValue)
-                                {
-                                    <span>~@context.Item.EndDate.Value.ToString("yyyy-MM-dd")</span>
-                                }
-                            </CellTemplate>
-                        </TemplateColumn>
-                        <TemplateColumn Title="상태">
-                            <CellTemplate>
-                                @{
-                                    var isActive = !context.Item.EndDate.HasValue || context.Item.EndDate.Value >= DateTime.Today;
-                                }
-                                @if (isActive)
-                                {
-                                    <MudChip Size="Size.Small" Color="Color.Success" Variant="Variant.Filled">활성</MudChip>
-                                }
-                                else
-                                {
-                                    <MudChip Size="Size.Small" Color="Color.Default" Variant="Variant.Outlined">만료</MudChip>
-                                }
-                            </CellTemplate>
-                        </TemplateColumn>
-                        <TemplateColumn Title="작업" Sortable="false">
-                            <CellTemplate>
-                                <MudIconButton Icon="@Icons.Material.Filled.Delete" Color="Color.Error" Size="Size.Small"
-                                    OnClick="@(async () => await DeleteContract(context.Item.Id))" />
-                            </CellTemplate>
-                        </TemplateColumn>
-                    </Columns>
-                </MudDataGrid>
-            }
-        </MudItem>
-
-        <!-- Right: Detail Form Panel (Inline Editor) -->
-        <MudItem XS="12" MD="4">
-            <MudPaper Class="pa-4 admin-surface admin-editor-panel" Elevation="0" Style="border: 1px solid var(--border-color); min-height: 400px;">
-                <div class="d-flex align-center justify-space-between mb-4">
-                    <MudText Typo="Typo.h6" Class="font-weight-bold">@(isEditMode ? "계약 상세 정보" : "새 계약 추가")</MudText>
-                    @if (isEditMode)
-                    {
-                        <MudButton Size="Size.Small" Variant="Variant.Outlined" Color="Color.Secondary" OnClick="PrepareCreate">
-                            새로 작성
-                        </MudButton>
-                    }
-                </div>
-                <MudForm @ref="form">
-                    <MudSelect T="int?" @bind-Value="contractForm.ClientId" Label="고객" Required="true" Variant="Variant.Outlined" FullWidth="@true" Class="mb-3" RequiredError="고객을 선택하세요." Disabled="@isEditMode">
-                        @foreach (var client in clients)
                         {
-                            <MudSelectItem Value="@((int?)client.Id)">@GetClientDisplayName(client)</MudSelectItem>
+                            <MudLink Href="@($"/taxbaik/admin/clients/{context.Item.ClientId}")" Color="Color.Primary">
+                                @clientName
+                            </MudLink>
                         }
-                    </MudSelect>
+                    </CellTemplate>
-                    <MudTextField T="string" @bind-Value="contractForm.ContractNumber" Label="계약번호" Variant="Variant.Outlined" FullWidth="@true" Class="mb-3" Required="true" />
+                </TemplateColumn>
-                    <CommonCodeSelect @bind-Value="contractForm.ServiceType" Group="CONTRACT_SERVICE_TYPE" Label="서비스 유형" Class="mb-3" Required="true" />
+                <PropertyColumn Property="x => x.ContractNumber" Title="계약번호" />
-                    <MudDatePicker @bind-Date="contractForm.StartDate" Label="계약 시작일" Variant="Variant.Outlined" FullWidth="@true" Class="mb-3" Required="true" />
+                <PropertyColumn Property="x => x.ServiceType" Title="서비스 유형" />
-                    <MudNumericField T="decimal?" @bind-Value="contractForm.MonthlyFee" Label="월 수수료" Variant="Variant.Outlined" FullWidth="@true" Class="mb-4" />
+                <PropertyColumn Property="x => x.MonthlyFee" Title="월 수수료" Format="C" />
-                    
+                <TemplateColumn Title="계약기간">
-                    <div class="d-flex justify-end gap-2">
+                    <CellTemplate>
-                        @if (isEditMode)
+                        @context.Item.StartDate.ToString("yyyy-MM-dd")
+                        @if (context.Item.EndDate.HasValue)
                         {
-                            <MudButton Variant="Variant.Outlined" Color="Color.Error" OnClick="@(async () => await DeleteContract(selectedContract?.Id ?? 0))">삭제</MudButton>
+                            <span>~@context.Item.EndDate.Value.ToString("yyyy-MM-dd")</span>
+                        }
+                    </CellTemplate>
+                </TemplateColumn>
+                <TemplateColumn Title="상태">
+                    <CellTemplate>
+                        @{
+                            var isActive = !context.Item.EndDate.HasValue || context.Item.EndDate.Value >= DateTime.Today;
+                        }
+                        @if (isActive)
+                        {
+                            <MudChip Size="Size.Small" Color="Color.Success" Variant="Variant.Filled">활성</MudChip>
                         }
                         else
                         {
-                            <MudButton Variant="Variant.Filled" Color="Color.Primary" OnClick="SaveContract" id="btn-save-contract">저장</MudButton>
+                            <MudChip Size="Size.Small" Color="Color.Default" Variant="Variant.Outlined">만료</MudChip>
                         }
-                    </div>
+                    </CellTemplate>
-                </MudForm>
+                </TemplateColumn>
-            </MudPaper>
+                <TemplateColumn Title="작업" Sortable="false">
-        </MudItem>
+                    <CellTemplate>
-    </MudGrid>
+                        <MudButtonGroup Size="Size.Small" Variant="Variant.Outlined">
-}
+                            <MudIconButton Icon="@Icons.Material.Filled.Delete" Color="Color.Error"
+                                OnClick="@(async () => await DeleteContract(context.Item.Id))" />
+                        </MudButtonGroup>
+                    </CellTemplate>
+                </TemplateColumn>
+            </Columns>
+        </MudDataGrid>
+    }
+</MudPaper>
+
+<!-- Create Dialog -->
+<MudDialog @bind-IsVisible="isDialogOpen" Options="new DialogOptions { MaxWidth = MaxWidth.Small, FullWidth = true }">
+    <TitleContent>
+        <MudText Typo="Typo.h6">새 계약 추가</MudText>
+    </TitleContent>
+    <DialogContent>
+        <MudForm @ref="form">
+            <MudSelect T="int" @bind-Value="contractForm.ClientId" Label="고객" Required="true" Variant="Variant.Outlined" FullWidth="true" Class="mb-4">
+                @foreach (var client in clients)
+                {
+                    <MudSelectItem Value="@client.Id">@client.CompanyName</MudSelectItem>
+                }
+            </MudSelect>
+            <MudTextField T="string" @bind-Value="contractForm.ContractNumber" Label="계약번호" Variant="Variant.Outlined" FullWidth="true" Class="mb-4" Required="true" />
+            <MudTextField T="string" @bind-Value="contractForm.ServiceType" Label="서비스 유형" Variant="Variant.Outlined" FullWidth="true" Class="mb-4" Required="true" />
+            <MudDatePicker @bind-Date="contractForm.StartDate" Label="계약 시작일" Variant="Variant.Outlined" FullWidth="true" Class="mb-4" Required="true" />
+            <MudNumericField T="decimal?" @bind-Value="contractForm.MonthlyFee" Label="월 수수료" Variant="Variant.Outlined" FullWidth="true" Class="mb-4" />
+        </MudForm>
+    </DialogContent>
+    <DialogActions>
+        <MudButton OnClick="CloseDialog">취소</MudButton>
+        <MudButton Color="Color.Primary" OnClick="SaveContract">저장</MudButton>
+    </DialogActions>
+</MudDialog>
 
 @code {
-    [CascadingParameter]
-    private Task<AuthenticationState>? AuthStateTask { get; set; }
-
     private List<Contract>? contracts;
     private List<Client> clients = [];
     private Dictionary<int, string> clientMap = new();
     private decimal mrr = 0;
     private MudForm? form;
-    private bool isEditMode;
+    private bool isDialogOpen;
-    private Contract? selectedContract;
     private ContractForm contractForm = new();
 
     protected override async Task OnInitializedAsync()
     {
-        if (AuthStateTask != null)
+        await LoadData();
-        {
-            var authState = await AuthStateTask;
-            if (authState.User.Identity?.IsAuthenticated == true)
-            {
-                await LoadData();
-                PrepareCreate();
-            }
-        }
     }
 
     private async Task LoadData()
@@ -174,9 +144,9 @@ else
         try
         {
             contracts = await ContractClient.GetAllAsync();
-            var (clientItems, _) = await ClientClient.GetPagedAsync(pageSize: 1000);
+            var (clientItems, _) = await ClientClient.GetPagedAsync();
             clients = clientItems.ToList();
-            clientMap = clients.ToDictionary(c => c.Id, GetClientDisplayName);
+            clientMap = clients.ToDictionary(c => c.Id, c => c.CompanyName ?? "");
             mrr = await ContractClient.GetMonthlyRecurringRevenueAsync();
         }
         catch (Exception ex)
@@ -185,49 +155,18 @@ else
         }
     }
 
-    private void PrepareCreate()
+    private void OpenCreateDialog()
     {
-        selectedContract = null;
+        contractForm = new();
-        isEditMode = false;
+        isDialogOpen = true;
-        contractForm = new ContractForm
-        {
-            ClientId = clients.FirstOrDefault()?.Id,
-            StartDate = DateTime.Today
-        };
-    }
-
-    private void OnRowSelected(Contract contract)
-    {
-        if (contract == null) return;
-        selectedContract = contract;
-        isEditMode = true;
-        contractForm = new ContractForm
-        {
-            ClientId = contract.ClientId,
-            ContractNumber = contract.ContractNumber,
-            ServiceType = contract.ServiceType,
-            StartDate = contract.StartDate,
-            MonthlyFee = contract.MonthlyFee
-        };
     }
 
     private async Task SaveContract()
     {
-        if (form != null)
-        {
-            await form.Validate();
-            if (!form.IsValid)
-            {
-                Snackbar.Add("필수 항목을 입력해주세요.", Severity.Warning);
-                return;
-            }
-        }
-
         try
         {
-            if (contractForm.ClientId == null) return;
             var newId = await ContractClient.CreateAsync(
-                contractForm.ClientId.Value,
+                contractForm.ClientId,
                 contractForm.ContractNumber,
                 contractForm.ServiceType,
                 contractForm.StartDate ?? DateTime.Now,
@@ -236,7 +175,7 @@ else
             if (newId > 0)
             {
                 Snackbar.Add("계약이 추가되었습니다.", Severity.Success);
-                PrepareCreate();
+                CloseDialog();
                 await LoadData();
             }
         }
@@ -264,10 +203,6 @@ else
         {
             await ContractClient.DeleteAsync(id);
             Snackbar.Add("계약이 삭제되었습니다.", Severity.Success);
-            if (selectedContract?.Id == id)
-            {
-                PrepareCreate();
-            }
             await LoadData();
         }
         catch (Exception ex)
@@ -276,16 +211,15 @@ else
         }
     }
 
-    private static string GetClientDisplayName(Client client)
+    private void CloseDialog()
-        => !string.IsNullOrWhiteSpace(client.CompanyName)
+    {
-            ? client.CompanyName
+        isDialogOpen = false;
-            : !string.IsNullOrWhiteSpace(client.Name)
+        contractForm = new();
-                ? client.Name
+    }
-                : $"Client #{client.Id}";
 
     private class ContractForm
     {
-        public int? ClientId { get; set; }
+        public int ClientId { get; set; }
         public string ContractNumber { get; set; } = "";
         public string ServiceType { get; set; } = "";
         public DateTime? StartDate { get; set; }

TaxBaik.Web/Components/Admin/Pages/Dashboard.razor

@@ -1,7 +1,6 @@
 @page "/admin/dashboard"
 @attribute [Authorize]
 @using TaxBaik.Web.Services
-@using TaxBaik.Web.Components.Admin.Shared
 @inject IAdminDashboardClient DashboardClient
 @inject NavigationManager Nav
 
@@ -18,58 +17,49 @@
     </MudButton>
 </section>
 
-@if (!string.IsNullOrEmpty(errorMessage))
+<!-- Metrics Grid - Pure HTML div instead of MudGrid to ensure proper layout -->
-{
-    <MudAlert Severity="Severity.Error" Class="mb-4">@errorMessage</MudAlert>
-}
-@if (isLoading)
-{
-    <MudProgressLinear Color="Color.Primary" Indeterminate="true" Class="mb-4" />
-}
-
-<!-- Metrics Grid -->
 <div class="admin-metric-grid">
-    <div class="admin-metric-card accent-blue cursor-pointer" @onclick='(() => Nav.NavigateTo("/taxbaik/admin/inquiries"))'>
+    <div class="admin-metric-card accent-blue cursor-pointer" @onclick='(() => Nav.NavigateTo("/taxbaik/admin/inquiries"))' style="cursor: pointer;">
-        <div class="admin-metric-card-body">
+        <div style="display: flex; flex-direction: column; gap: 12px; height: 100%;">
-            <span class="admin-metric-card-label">이번달 문의</span>
+            <span style="font-size: 0.75rem; color: #999; text-transform: uppercase; font-weight: 600;">이번달 문의</span>
-            <div class="admin-metric-card-value-row">
+            <div style="display: flex; justify-content: space-between; align-items: center; flex: 1;">
-                <span class="admin-metric-card-value" style="color: var(--primary-dark);">@summary.ThisMonthInquiries</span>
+                <span style="font-size: 2rem; font-weight: 700; color: #1565c0;">@summary.ThisMonthInquiries</span>
-                <span class="admin-metric-card-icon" style="color: var(--primary-color);">💬</span>
+                <span style="font-size: 2.5rem; opacity: 0.15; color: #1976d2;">💬</span>
             </div>
-            <span class="admin-metric-card-caption">월간 상담 유입 (클릭 시 이동)</span>
+            <span style="font-size: 0.9rem; color: #666;">월간 상담 유입 (클릭 시 이동)</span>
         </div>
     </div>
 
-    <div class="admin-metric-card accent-amber cursor-pointer" @onclick='(() => Nav.NavigateTo("/taxbaik/admin/inquiries?status=new"))'>
+    <div class="admin-metric-card accent-amber cursor-pointer" @onclick='(() => Nav.NavigateTo("/taxbaik/admin/inquiries?status=new"))' style="cursor: pointer;">
-        <div class="admin-metric-card-body">
+        <div style="display: flex; flex-direction: column; gap: 12px; height: 100%;">
-            <span class="admin-metric-card-label">신규 문의</span>
+            <span style="font-size: 0.75rem; color: #999; text-transform: uppercase; font-weight: 600;">신규 문의</span>
-            <div class="admin-metric-card-value-row">
+            <div style="display: flex; justify-content: space-between; align-items: center; flex: 1;">
-                <span class="admin-metric-card-value" style="color: var(--tertiary-dark);">@summary.NewInquiries</span>
+                <span style="font-size: 2rem; font-weight: 700; color: #e65100;">@summary.NewInquiries</span>
-                <span class="admin-metric-card-icon" style="color: var(--tertiary-color);">⚠️</span>
+                <span style="font-size: 2.5rem; opacity: 0.15; color: #f57c00;">⚠️</span>
             </div>
-            <span class="admin-metric-card-caption">처리 대기 (클릭 시 이동)</span>
+            <span style="font-size: 0.9rem; color: #666;">처리 대기 (클릭 시 이동)</span>
         </div>
     </div>
 
-    <div class="admin-metric-card accent-slate cursor-pointer" @onclick='(() => Nav.NavigateTo("/taxbaik/admin/blog"))'>
+    <div class="admin-metric-card accent-slate cursor-pointer" @onclick='(() => Nav.NavigateTo("/taxbaik/admin/blog"))' style="cursor: pointer;">
-        <div class="admin-metric-card-body">
+        <div style="display: flex; flex-direction: column; gap: 12px; height: 100%;">
-            <span class="admin-metric-card-label">전체 포스트</span>
+            <span style="font-size: 0.75rem; color: #999; text-transform: uppercase; font-weight: 600;">전체 포스트</span>
-            <div class="admin-metric-card-value-row">
+            <div style="display: flex; justify-content: space-between; align-items: center; flex: 1;">
-                <span class="admin-metric-card-value" style="color: #455a64;">@summary.TotalPosts</span>
+                <span style="font-size: 2rem; font-weight: 700; color: #455a64;">@summary.TotalPosts</span>
-                <span class="admin-metric-card-icon" style="color: #607d8b;">📄</span>
+                <span style="font-size: 2.5rem; opacity: 0.15; color: #607d8b;">📄</span>
             </div>
-            <span class="admin-metric-card-caption">콘텐츠 자산 (클릭 시 이동)</span>
+            <span style="font-size: 0.9rem; color: #666;">콘텐츠 자산 (클릭 시 이동)</span>
         </div>
     </div>
 
-    <div class="admin-metric-card accent-green cursor-pointer" @onclick='(() => Nav.NavigateTo("/taxbaik/admin/blog"))'>
+    <div class="admin-metric-card accent-green cursor-pointer" @onclick='(() => Nav.NavigateTo("/taxbaik/admin/blog"))' style="cursor: pointer;">
-        <div class="admin-metric-card-body">
+        <div style="display: flex; flex-direction: column; gap: 12px; height: 100%;">
-            <span class="admin-metric-card-label">발행된 포스트</span>
+            <span style="font-size: 0.75rem; color: #999; text-transform: uppercase; font-weight: 600;">발행된 포스트</span>
-            <div class="admin-metric-card-value-row">
+            <div style="display: flex; justify-content: space-between; align-items: center; flex: 1;">
-                <span class="admin-metric-card-value" style="color: var(--secondary-dark);">@summary.PublishedPosts</span>
+                <span style="font-size: 2rem; font-weight: 700; color: #2e7d32;">@summary.PublishedPosts</span>
-                <span class="admin-metric-card-icon" style="color: var(--secondary-color);">🌐</span>
+                <span style="font-size: 2.5rem; opacity: 0.15; color: #388e3c;">🌐</span>
             </div>
-            <span class="admin-metric-card-caption">검색 노출 대상 (클릭 시 이동)</span>
+            <span style="font-size: 0.9rem; color: #666;">검색 노출 대상 (클릭 시 이동)</span>
         </div>
     </div>
 </div>
@@ -96,8 +86,7 @@
             <tbody>
                 @foreach (var f in upcomingFilings)
                 {
-                    var dday = BusinessDayCalculator.GetDday(DateOnly.FromDateTime(f.DueDate));
+                    var dday = (f.DueDate.Date - DateTime.Today).Days;
-                    var effectiveDueDate = BusinessDayCalculator.GetEffectiveDueDate(DateOnly.FromDateTime(f.DueDate));
                     <tr>
                         <td>
                             <MudLink Href="@($"/taxbaik/admin/clients/{f.ClientId}")" Underline="Underline.Hover" Color="Color.Primary" Class="font-weight-bold">
@@ -105,7 +94,7 @@
                             </MudLink>
                         </td>
                         <td>@f.FilingType</td>
-                        <td>@effectiveDueDate.ToDateTime(TimeOnly.MinValue).ToString("yyyy-MM-dd")</td>
+                        <td>@f.DueDate.ToString("yyyy-MM-dd")</td>
                         <td>
                             @if (dday < 0)
                             {
@@ -169,9 +158,6 @@
 </MudPaper>
 
 @code {
-    [CascadingParameter]
-    private Task<AuthenticationState>? AuthStateTask { get; set; }
-
     private AdminDashboardSummary summary = new(0, 0, 0, 0, []);
     private List<Domain.Entities.TaxFiling> upcomingFilings = [];
     private string? errorMessage;
@@ -179,30 +165,24 @@
 
     protected override async Task OnInitializedAsync()
     {
-        if (AuthStateTask != null)
+        try
         {
-            var authState = await AuthStateTask;
+            // API 클라이언트 사용 (서비스 직접 호출 X)
-            if (authState.User.Identity?.IsAuthenticated == true)
+            var summaryTask = DashboardClient.GetSummaryAsync();
-            {
+            var filingsTask = DashboardClient.GetUpcomingFilingsAsync(30);
-                try
-                {
-                    var summaryTask = DashboardClient.GetSummaryAsync();
-                    var filingsTask = DashboardClient.GetUpcomingFilingsAsync(30);
 
-                    await Task.WhenAll(summaryTask, filingsTask);
+            await Task.WhenAll(summaryTask, filingsTask);
-                    summary = await summaryTask;
+            summary = await summaryTask;
-                    upcomingFilings = (await filingsTask).ToList();
+            upcomingFilings = (await filingsTask).ToList();
-                }
+        }
-                catch (Exception ex)
+        catch (Exception ex)
-                {
+        {
-                    errorMessage = "대시보드 데이터를 불러올 수 없습니다.";
+            errorMessage = "대시보드 데이터를 불러올 수 없습니다.";
-                    Console.Error.WriteLine($"Dashboard error: {ex.Message}");
+            Console.Error.WriteLine($"Dashboard error: {ex.Message}");
-                }
+        }
-                finally
+        finally
-                {
+        {
-                    isLoading = false;
+            isLoading = false;
-                }
-            }
         }
     }
 

TaxBaik.Web/Components/Admin/Pages/Faqs/FaqList.razor

@@ -22,21 +22,16 @@
     </MudButton>
 </section>
 
-<div class="d-flex pa-4 gap-4 align-center">
-    <MudTextField @bind-Value="searchQuery" Placeholder="질문 또는 답변 검색..." Adornment="Adornment.Start" 
-                  AdornmentIcon="@Icons.Material.Filled.Search" IconSize="Size.Medium" Class="flex-grow-1" Immediate="true" Clearable="true" />
-</div>
-
 <MudPaper Class="admin-surface" Elevation="0">
     @if (faqs is null)
     {
         <MudProgressLinear Indeterminate="true" />
     }
-    else if (!FilteredFaqs.Any())
+    else if (!faqs.Any())
     {
         <div class="pa-6 text-center">
             <MudIcon Icon="@Icons.Material.Filled.QuestionAnswer" Style="font-size:3rem; opacity:.3;" />
-            <MudText Class="mt-2 text-muted">검색 조건에 맞는 FAQ가 없습니다.</MudText>
+            <MudText Class="mt-2 text-muted">등록된 FAQ가 없습니다.</MudText>
         </div>
     }
     else
@@ -44,7 +39,7 @@
         <MudSimpleTable Striped="true" Dense="true" Class="admin-table">
             <thead>
                 <tr>
-                    <th style="width:110px;">순서</th>
+                    <th style="width:60px;">순서</th>
                     <th>질문</th>
                     <th style="width:130px;">카테고리</th>
                     <th style="width:90px;">상태</th>
@@ -52,15 +47,11 @@
                 </tr>
             </thead>
             <tbody>
-                @foreach (var item in FilteredFaqs)
+                @foreach (var item in faqs)
                 {
                     <tr>
-                        <td>
+                        <td class="text-center">
-                            <div class="d-flex align-center justify-start gap-1">
+                            <MudText Typo="Typo.body2">@item.SortOrder</MudText>
-                                <MudText Typo="Typo.body2" Class="mr-2">@item.SortOrder</MudText>
-                                <MudIconButton Icon="@Icons.Material.Filled.ArrowDropUp" Size="Size.Small" OnClick="@(() => MoveUpAsync(item))" Style="padding:2px;" Dense="true" />
-                                <MudIconButton Icon="@Icons.Material.Filled.ArrowDropDown" Size="Size.Small" OnClick="@(() => MoveDownAsync(item))" Style="padding:2px;" Dense="true" />
-                            </div>
                         </td>
                         <td>
                             <MudText Typo="Typo.body2" Style="max-width:480px; white-space:nowrap; overflow:hidden; text-overflow:ellipsis;">
@@ -86,10 +77,10 @@
                         <td>
                             <MudButtonGroup Size="Size.Small" Variant="Variant.Outlined">
                                 <MudButton @onclick="@(() => Navigation.NavigateTo($"/taxbaik/admin/faqs/{item.Id}/edit"))">
-                                     수정
+                                    수정
                                 </MudButton>
                                 <MudButton Color="Color.Error" @onclick="@(() => DeleteAsync(item))">
-                                     삭제
+                                    삭제
                                 </MudButton>
                             </MudButtonGroup>
                         </td>
@@ -98,41 +89,21 @@
             </tbody>
         </MudSimpleTable>
         <MudText Typo="Typo.caption" Class="pa-2 text-muted">
-            검색 결과 @(FilteredFaqs.Count())개 · 총 @(faqs.Count)개 · 노출 중 @(faqs.Count(f => f.IsActive))개
+            총 @(faqs.Count)개 · 노출 중 @(faqs.Count(f => f.IsActive))개
         </MudText>
     }
 </MudPaper>
 
 @code {
-    [CascadingParameter]
-    private Task<AuthenticationState>? AuthStateTask { get; set; }
-
     private List<Faq>? faqs;
-    private string searchQuery = "";
 
-    private IEnumerable<Faq> FilteredFaqs => faqs?
+    protected override async Task OnInitializedAsync() => await LoadAsync();
-        .Where(f => string.IsNullOrEmpty(searchQuery) || 
-                    f.Question.Contains(searchQuery, StringComparison.OrdinalIgnoreCase) || 
-                    (f.Answer != null && f.Answer.Contains(searchQuery, StringComparison.OrdinalIgnoreCase)))
-        .OrderBy(f => f.SortOrder) ?? Enumerable.Empty<Faq>();
-
-    protected override async Task OnInitializedAsync()
-    {
-        if (AuthStateTask != null)
-        {
-            var authState = await AuthStateTask;
-            if (authState.User.Identity?.IsAuthenticated == true)
-            {
-                await LoadAsync();
-            }
-        }
-    }
 
     private async Task LoadAsync()
     {
         try
         {
-            faqs = (await FaqClient.GetAllAsync()).OrderBy(f => f.SortOrder).ToList();
+            faqs = (await FaqClient.GetAllAsync()).ToList();
         }
         catch (Exception ex)
         {
@@ -141,66 +112,6 @@
         }
     }
 
-    private async Task MoveUpAsync(Faq item)
-    {
-        if (faqs == null) return;
-        var sorted = faqs.OrderBy(f => f.SortOrder).ToList();
-        var index = sorted.IndexOf(item);
-        if (index <= 0) return;
-
-        var prev = sorted[index - 1];
-        var temp = item.SortOrder;
-        item.SortOrder = prev.SortOrder;
-        prev.SortOrder = temp;
-
-        if (item.SortOrder == prev.SortOrder)
-        {
-            prev.SortOrder = item.SortOrder + 1;
-        }
-
-        try
-        {
-            await FaqClient.UpdateAsync(item.Id, item);
-            await FaqClient.UpdateAsync(prev.Id, prev);
-            Snackbar.Add("순서가 상향되었습니다.", Severity.Success);
-            await LoadAsync();
-        }
-        catch (Exception ex)
-        {
-            Snackbar.Add($"순서 조정 실패: {ex.Message}", Severity.Error);
-        }
-    }
-
-    private async Task MoveDownAsync(Faq item)
-    {
-        if (faqs == null) return;
-        var sorted = faqs.OrderBy(f => f.SortOrder).ToList();
-        var index = sorted.IndexOf(item);
-        if (index < 0 || index >= sorted.Count - 1) return;
-
-        var next = sorted[index + 1];
-        var temp = item.SortOrder;
-        item.SortOrder = next.SortOrder;
-        next.SortOrder = temp;
-
-        if (item.SortOrder == next.SortOrder)
-        {
-            next.SortOrder = item.SortOrder + 1;
-        }
-
-        try
-        {
-            await FaqClient.UpdateAsync(item.Id, item);
-            await FaqClient.UpdateAsync(next.Id, next);
-            Snackbar.Add("순서가 하향되었습니다.", Severity.Success);
-            await LoadAsync();
-        }
-        catch (Exception ex)
-        {
-            Snackbar.Add($"순서 조정 실패: {ex.Message}", Severity.Error);
-        }
-    }
-
     private async Task DeleteAsync(Faq item)
     {
         var confirmed = await DialogService.ShowMessageBox(

TaxBaik.Web/Components/Admin/Pages/Inquiries/InquiryCreate.razor

@@ -1,8 +1,9 @@
 @page "/admin/inquiries/create"
 @attribute [Authorize]
 @using TaxBaik.Application.DTOs
+@using TaxBaik.Application.Services
 @using TaxBaik.Web.Components.Admin.Forms
-@inject IInquiryBrowserClient InquiryClient
+@inject InquiryService InquiryService
 @inject NavigationManager Navigation
 @inject ISnackbar Snackbar
 
@@ -31,21 +32,13 @@
     {
         try
         {
-            var result = await InquiryClient.CreateAsync(new SubmitInquiryDto
+            await InquiryService.SubmitAsync(
-            {
+                model.Name,
-                Name = model.Name,
+                model.Phone,
-                Phone = model.Phone,
+                model.ServiceType,
-                Email = model.Email,
+                model.Message,
-                ServiceType = model.ServiceType,
+                model.Email,
-                Message = model.Message,
+                ipAddress: "admin-registered");
-                SuppressNotification = true
-            });
-
-            if (result == null)
-            {
-                Snackbar.Add("문의가 등록되지 않았습니다.", Severity.Error);
-                return;
-            }
 
             Snackbar.Add("문의가 등록되었습니다.", Severity.Success);
             Navigation.NavigateTo("/taxbaik/admin/inquiries");

TaxBaik.Web/Components/Admin/Pages/Inquiries/InquiryEdit.razor

@@ -1,8 +1,9 @@
 @page "/admin/inquiries/{id:int}/edit"
 @attribute [Authorize]
 @using TaxBaik.Application.DTOs
+@using TaxBaik.Application.Services
 @using TaxBaik.Web.Components.Admin.Forms
-@inject IInquiryBrowserClient InquiryClient
+@inject InquiryService InquiryService
 @inject NavigationManager Navigation
 @inject ISnackbar Snackbar
 @inject IDialogService DialogService
@@ -51,7 +52,7 @@ else
     {
         try
         {
-            inquiry = await InquiryClient.GetByIdAsync(Id);
+            inquiry = await InquiryService.GetByIdAsync(Id);
             if (inquiry != null)
             {
                 formModel = new InquiryForm.InquiryFormModel
@@ -88,34 +89,19 @@ else
 
         try
         {
-            var updated = await InquiryClient.UpdateAsync(inquiry.Id, new UpdateInquiryDto
+            inquiry.Name = model.Name;
-            {
+            inquiry.Phone = model.Phone;
-                Name = model.Name,
+            inquiry.Email = model.Email;
-                Phone = model.Phone,
+            inquiry.ServiceType = model.ServiceType;
-                Email = model.Email,
+            inquiry.Message = model.Message;
-                ServiceType = model.ServiceType,
+            inquiry.AdminMemo = model.AdminMemo;
-                Message = model.Message,
-                Status = model.Status,
-                AdminMemo = model.AdminMemo
-            });
 
-            if (updated == null)
+            if (inquiry.Status != model.Status)
             {
-                Snackbar.Add("문의 수정에 실패했습니다.", Severity.Error);
+                await InquiryService.UpdateStatusAsync(inquiry.Id, model.Status);
-                return;
             }
 
-            inquiry = updated;
+            await InquiryService.UpdateAdminMemoAsync(inquiry.Id, model.AdminMemo);
-            formModel = new InquiryForm.InquiryFormModel
-            {
-                Name = inquiry.Name,
-                Phone = inquiry.Phone,
-                Email = inquiry.Email,
-                ServiceType = inquiry.ServiceType,
-                Message = inquiry.Message,
-                Status = inquiry.Status,
-                AdminMemo = inquiry.AdminMemo
-            };
 
             Snackbar.Add("문의가 수정되었습니다.", Severity.Success);
             Navigation.NavigateTo("/taxbaik/admin/inquiries");
@@ -145,12 +131,7 @@ else
 
         try
         {
-            var deleted = await InquiryClient.DeleteAsync(inquiry.Id);
+            await InquiryService.DeleteAsync(inquiry.Id);
-            if (!deleted)
-            {
-                Snackbar.Add("문의 삭제에 실패했습니다.", Severity.Error);
-                return;
-            }
             Snackbar.Add("문의가 삭제되었습니다.", Severity.Success);
             Navigation.NavigateTo("/taxbaik/admin/inquiries");
         }

TaxBaik.Web/Components/Admin/Pages/Inquiries/InquiryList.razor

@@ -5,12 +5,15 @@
 
 <PageTitle>문의 관리</PageTitle>
 
-<AdminPageHeader Title="문의 관리" Eyebrow="Customer Requests" Subtitle="상담 요청을 상태별로 확인하고 후속 조치를 기록합니다.">
+<section class="admin-page-hero">
-    <ChildContent>
+    <div>
-        <MudButton Variant="Variant.Filled" Color="Color.Primary" StartIcon="@Icons.Material.Filled.Add"
+        <MudText Typo="Typo.caption" Class="admin-eyebrow">Customer Requests</MudText>
-                   Href="/taxbaik/admin/inquiries/create">새 문의 등록</MudButton>
+        <MudText Typo="Typo.h4" Class="admin-page-title">문의 관리</MudText>
-    </ChildContent>
+        <MudText Typo="Typo.body2" Class="admin-page-subtitle">상담 요청을 상태별로 확인하고 후속 조치를 기록합니다.</MudText>
-</AdminPageHeader>
+    </div>
+    <MudButton Variant="Variant.Filled" Color="Color.Primary" StartIcon="@Icons.Material.Filled.Add"
+        Href="/taxbaik/admin/inquiries/create">새 문의 등록</MudButton>
+</section>
 
 <MudPaper Class="admin-surface" Elevation="0">
 @if (isLoading)
@@ -43,27 +46,11 @@ else
 </MudPaper>
 
 @code {
-    [CascadingParameter]
-    private Task<AuthenticationState>? AuthStateTask { get; set; }
-
     private bool isLoading = true;
     private IReadOnlyList<Domain.Entities.Inquiry> allInquiries = [];
 
     protected override async Task OnInitializedAsync()
     {
-        if (AuthStateTask != null)
-        {
-            var authState = await AuthStateTask;
-            if (authState.User.Identity?.IsAuthenticated == true)
-            {
-                await LoadData();
-            }
-        }
-    }
-
-    private async Task LoadData()
-    {
-        isLoading = true;
         try
         {
             var (items, _) = await InquiryClient.GetPagedAsync(1, 200);

TaxBaik.Web/Components/Admin/Pages/Login.razor

@@ -1,10 +1,12 @@
 @page "/admin/login"
+@using System.ComponentModel.DataAnnotations
 @layout TaxBaik.Web.Components.Admin.Layout.BlankLayout
 @attribute [AllowAnonymous]
-@rendermode @(new InteractiveServerRenderMode(prerender: true))
 @inject IApiClient ApiClient
-@inject ILocalStorageService LocalStorageService
+@inject NavigationManager NavigationManager
+@inject CustomAuthenticationStateProvider AuthStateProvider
 @inject IJSRuntime Js
+@inject ILocalStorageService LocalStorageService
 
 <PageTitle>로그인</PageTitle>
 
@@ -12,39 +14,52 @@
     <MudPaper Class="pa-8" Elevation="3" Style="width: 100%; max-width: 400px;">
         <MudText Typo="Typo.h4" Class="mb-6 text-center">관리자 로그인</MudText>
 
-        <form id="admin-login-form">
+        <form @onsubmit="HandleLogin" @onsubmit:preventDefault>
-            <input class="mud-input mud-input-outlined mud-input-root mud-input-root-adorned-start mb-4"
+            <InputText class="mud-input mud-input-outlined mud-input-root mud-input-root-adorned-start mb-4"
-                   style="width: 100%; min-height: 56px; padding: 16px 14px;"
+                       style="width: 100%; min-height: 56px; padding: 16px 14px;"
-                   placeholder="사용자명"
+                       placeholder="사용자명"
-                   autocomplete="username"
+                       autocomplete="username"
-                   name="username"
+                       @bind-Value="model.Username" />
-                   value="@model.Username" />
 
-            <input type="password"
+            <InputText type="password"
-                   class="mud-input mud-input-outlined mud-input-root mud-input-root-adorned-start mb-4"
+                       class="mud-input mud-input-outlined mud-input-root mud-input-root-adorned-start mb-4"
-                   style="width: 100%; min-height: 56px; padding: 16px 14px;"
+                       style="width: 100%; min-height: 56px; padding: 16px 14px;"
-                   placeholder="비밀번호"
+                       placeholder="비밀번호"
-                   autocomplete="current-password"
+                       autocomplete="current-password"
-                   name="password" />
+                       @bind-Value="model.Password" />
 
             <div class="mb-4">
-                <input class="mud-checkbox" type="checkbox" name="rememberMe" />
+                <InputCheckbox class="mud-checkbox" @bind-Value="model.RememberMe" />
                 <label style="margin-left: 8px; cursor: pointer;">아이디 저장</label>
             </div>
 
-            <div class="mud-alert mud-alert-filled-error mb-4 login-error-message" style="display:none;">로그인 중 오류가 발생했습니다.</div>
+            @if (!string.IsNullOrEmpty(errorMessage))
+            {
+                <MudAlert Severity="Severity.Error" Class="mb-4">@errorMessage</MudAlert>
+            }
 
             <button type="submit"
                     class="mud-button-root mud-button mud-button-filled mud-button-filled-primary mud-elevation-0"
-                    style="width: 100%; min-height: 52px; border: 0; border-radius: 4px; color: white;">
+                    style="width: 100%; min-height: 52px; border: 0; border-radius: 4px; color: white;"
-                <span>로그인</span>
+                    disabled="@isLoading">
+                @if (isLoading)
+                {
+                    <MudProgressCircular Size="Size.Small" Indeterminate="true" Class="mr-2" />
+                    <span>로그인 중...</span>
+                }
+                else
+                {
+                    <span>로그인</span>
+                }
             </button>
         </form>
     </MudPaper>
 </MudContainer>
 
 @code {
-    private readonly LoginModel model = new();
+    private bool isLoading = false;
+    private string errorMessage = "";
+    private LoginModel model = new();
     private const string RememberedUsernameKey = "admin-remembered-username";
 
     protected override async Task OnInitializedAsync()
@@ -55,11 +70,12 @@
             if (!string.IsNullOrEmpty(remembered))
             {
                 model.Username = remembered;
+                model.RememberMe = true;
             }
         }
         catch
         {
-            // LocalStorage may be unavailable during prerender.
+            // LocalStorage not available in pre-render
         }
     }
 
@@ -69,10 +85,75 @@
             await Js.InvokeVoidAsync("taxbaikAdminSession.syncRouteClass");
     }
 
+    private async Task HandleLogin()
+    {
+        if (isLoading)
+            return;
+
+        isLoading = true;
+        errorMessage = "";
+
+        try
+        {
+            var request = new { model.Username, model.Password };
+            var response = await ApiClient.PostAsync<LoginResponse>("auth/login", request);
+
+            if (response?.AccessToken == null || response?.RefreshToken == null)
+            {
+                errorMessage = "사용자명 또는 비밀번호가 올바르지 않습니다.";
+                isLoading = false;
+                return;
+            }
+
+            if (model.RememberMe)
+            {
+                await LocalStorageService.SetItemAsStringAsync(RememberedUsernameKey, model.Username);
+            }
+            else
+            {
+                await LocalStorageService.RemoveItemAsync(RememberedUsernameKey);
+            }
+
+            await ApiClient.SetAuthToken(response.AccessToken);
+            await AuthStateProvider.LoginAsync(response.AccessToken, response.RefreshToken, response.ExpiresIn);
+            NavigationManager.NavigateTo(GetReturnUrl(), forceLoad: false);
+        }
+        catch
+        {
+            errorMessage = "로그인 중 오류가 발생했습니다.";
+            isLoading = false;
+        }
+    }
+
+    private class LoginResponse
+    {
+        public string AccessToken { get; set; } = "";
+        public string RefreshToken { get; set; } = "";
+        public int ExpiresIn { get; set; }
+    }
+
     private class LoginModel
     {
         public string Username { get; set; } = "";
         public string Password { get; set; } = "";
         public bool RememberMe { get; set; }
     }
+
+    private string GetReturnUrl()
+    {
+        var uri = NavigationManager.ToAbsoluteUri(NavigationManager.Uri);
+        if (!Microsoft.AspNetCore.WebUtilities.QueryHelpers.ParseQuery(uri.Query).TryGetValue("returnUrl", out var returnUrl)
+            || string.IsNullOrWhiteSpace(returnUrl))
+        {
+            return "/taxbaik/admin/dashboard";
+        }
+
+        var value = returnUrl.ToString();
+        if (!value.StartsWith("admin", StringComparison.OrdinalIgnoreCase))
+        {
+            return "/taxbaik/admin/dashboard";
+        }
+
+        return $"/taxbaik/{value.TrimStart('/')}";
+    }
 }

TaxBaik.Web/Components/Admin/Pages/RevenueTrackings.razor

@@ -1,6 +1,5 @@
 @page "/admin/revenue-trackings"
 @using TaxBaik.Web.Services.AdminClients
-@using TaxBaik.Web.Components.Admin.Shared
 @inject IRevenueTrackingBrowserClient RevenueClient
 @inject IClientBrowserClient ClientClient
 @inject ISnackbar Snackbar
@@ -97,13 +96,13 @@
             <MudSelect T="int" @bind-Value="revenueForm.ClientId" Label="고객" Required="true" Variant="Variant.Outlined" FullWidth="true" Class="mb-4">
                 @foreach (var client in clients)
                 {
-                    <MudSelectItem Value="@client.Id">@GetClientDisplayName(client)</MudSelectItem>
+                    <MudSelectItem Value="@client.Id">@client.CompanyName</MudSelectItem>
                 }
             </MudSelect>
             <MudTextField T="string" @bind-Value="revenueForm.InvoiceNumber" Label="청구번호" Variant="Variant.Outlined" FullWidth="true" Class="mb-4" Required="true" />
             <MudDatePicker @bind-Date="revenueForm.InvoiceDate" Label="청구일" Variant="Variant.Outlined" FullWidth="true" Class="mb-4" Required="true" />
             <MudNumericField T="decimal" @bind-Value="revenueForm.Amount" Label="청구액" Variant="Variant.Outlined" FullWidth="true" Class="mb-4" Required="true" />
-            <CommonCodeSelect @bind-Value="revenueForm.ServiceType" Group="REVENUE_SERVICE_TYPE" Label="서비스 유형" Class="mb-4" />
+            <MudTextField T="string" @bind-Value="revenueForm.ServiceType" Label="서비스 유형" Variant="Variant.Outlined" FullWidth="true" Class="mb-4" />
             <MudDatePicker @bind-Date="revenueForm.DueDate" Label="납부예정일" Variant="Variant.Outlined" FullWidth="true" Class="mb-4" />
         </MudForm>
     </DialogContent>
@@ -114,9 +113,6 @@
 </MudDialog>
 
 @code {
-    [CascadingParameter]
-    private Task<AuthenticationState>? AuthStateTask { get; set; }
-
     private List<RevenueTracking>? revenues;
     private List<Client> clients = [];
     private Dictionary<int, string> clientMap = new();
@@ -126,14 +122,7 @@
 
     protected override async Task OnInitializedAsync()
     {
-        if (AuthStateTask != null)
+        await LoadData();
-        {
-            var authState = await AuthStateTask;
-            if (authState.User.Identity?.IsAuthenticated == true)
-            {
-                await LoadData();
-            }
-        }
     }
 
     private async Task LoadData()
@@ -141,9 +130,9 @@
         try
         {
             revenues = await RevenueClient.GetAllAsync();
-            var (clientItems, _) = await ClientClient.GetPagedAsync(pageSize: 1000);
+            var (clientItems, _) = await ClientClient.GetPagedAsync();
             clients = clientItems.ToList();
-            clientMap = clients.ToDictionary(c => c.Id, GetClientDisplayName);
+            clientMap = clients.ToDictionary(c => c.Id, c => c.CompanyName ?? "");
         }
         catch (Exception ex)
         {
@@ -153,27 +142,12 @@
 
     private void OpenCreateDialog()
     {
-        revenueForm = new RevenueForm
+        revenueForm = new();
-        {
-            ClientId = clients.FirstOrDefault()?.Id ?? 0,
-            InvoiceDate = DateTime.Today,
-            DueDate = DateTime.Today.AddDays(14)
-        };
         isDialogOpen = true;
     }
 
     private async Task SaveRevenue()
     {
-        if (form != null)
-        {
-            await form.Validate();
-            if (!form.IsValid)
-            {
-                Snackbar.Add("필수 항목을 입력해주세요.", Severity.Warning);
-                return;
-            }
-        }
-
         try
         {
             var newId = await RevenueClient.CreateAsync(
@@ -243,12 +217,6 @@
         revenueForm = new();
     }
 
-    private static string GetClientDisplayName(Client client)
-        => !string.IsNullOrWhiteSpace(client.CompanyName)
-            ? client.CompanyName
-            : !string.IsNullOrWhiteSpace(client.Name)
-                ? client.Name
-                : $"Client #{client.Id}";
     private class RevenueForm
     {
         public int ClientId { get; set; }

TaxBaik.Web/Components/Admin/Pages/Settings/SiteSettings.razor

@@ -35,7 +35,7 @@
                 <MudTextField @bind-Value="email" Label="이메일"
                     Variant="Variant.Outlined" Class="mb-4" />
 
-                <MudTextField @bind-Value="kakaoUrl" Label="카카오채널 URL"
+                <MudTextField @bind-Value="kakaoUrl" Label="카카오 채널 URL"
                     Variant="Variant.Outlined" Class="mb-4" />
 
                 <MudTextField @bind-Value="instagramUrl" Label="인스타그램"

TaxBaik.Web/Components/Admin/Pages/TaxFilingSchedules.razor

@@ -1,7 +1,5 @@
 @page "/admin/tax-filing-schedules"
 @using TaxBaik.Web.Services.AdminClients
-@using TaxBaik.Domain.Entities
-@using TaxBaik.Web.Components.Admin.Shared
 @inject ITaxFilingScheduleBrowserClient TaxFilingClient
 @inject IClientBrowserClient ClientClient
 @inject ISnackbar Snackbar
@@ -16,189 +14,150 @@
         <MudText Typo="Typo.h4" Class="admin-page-title">신고 일정</MudText>
         <MudText Typo="Typo.body2" Class="admin-page-subtitle">고객별 마감일과 처리 상태를 한 화면에서 관리합니다.</MudText>
     </div>
-    <MudButton Variant="Variant.Filled" Color="Color.Primary" OnClick="PrepareCreate" StartIcon="@Icons.Material.Filled.Add" id="btn-add-schedule">
+    <MudButton Variant="Variant.Filled"
+               Color="Color.Primary"
+               OnClick="OpenCreateDialog"
+               StartIcon="@Icons.Material.Filled.Add">
         새 일정 추가
     </MudButton>
 </section>
 
-@if (schedules is null)
+<MudPaper Class="admin-surface" Elevation="0">
-{
+    @if (schedules is null)
-    <MudProgressLinear Indeterminate="true" />
+    {
-}
+        <MudProgressLinear Indeterminate="true" />
-else
+    }
-{
+    else if (schedules.Count == 0)
-    <MudGrid Spacing="2" Class="mt-2">
+    {
-        <!-- Left: Dense Grid List -->
+        <MudAlert Severity="Severity.Info" Class="mt-4">
-        <MudItem XS="12" MD="8">
+            <MudIcon Icon="@Icons.Material.Filled.EventBusy" Class="me-2" />
-            @if (schedules.Count == 0)
+            신고 일정이 없습니다.
-            {
+        </MudAlert>
-                <MudAlert Severity="Severity.Info">
+    }
-                    <MudIcon Icon="@Icons.Material.Filled.EventBusy" Class="me-2" />
+    else
-                    신고 일정이 없습니다.
+    {
-                </MudAlert>
+        <MudDataGrid T="TaxFilingSchedule"
-            }
+                     Items="@schedules"
-            else
+                     Dense="true"
-            {
+                     Hover="true"
-                <MudDataGrid T="TaxFilingSchedule"
+                     Striped="true"
-                             Items="@schedules"
+                     Virtualize="true"
-                             Dense="true"
+                     RowsPerPage="30"
-                             Hover="true"
+                     Class="admin-grid">
-                             Striped="true"
+            <Columns>
-                             Virtualize="true"
+                <PropertyColumn Property="x => x.Id" Title="ID" Sortable="true" />
-                             RowsPerPage="30"
+                <TemplateColumn Title="고객">
-                             SelectedItem="@selectedSchedule"
+                    <CellTemplate>
-                             SelectedItemChanged="OnRowSelected"
+                        @if (clientMap.TryGetValue(context.Item.ClientId, out var clientName))
-                             Class="admin-grid">
-                    <Columns>
-                        <PropertyColumn Property="x => x.Id" Title="ID" Sortable="true" />
-                        <TemplateColumn Title="고객">
-                            <CellTemplate>
-                                @if (clientMap.TryGetValue(context.Item.ClientId, out var clientName))
-                                {
-                                    @clientName
-                                }
-                            </CellTemplate>
-                        </TemplateColumn>
-                        <PropertyColumn Property="x => x.FilingType" Title="신고 유형" />
-                        <TemplateColumn Title="마감일">
-                            <CellTemplate>
-                                @{
-                                    var effectiveDueDate = BusinessDayCalculator.GetEffectiveDueDate(DateOnly.FromDateTime(context.Item.DueDate));
-                                    var daysLeft = BusinessDayCalculator.GetDday(DateOnly.FromDateTime(context.Item.DueDate));
-                                    var statusColor = daysLeft < 0 ? Color.Error : daysLeft <= 7 ? Color.Warning : Color.Success;
-                                }
-                                <MudChip Size="Size.Small" Color="@statusColor" Variant="Variant.Filled">
-                                    @effectiveDueDate.ToDateTime(TimeOnly.MinValue).ToString("yyyy-MM-dd")
-                                    @if (daysLeft >= 0)
-                                    {
-                                        <span class="ms-1">(D-@daysLeft)</span>
-                                    }
-                                    else
-                                    {
-                                        <span class="ms-1">(마감 @Math.Abs(daysLeft)일 경과)</span>
-                                    }
-                                </MudChip>
-                            </CellTemplate>
-                        </TemplateColumn>
-                        <PropertyColumn Property="x => x.FilingYear" Title="신고연도" />
-                        <TemplateColumn Title="상태">
-                            <CellTemplate>
-                                @if (context.Item.Status == "completed")
-                                {
-                                    <MudChip Size="Size.Small" Color="Color.Success" Variant="Variant.Filled">완료</MudChip>
-                                }
-                                else
-                                {
-                                    <MudChip Size="Size.Small" Color="Color.Default" Variant="Variant.Outlined">대기</MudChip>
-                                }
-                            </CellTemplate>
-                        </TemplateColumn>
-                        <TemplateColumn Title="작업" Sortable="false">
-                            <CellTemplate>
-                                <MudButtonGroup Size="Size.Small" Variant="Variant.Outlined">
-                                    @if (context.Item.Status != "completed")
-                                    {
-                                        <MudIconButton Icon="@Icons.Material.Filled.CheckCircle"
-                                                       Color="Color.Success"
-                                                       OnClick="@(async () => await CompleteSchedule(context.Item.Id))"
-                                                       Title="완료" />
-                                    }
-                                    <MudIconButton Icon="@Icons.Material.Filled.Delete"
-                                                   Color="Color.Error"
-                                                   OnClick="@(async () => await DeleteSchedule(context.Item.Id))"
-                                                   Title="삭제" />
-                                </MudButtonGroup>
-                            </CellTemplate>
-                        </TemplateColumn>
-                    </Columns>
-                </MudDataGrid>
-            }
-        </MudItem>
-
-        <!-- Right: Detail Form Panel (Inline Editor) -->
-        <MudItem XS="12" MD="4">
-            <MudPaper Class="pa-4 admin-surface admin-editor-panel" Elevation="0" Style="border: 1px solid var(--border-color); min-height: 400px;">
-                <div class="d-flex align-center justify-space-between mb-4">
-                    <MudText Typo="Typo.h6" Class="font-weight-bold">@(isEditMode ? "신고 일정 상세" : "새 신고 일정 추가")</MudText>
-                    @if (isEditMode)
-                    {
-                        <MudButton Size="Size.Small" Variant="Variant.Outlined" Color="Color.Secondary" OnClick="PrepareCreate">
-                            새로 작성
-                        </MudButton>
-                    }
-                </div>
-                <MudForm @ref="form">
-                    <MudSelect T="int?"
-                               @bind-Value="scheduleForm.ClientId"
-                               Label="고객"
-                               Required="true"
-                               Variant="Variant.Outlined"
-                               FullWidth="@true"
-                               Class="mb-3"
-                               RequiredError="고객을 선택하세요."
-                               Disabled="@isEditMode">
-                        @foreach (var client in clients)
                         {
-                            <MudSelectItem Value="@((int?)client.Id)">@GetClientDisplayName(client)</MudSelectItem>
+                            <MudLink Href="@($"/taxbaik/admin/clients/{context.Item.ClientId}")" Color="Color.Primary">
+                                @clientName
+                            </MudLink>
                         }
-                    </MudSelect>
+                    </CellTemplate>
-                    <CommonCodeSelect @bind-Value="scheduleForm.FilingType" Group="FILING_TYPE" Label="신고 유형" Class="mb-3" Required="true" />
+                </TemplateColumn>
-                    <MudDatePicker @bind-Date="scheduleForm.DueDate" Label="마감일" Variant="Variant.Outlined" FullWidth="@true" Class="mb-3" Required="true" />
+                <PropertyColumn Property="x => x.FilingType" Title="신고 유형" />
-                    <MudNumericField T="int" @bind-Value="scheduleForm.FilingYear" Label="신고연도" Variant="Variant.Outlined" FullWidth="@true" Class="mb-4" Required="true" />
+                <TemplateColumn Title="마감일">
-                    
+                    <CellTemplate>
-                    <div class="d-flex justify-end gap-2">
+                        @{
-                        @if (isEditMode && selectedSchedule?.Status != "completed")
+                            var daysLeft = (context.Item.DueDate.Date - DateTime.Today).Days;
-                        {
+                            var statusColor = daysLeft < 0 ? Color.Error : daysLeft <= 7 ? Color.Warning : Color.Success;
-                            <MudButton Variant="Variant.Outlined" Color="Color.Success" OnClick="@(async () => await CompleteSchedule(selectedSchedule?.Id ?? 0))">완료 처리</MudButton>
                         }
-                        @if (isEditMode)
+                        <MudChip Size="Size.Small" Color="@statusColor" Variant="Variant.Filled">
+                            @context.Item.DueDate.ToString("yyyy-MM-dd")
+                            @if (daysLeft >= 0)
+                            {
+                                <span class="ms-1">(D-@daysLeft)</span>
+                            }
+                            else
+                            {
+                                <span class="ms-1">(마감 @Math.Abs(daysLeft)일 경과)</span>
+                            }
+                        </MudChip>
+                    </CellTemplate>
+                </TemplateColumn>
+                <PropertyColumn Property="x => x.FilingYear" Title="신고연도" />
+                <TemplateColumn Title="상태">
+                    <CellTemplate>
+                        @if (context.Item.Status == "completed")
                         {
-                            <MudButton Variant="Variant.Outlined" Color="Color.Error" OnClick="@(async () => await DeleteSchedule(selectedSchedule?.Id ?? 0))">삭제</MudButton>
+                            <MudChip Size="Size.Small" Color="Color.Success" Variant="Variant.Filled">완료</MudChip>
                         }
                         else
                         {
-                            <MudButton Variant="Variant.Filled" Color="Color.Primary" OnClick="SaveSchedule" id="btn-save-schedule">저장</MudButton>
+                            <MudChip Size="Size.Small" Color="Color.Default" Variant="Variant.Outlined">대기</MudChip>
                         }
-                    </div>
+                    </CellTemplate>
-                </MudForm>
+                </TemplateColumn>
-            </MudPaper>
+                <TemplateColumn Title="작업" Sortable="false">
-        </MudItem>
+                    <CellTemplate>
-    </MudGrid>
+                        <MudButtonGroup Size="Size.Small" Variant="Variant.Outlined">
-}
+                            @if (context.Item.Status != "completed")
+                            {
+                                <MudIconButton Icon="@Icons.Material.Filled.CheckCircle"
+                                               Color="Color.Success"
+                                               OnClick="@(async () => await CompleteSchedule(context.Item.Id))"
+                                               Title="완료" />
+                            }
+                            <MudIconButton Icon="@Icons.Material.Filled.Delete"
+                                           Color="Color.Error"
+                                           OnClick="@(async () => await DeleteSchedule(context.Item.Id))"
+                                           Title="삭제" />
+                        </MudButtonGroup>
+                    </CellTemplate>
+                </TemplateColumn>
+            </Columns>
+        </MudDataGrid>
+    }
+</MudPaper>
+
+<MudDialog @bind-IsVisible="isDialogOpen" Options="new DialogOptions { MaxWidth = MaxWidth.Small, FullWidth = true }">
+    <TitleContent>
+        <MudText Typo="Typo.h6">새 신고 일정 추가</MudText>
+    </TitleContent>
+    <DialogContent>
+        <MudForm @ref="form">
+            <MudSelect T="int"
+                       @bind-Value="scheduleForm.ClientId"
+                       Label="고객"
+                       Required="true"
+                       Variant="Variant.Outlined"
+                       FullWidth="true"
+                       Class="mb-4">
+                @foreach (var client in clients)
+                {
+                    <MudSelectItem Value="@client.Id">@client.CompanyName</MudSelectItem>
+                }
+            </MudSelect>
+            <MudTextField T="string" @bind-Value="scheduleForm.FilingType" Label="신고 유형" Variant="Variant.Outlined" FullWidth="true" Class="mb-4" Required="true" />
+            <MudDatePicker @bind-Date="scheduleForm.DueDate" Label="마감일" Variant="Variant.Outlined" FullWidth="true" Class="mb-4" Required="true" />
+            <MudNumericField T="int" @bind-Value="scheduleForm.FilingYear" Label="신고연도" Variant="Variant.Outlined" FullWidth="true" Class="mb-4" Required="true" />
+        </MudForm>
+    </DialogContent>
+    <DialogActions>
+        <MudButton OnClick="CloseDialog">취소</MudButton>
+        <MudButton Color="Color.Primary" OnClick="SaveSchedule">저장</MudButton>
+    </DialogActions>
+</MudDialog>
 
 @code {
-    [CascadingParameter]
-    private Task<AuthenticationState>? AuthStateTask { get; set; }
-
     private List<TaxFilingSchedule>? schedules;
     private List<Client> clients = [];
     private Dictionary<int, string> clientMap = new();
     private MudForm? form;
-    private bool isEditMode;
+    private bool isDialogOpen;
-    private TaxFilingSchedule? selectedSchedule;
     private TaxFilingScheduleForm scheduleForm = new();
 
-    protected override async Task OnInitializedAsync()
+    protected override async Task OnInitializedAsync() => await LoadData();
-    {
-        if (AuthStateTask != null)
-        {
-            var authState = await AuthStateTask;
-            if (authState.User.Identity?.IsAuthenticated == true)
-            {
-                await LoadData();
-                PrepareCreate();
-            }
-        }
-    }
 
     private async Task LoadData()
     {
         try
         {
             schedules = await TaxFilingClient.GetAllAsync();
-            var (clientItems, _) = await ClientClient.GetPagedAsync(pageSize: 1000);
+            var (clientItems, _) = await ClientClient.GetPagedAsync();
             clients = clientItems.ToList();
-            clientMap = clients.ToDictionary(c => c.Id, GetClientDisplayName);
+            clientMap = clients.ToDictionary(c => c.Id, c => c.CompanyName ?? "");
         }
         catch (Exception ex)
         {
@@ -206,50 +165,18 @@ else
         }
     }
 
-    private void PrepareCreate()
+    private void OpenCreateDialog()
     {
-        selectedSchedule = null;
+        scheduleForm = new TaxFilingScheduleForm { FilingYear = DateTime.Now.Year };
-        isEditMode = false;
+        isDialogOpen = true;
-        scheduleForm = new TaxFilingScheduleForm
-        {
-            FilingYear = DateTime.Now.Year,
-            DueDate = DateTime.Today,
-            ClientId = clients.FirstOrDefault()?.Id,
-            FilingType = string.Empty
-        };
-    }
-
-    private void OnRowSelected(TaxFilingSchedule schedule)
-    {
-        if (schedule == null) return;
-        selectedSchedule = schedule;
-        isEditMode = true;
-        scheduleForm = new TaxFilingScheduleForm
-        {
-            ClientId = schedule.ClientId,
-            FilingType = schedule.FilingType,
-            DueDate = schedule.DueDate,
-            FilingYear = schedule.FilingYear
-        };
     }
 
     private async Task SaveSchedule()
     {
-        if (form != null)
-        {
-            await form.Validate();
-            if (!form.IsValid)
-            {
-                Snackbar.Add("필수 항목을 입력해주세요.", Severity.Warning);
-                return;
-            }
-        }
-
         try
         {
-            if (scheduleForm.ClientId == null) return;
             var newId = await TaxFilingClient.CreateAsync(
-                scheduleForm.ClientId.Value,
+                scheduleForm.ClientId,
                 scheduleForm.FilingType,
                 scheduleForm.DueDate ?? DateTime.Today,
                 scheduleForm.FilingYear);
@@ -257,7 +184,7 @@ else
             if (newId > 0)
             {
                 Snackbar.Add("신고 일정이 추가되었습니다.", Severity.Success);
-                PrepareCreate();
+                CloseDialog();
                 await LoadData();
             }
             else
@@ -277,10 +204,6 @@ else
         {
             await TaxFilingClient.MarkCompletedAsync(id);
             Snackbar.Add("신고 일정이 완료 처리되었습니다.", Severity.Success);
-            if (selectedSchedule?.Id == id)
-            {
-                PrepareCreate();
-            }
             await LoadData();
         }
         catch (Exception ex)
@@ -306,10 +229,6 @@ else
         {
             await TaxFilingClient.DeleteAsync(id);
             Snackbar.Add("신고 일정이 삭제되었습니다.", Severity.Success);
-            if (selectedSchedule?.Id == id)
-            {
-                PrepareCreate();
-            }
             await LoadData();
         }
         catch (Exception ex)
@@ -318,16 +237,15 @@ else
         }
     }
 
-    private static string GetClientDisplayName(Client client)
+    private void CloseDialog()
-        => !string.IsNullOrWhiteSpace(client.CompanyName)
+    {
-            ? client.CompanyName
+        isDialogOpen = false;
-            : !string.IsNullOrWhiteSpace(client.Name)
+        scheduleForm = new();
-                ? client.Name
+    }
-                : $"Client #{client.Id}";
 
     private class TaxFilingScheduleForm
     {
-        public int? ClientId { get; set; }
+        public int ClientId { get; set; }
         public string FilingType { get; set; } = "";
         public DateTime? DueDate { get; set; }
         public int FilingYear { get; set; } = DateTime.Now.Year;

TaxBaik.Web/Components/Admin/Pages/TaxFilings/FilingTable.razor

@@ -1,6 +1,5 @@
 @using TaxBaik.Web.Services
 @using TaxBaik.Domain.Entities
-@using TaxBaik.Web.Components.Admin.Shared
 @inject ITaxFilingBrowserClient FilingClient
 @inject ISnackbar Snackbar
 
@@ -22,10 +21,10 @@ else
         <RowTemplate>
             <MudTd>@context.ClientName</MudTd>
             <MudTd>@context.FilingType</MudTd>
-            <MudTd>@BusinessDayCalculator.GetEffectiveDueDate(DateOnly.FromDateTime(context.DueDate)).ToDateTime(TimeOnly.MinValue).ToString("yyyy-MM-dd")</MudTd>
+            <MudTd>@context.DueDate.ToString("yyyy-MM-dd")</MudTd>
             <MudTd>
                 @{
-                    var dday = BusinessDayCalculator.GetDday(DateOnly.FromDateTime(context.DueDate));
+                    var dday = (context.DueDate.Date - DateTime.Today).Days;
                 }
                 @if (dday < 0)
                 {

TaxBaik.Web/Components/Admin/Pages/TaxFilings/TaxFilingList.razor

@@ -2,7 +2,6 @@
 @attribute [Authorize]
 @using TaxBaik.Web.Services
 @using TaxBaik.Domain.Entities
-@using TaxBaik.Web.Components.Admin.Shared
 @inject ITaxFilingBrowserClient FilingClient
 @inject IClientBrowserClient ClientClient
 @inject ISnackbar Snackbar
@@ -35,7 +34,12 @@
                                  Variant="Variant.Outlined" />
             </MudItem>
             <MudItem xs="12" sm="6" md="4">
-            <CommonCodeSelect @bind-Value="newFilingType" Group="FILING_TYPE" Label="신고 유형 *" />
+                <MudSelect T="string" @bind-Value="newFilingType" Label="신고 유형 *" Variant="Variant.Outlined">
+                    @foreach (var t in TaxFilingService.FilingTypes)
+                    {
+                        <MudSelectItem Value="@t">@t</MudSelectItem>
+                    }
+                </MudSelect>
             </MudItem>
             <MudItem xs="12" sm="6" md="4">
                 <MudDatePicker @bind-Date="newDueDate" Label="신고 기한 *" DateFormat="yyyy-MM-dd" />
@@ -78,10 +82,6 @@
 
     protected override async Task OnInitializedAsync() => await Reload();
 
-    protected override async Task OnParametersSetAsync()
-    {
-    }
-
     private async Task Reload()
     {
         try
@@ -101,7 +101,7 @@
     {
         try
         {
-            var (items, _) = await ClientClient.GetPagedAsync(1, 100, search: value);
+            var (items, _) = await ClientClient.GetPagedAsync(1, 20, search: value);
             return items;
         }
         catch
@@ -110,12 +110,6 @@
         }
     }
 
-    private static string GetClientDisplayName(Client client)
-        => !string.IsNullOrWhiteSpace(client.CompanyName)
-            ? client.CompanyName
-            : !string.IsNullOrWhiteSpace(client.Name)
-                ? client.Name
-                : $"Client #{client.Id}";
     private async Task AddFiling()
     {
         try

TaxBaik.Web/Components/Admin/Pages/TaxProfiles.razor

@@ -1,6 +1,5 @@
 @page "/admin/tax-profiles"
 @using TaxBaik.Web.Services.AdminClients
-@using TaxBaik.Web.Components.Admin.Shared
 @inject ITaxProfileBrowserClient TaxProfileClient
 @inject IClientBrowserClient ClientClient
 @inject ISnackbar Snackbar
@@ -15,7 +14,7 @@
         <MudText Typo="Typo.h4" Class="admin-page-title">세무 프로필</MudText>
         <MudText Typo="Typo.body2" Class="admin-page-subtitle">고객별 세무 프로필, 신고 일정, 위험도 추적</MudText>
     </div>
-    <MudButton Variant="Variant.Filled" Color="Color.Primary" OnClick="PrepareCreate" StartIcon="@Icons.Material.Filled.Add" id="btn-add-profile">
+    <MudButton Variant="Variant.Filled" Color="Color.Primary" OnClick="OpenCreateDialog" StartIcon="@Icons.Material.Filled.Add">
         새 프로필 추가
     </MudButton>
 </section>
@@ -24,124 +23,102 @@
 {
     <MudProgressCircular Indeterminate="true" Class="mt-4" />
 }
+else if (profiles.Count == 0)
+{
+    <MudAlert Severity="Severity.Info" Class="mt-4">세무 프로필이 없습니다.</MudAlert>
+}
 else
 {
-    <MudGrid Spacing="2" Class="mt-2">
+    <MudDataGrid T="TaxProfile"
-        <!-- Left: Dense Grid List -->
+        Items="@profiles"
-        <MudItem XS="12" MD="8">
+        Dense="true"
-            @if (profiles.Count == 0)
+        Hover="true"
-            {
+        Striped="true"
-                <MudAlert Severity="Severity.Info">세무 프로필이 없습니다.</MudAlert>
+        Virtualize="true"
-            }
+        RowsPerPage="30"
-            else
+        Class="admin-grid mt-4">
-            {
+        <Columns>
-                <MudDataGrid T="TaxProfile"
+            <PropertyColumn Property="x => x.Id" Title="ID" Sortable="true" />
-                    Items="@profiles"
+            <TemplateColumn Title="고객">
-                    Dense="true"
+                <CellTemplate>
-                    Hover="true"
+                    @if (clientMap.TryGetValue(context.Item.ClientId, out var clientName))
-                    Striped="true"
-                    Virtualize="true"
-                    RowsPerPage="30"
-                    SelectedItem="@selectedProfile"
-                    SelectedItemChanged="OnRowSelected"
-                    Class="admin-grid">
-                    <Columns>
-                        <PropertyColumn Property="x => x.Id" Title="ID" Sortable="true" />
-                        <TemplateColumn Title="고객">
-                            <CellTemplate>
-                                @if (clientMap.TryGetValue(context.Item.ClientId, out var clientName))
-                                {
-                                    @clientName
-                                }
-                            </CellTemplate>
-                        </TemplateColumn>
-                        <PropertyColumn Property="x => x.BusinessType" Title="사업 유형" />
-                        <TemplateColumn Title="위험도">
-                            <CellTemplate>
-                                <MudChip Size="Size.Small" Color="@GetRiskColor(context.Item.TaxRiskLevel)" Variant="Variant.Filled">
-                                    @context.Item.TaxRiskLevel
-                                </MudChip>
-                            </CellTemplate>
-                        </TemplateColumn>
-                        <TemplateColumn Title="다음 신고">
-                            <CellTemplate>
-                                @if (context.Item.NextFilingDueDate.HasValue)
-                                {
-                                    @context.Item.NextFilingDueDate.Value.ToString("yyyy-MM-dd")
-                                }
-                            </CellTemplate>
-                        </TemplateColumn>
-                        <TemplateColumn Title="작업" Sortable="false">
-                            <CellTemplate>
-                                <MudIconButton Icon="@Icons.Material.Filled.Delete" Color="Color.Error" Size="Size.Small" OnClick="@(async () => await DeleteProfile(context.Item.Id))" />
-                            </CellTemplate>
-                        </TemplateColumn>
-                    </Columns>
-                </MudDataGrid>
-            }
-        </MudItem>
-
-        <!-- Right: Detail Form Panel (Inline Editor) -->
-        <MudItem XS="12" MD="4">
-            <MudPaper Class="pa-4 admin-surface admin-editor-panel" Elevation="0" Style="border: 1px solid var(--border-color); min-height: 400px;">
-                <div class="d-flex align-center justify-space-between mb-4">
-                    <MudText Typo="Typo.h6" Class="font-weight-bold">@(isEditMode ? "세무 프로필 수정" : "새 세무 프로필 추가")</MudText>
-                    @if (isEditMode)
                     {
-                        <MudButton Size="Size.Small" Variant="Variant.Outlined" Color="Color.Secondary" OnClick="PrepareCreate">
+                        <MudLink Href="@($"/taxbaik/admin/clients/{context.Item.ClientId}")" Color="Color.Primary">
-                            새로 작성
+                            @clientName
-                        </MudButton>
+                        </MudLink>
                     }
-                </div>
+                </CellTemplate>
-                <MudForm @ref="form">
+            </TemplateColumn>
-                    <MudSelect T="int?" @bind-Value="profileForm.ClientId" Label="고객" Required="true" Variant="Variant.Outlined" FullWidth="@true" Class="mb-3" RequiredError="고객을 선택하세요." Disabled="@isEditMode">
+            <PropertyColumn Property="x => x.BusinessType" Title="사업 유형" />
-                        @foreach (var client in clients)
+            <TemplateColumn Title="위험도">
-                        {
+                <CellTemplate>
-                            <MudSelectItem Value="@((int?)client.Id)">@GetClientDisplayName(client)</MudSelectItem>
+                    <MudChip Size="Size.Small" Color="@GetRiskColor(context.Item.TaxRiskLevel)" Variant="Variant.Filled">
-                        }
+                        @context.Item.TaxRiskLevel
-                    </MudSelect>
+                    </MudChip>
-                    <CommonCodeSelect @bind-Value="profileForm.BusinessType" Group="BUSINESS_TYPE" Label="사업 유형" Class="mb-3" Required="true" />
+                </CellTemplate>
-                    <CommonCodeSelect @bind-Value="profileForm.TaxRiskLevel" Group="TAX_RISK_LEVEL" Label="위험도" Class="mb-3" />
+            </TemplateColumn>
-                    <MudDatePicker @bind-Date="profileForm.NextFilingDueDate" Label="다음 신고 예정일" Variant="Variant.Outlined" FullWidth="@true" Class="mb-3" />
+            <TemplateColumn Title="다음 신고">
-                    <MudTextField T="string" @bind-Value="profileForm.SpecialNotes" Label="특수 사항" Variant="Variant.Outlined" FullWidth="@true" Lines="3" Class="mb-4" />
+                <CellTemplate>
-                    
+                    @if (context.Item.NextFilingDueDate.HasValue)
-                    <div class="d-flex justify-end gap-2">
+                    {
-                        @if (isEditMode)
+                        @context.Item.NextFilingDueDate.Value.ToString("yyyy-MM-dd")
-                        {
+                    }
-                            <MudButton Variant="Variant.Outlined" Color="Color.Error" OnClick="@(async () => await DeleteProfile(selectedProfile?.Id ?? 0))">삭제</MudButton>
+                </CellTemplate>
-                        }
+            </TemplateColumn>
-                        <MudButton Variant="Variant.Filled" Color="Color.Primary" OnClick="SaveProfile" id="btn-save-profile">저장</MudButton>
+            <TemplateColumn Title="작업" Sortable="false">
-                    </div>
+                <CellTemplate>
-                </MudForm>
+                    <MudButtonGroup Size="Size.Small" Variant="Variant.Outlined">
-            </MudPaper>
+                        <MudIconButton Icon="@Icons.Material.Filled.Edit" OnClick="@(async () => await OpenEditDialog(context.Item))" />
-        </MudItem>
+                        <MudIconButton Icon="@Icons.Material.Filled.Delete" Color="Color.Error" OnClick="@(async () => await DeleteProfile(context.Item.Id))" />
-    </MudGrid>
+                    </MudButtonGroup>
+                </CellTemplate>
+            </TemplateColumn>
+        </Columns>
+    </MudDataGrid>
 }
 
-@code {
+<!-- Create/Edit Dialog -->
-    [CascadingParameter]
+<MudDialog @bind-IsVisible="isDialogOpen" Options="new DialogOptions { MaxWidth = MaxWidth.Small, FullWidth = true }">
-    private Task<AuthenticationState>? AuthStateTask { get; set; }
+    <TitleContent>
+        <MudText Typo="Typo.h6">@(isEditMode ? "세무 프로필 수정" : "새 세무 프로필 추가")</MudText>
+    </TitleContent>
+    <DialogContent>
+        <MudForm @ref="form">
+            <MudSelect T="int" @bind-Value="profileForm.ClientId" Label="고객" Required="true" Variant="Variant.Outlined" FullWidth="true" Class="mb-4">
+                @foreach (var client in clients)
+                {
+                    <MudSelectItem Value="@client.Id">@client.CompanyName</MudSelectItem>
+                }
+            </MudSelect>
+            <MudTextField T="string" @bind-Value="profileForm.BusinessType" Label="사업 유형" Variant="Variant.Outlined" FullWidth="true" Class="mb-4" />
+            <MudSelect T="string" @bind-Value="profileForm.TaxRiskLevel" Label="위험도" Variant="Variant.Outlined" FullWidth="true" Class="mb-4">
+                <MudSelectItem Value="@("low")">낮음</MudSelectItem>
+                <MudSelectItem Value="@("normal")">보통</MudSelectItem>
+                <MudSelectItem Value="@("high")">높음</MudSelectItem>
+            </MudSelect>
+            <MudDatePicker @bind-Date="profileForm.NextFilingDueDate" Label="다음 신고 예정일" Variant="Variant.Outlined" FullWidth="true" Class="mb-4" />
+            <MudTextField T="string" @bind-Value="profileForm.SpecialNotes" Label="특수 사항" Variant="Variant.Outlined" FullWidth="true" Lines="2" />
+        </MudForm>
+    </DialogContent>
+    <DialogActions>
+        <MudButton OnClick="CloseDialog">취소</MudButton>
+        <MudButton Color="Color.Primary" OnClick="SaveProfile">저장</MudButton>
+    </DialogActions>
+</MudDialog>
 
+@code {
     private List<TaxProfile>? profiles;
     private List<Client> clients = [];
     private Dictionary<int, string> clientMap = new();
-    private List<CommonCode> riskLevels = [];
     private MudForm? form;
+    private bool isDialogOpen;
     private bool isEditMode;
-    private TaxProfile? selectedProfile;
+    private TaxProfile? editingProfile;
     private TaxProfileForm profileForm = new();
 
     protected override async Task OnInitializedAsync()
     {
-        if (AuthStateTask != null)
+        await LoadData();
-        {
-            var authState = await AuthStateTask;
-            if (authState.User.Identity?.IsAuthenticated == true)
-            {
-                await LoadData();
-                PrepareCreate();
-            }
-        }
     }
 
     private async Task LoadData()
@@ -149,10 +126,9 @@ else
         try
         {
             profiles = await TaxProfileClient.GetAllAsync();
-            var (clientItems, _) = await ClientClient.GetPagedAsync(pageSize: 1000);
+            var (clientItems, _) = await ClientClient.GetPagedAsync();
             clients = clientItems.ToList();
-            clientMap = clients.ToDictionary(c => c.Id, GetClientDisplayName);
+            clientMap = clients.ToDictionary(c => c.Id, c => c.CompanyName ?? "");
-
         }
         catch (Exception ex)
         {
@@ -160,23 +136,18 @@ else
         }
     }
 
-    private void PrepareCreate()
+    private void OpenCreateDialog()
     {
-        selectedProfile = null;
         isEditMode = false;
-        profileForm = new TaxProfileForm
+        editingProfile = null;
-        {
+        profileForm = new();
-            ClientId = clients.FirstOrDefault()?.Id,
+        isDialogOpen = true;
-            TaxRiskLevel = "normal",
-            NextFilingDueDate = DateTime.Today.AddMonths(1)
-        };
     }
 
-    private void OnRowSelected(TaxProfile profile)
+    private async Task OpenEditDialog(TaxProfile profile)
     {
-        if (profile == null) return;
-        selectedProfile = profile;
         isEditMode = true;
+        editingProfile = profile;
         profileForm = new TaxProfileForm
         {
             ClientId = profile.ClientId,
@@ -185,50 +156,34 @@ else
             NextFilingDueDate = profile.NextFilingDueDate,
             SpecialNotes = profile.SpecialNotes
         };
+        isDialogOpen = true;
     }
 
     private async Task SaveProfile()
     {
-        if (form != null)
-        {
-            await form.Validate();
-            if (!form.IsValid)
-            {
-                Snackbar.Add("고객을 선택하세요.", Severity.Warning);
-                return;
-            }
-        }
-
         try
         {
-            if (isEditMode && selectedProfile != null)
+            if (isEditMode)
             {
-                await TaxProfileClient.UpdateAsync(selectedProfile.Id, profileForm.BusinessType,
+                await TaxProfileClient.UpdateAsync(
-                    null, profileForm.NextFilingDueDate, profileForm.TaxRiskLevel);
+                    editingProfile!.Id,
-                Snackbar.Add("세무 프로필이 수정되었습니다.", Severity.Success);
+                    profileForm.BusinessType,
+                    null,
+                    profileForm.NextFilingDueDate,
+                    profileForm.TaxRiskLevel);
+                Snackbar.Add("세무 프로필이 업데이트되었습니다.", Severity.Success);
             }
             else
             {
-                if (!profileForm.ClientId.HasValue)
-                {
-                    Snackbar.Add("고객을 선택하세요.", Severity.Warning);
-                    return;
-                }
                 var newId = await TaxProfileClient.CreateAsync(
-                    profileForm.ClientId.Value,
+                    profileForm.ClientId,
                     profileForm.BusinessType);
                 if (newId > 0)
                 {
-                    await TaxProfileClient.UpdateAsync(
-                        newId,
-                        profileForm.BusinessType,
-                        null,
-                        profileForm.NextFilingDueDate,
-                        profileForm.TaxRiskLevel);
                     Snackbar.Add("세무 프로필이 추가되었습니다.", Severity.Success);
                 }
             }
-            PrepareCreate();
+            CloseDialog();
             await LoadData();
         }
         catch (Exception ex)
@@ -253,10 +208,6 @@ else
         {
             await TaxProfileClient.DeleteAsync(id);
             Snackbar.Add("세무 프로필이 삭제되었습니다.", Severity.Success);
-            if (selectedProfile?.Id == id)
-            {
-                PrepareCreate();
-            }
             await LoadData();
         }
         catch (Exception ex)
@@ -265,6 +216,14 @@ else
         }
     }
 
+    private void CloseDialog()
+    {
+        isDialogOpen = false;
+        isEditMode = false;
+        editingProfile = null;
+        profileForm = new();
+    }
+
     private Color GetRiskColor(string riskLevel) => riskLevel switch
     {
         "high" => Color.Error,
@@ -273,16 +232,9 @@ else
         _ => Color.Default
     };
 
-    private static string GetClientDisplayName(Client client)
-        => !string.IsNullOrWhiteSpace(client.CompanyName)
-            ? client.CompanyName
-            : !string.IsNullOrWhiteSpace(client.Name)
-                ? client.Name
-                : $"Client #{client.Id}";
-
     private class TaxProfileForm
     {
-        public int? ClientId { get; set; }
+        public int ClientId { get; set; }
         public string BusinessType { get; set; } = "";
         public string TaxRiskLevel { get; set; } = "normal";
         public DateTime? NextFilingDueDate { get; set; }

TaxBaik.Web/Components/Admin/Shared/AdminEmptyState.razor

@@ -1,12 +0,0 @@
-<div class="pa-6 text-center">
-    <MudIcon Icon="@Icon" Style="font-size:3rem; opacity:.3;" />
-    <MudText Class="mt-2 text-muted">@Message</MudText>
-</div>
-
-@code {
-    [Parameter, EditorRequired]
-    public string Icon { get; set; } = Icons.Material.Filled.Info;
-
-    [Parameter, EditorRequired]
-    public string Message { get; set; } = "";
-}

TaxBaik.Web/Components/Admin/Shared/AdminPageHeader.razor

@@ -1,31 +0,0 @@
-<section class="admin-page-hero">
-    <div>
-        @if (!string.IsNullOrWhiteSpace(Eyebrow))
-        {
-            <MudText Typo="Typo.caption" Class="admin-eyebrow">@Eyebrow</MudText>
-        }
-        <MudText Typo="Typo.h4" Class="admin-page-title">@Title</MudText>
-        @if (!string.IsNullOrWhiteSpace(Subtitle))
-        {
-            <MudText Typo="Typo.body2" Class="admin-page-subtitle">@Subtitle</MudText>
-        }
-    </div>
-    @if (ChildContent is not null)
-    {
-        <div>@ChildContent</div>
-    }
-</section>
-
-@code {
-    [Parameter, EditorRequired]
-    public string Title { get; set; } = "";
-
-    [Parameter]
-    public string? Eyebrow { get; set; }
-
-    [Parameter]
-    public string? Subtitle { get; set; }
-
-    [Parameter]
-    public RenderFragment? ChildContent { get; set; }
-}

TaxBaik.Web/Components/Admin/Shared/BusinessDayCalculator.cs

@@ -1,79 +0,0 @@
-namespace TaxBaik.Web.Components.Admin.Shared;
-
-public static class BusinessDayCalculator
-{
-    private sealed record HolidayWindow(DateOnly Start, DateOnly End)
-    {
-        public IEnumerable<DateOnly> Dates()
-        {
-            for (var date = Start; date <= End; date = date.AddDays(1))
-            {
-                yield return date;
-            }
-        }
-    }
-
-    private static readonly HolidayWindow[] HolidayWindows =
-    {
-        new(new DateOnly(2026, 1, 1), new DateOnly(2026, 1, 1)),
-        new(new DateOnly(2026, 2, 16), new DateOnly(2026, 2, 18)),
-        new(new DateOnly(2026, 3, 1), new DateOnly(2026, 3, 2)),
-        new(new DateOnly(2026, 5, 5), new DateOnly(2026, 5, 5)),
-        new(new DateOnly(2026, 6, 6), new DateOnly(2026, 6, 6)),
-        new(new DateOnly(2026, 8, 15), new DateOnly(2026, 8, 17)),
-        new(new DateOnly(2026, 9, 24), new DateOnly(2026, 9, 26)),
-        new(new DateOnly(2026, 10, 3), new DateOnly(2026, 10, 5)),
-        new(new DateOnly(2026, 10, 9), new DateOnly(2026, 10, 9)),
-        new(new DateOnly(2026, 12, 25), new DateOnly(2026, 12, 25)),
-        new(new DateOnly(2027, 1, 1), new DateOnly(2027, 1, 1)),
-        new(new DateOnly(2027, 2, 6), new DateOnly(2027, 2, 9)),
-        new(new DateOnly(2027, 3, 1), new DateOnly(2027, 3, 2)),
-        new(new DateOnly(2027, 5, 5), new DateOnly(2027, 5, 5)),
-        new(new DateOnly(2027, 5, 13), new DateOnly(2027, 5, 13)),
-        new(new DateOnly(2027, 6, 6), new DateOnly(2027, 6, 6)),
-        new(new DateOnly(2027, 8, 15), new DateOnly(2027, 8, 16)),
-        new(new DateOnly(2027, 9, 14), new DateOnly(2027, 9, 16)),
-        new(new DateOnly(2027, 10, 3), new DateOnly(2027, 10, 4)),
-        new(new DateOnly(2027, 10, 9), new DateOnly(2027, 10, 11)),
-        new(new DateOnly(2027, 12, 25), new DateOnly(2027, 12, 26))
-    };
-
-    private static readonly HashSet<DateOnly> HolidayDates = BuildHolidayDates();
-
-    public static DateOnly GetEffectiveDueDate(DateOnly dueDate)
-    {
-        var effectiveDate = dueDate;
-        while (!IsBusinessDay(effectiveDate))
-        {
-            effectiveDate = effectiveDate.AddDays(1);
-        }
-
-        return effectiveDate;
-    }
-
-    public static int GetDday(DateOnly dueDate, DateOnly? referenceDate = null)
-    {
-        var today = referenceDate ?? DateOnly.FromDateTime(DateTime.Today);
-        var effectiveDueDate = GetEffectiveDueDate(dueDate);
-        return effectiveDueDate.DayNumber - today.DayNumber;
-    }
-
-    public static bool IsBusinessDay(DateOnly date)
-        => date.DayOfWeek is not DayOfWeek.Saturday and not DayOfWeek.Sunday
-           && !HolidayDates.Contains(date);
-
-    private static HashSet<DateOnly> BuildHolidayDates()
-    {
-        var holidays = new HashSet<DateOnly>();
-
-        foreach (var window in HolidayWindows)
-        {
-            foreach (var date in window.Dates())
-            {
-                holidays.Add(date);
-            }
-        }
-
-        return holidays;
-    }
-}

TaxBaik.Web/Components/Admin/Shared/CommonCodeSelect.razor

@@ -1,56 +0,0 @@
-@using TaxBaik.Domain.Entities
-@using TaxBaik.Web.Services.AdminClients
-@inject ICommonCodeBrowserClient CommonCodeClient
-
-<MudSelect T="string"
-           Value="Value"
-           ValueChanged="ValueChanged"
-           Label="@Label"
-           Variant="@Variant"
-           FullWidth="@FullWidth"
-           Class="@Class"
-           Required="@Required"
-           Clearable="@Clearable"
-           Disabled="@Disabled">
-    @if (!string.IsNullOrWhiteSpace(Placeholder))
-    {
-        <MudSelectItem Value="@string.Empty">@Placeholder</MudSelectItem>
-    }
-    @foreach (var item in items)
-    {
-        <MudSelectItem Value="@item.CodeValue">@item.CodeName</MudSelectItem>
-    }
-</MudSelect>
-
-@code {
-    [Parameter] public string? Value { get; set; }
-    [Parameter] public EventCallback<string?> ValueChanged { get; set; }
-    [Parameter] public string Group { get; set; } = string.Empty;
-    [Parameter] public string Label { get; set; } = string.Empty;
-    [Parameter] public Variant Variant { get; set; } = Variant.Outlined;
-    [Parameter] public bool FullWidth { get; set; } = true;
-    [Parameter] public string? Class { get; set; }
-    [Parameter] public bool Required { get; set; }
-    [Parameter] public bool Clearable { get; set; }
-    [Parameter] public bool Disabled { get; set; }
-    [Parameter] public string? Placeholder { get; set; }
-
-    private List<CommonCode> items = [];
-
-    protected override async Task OnParametersSetAsync()
-    {
-        var normalizedGroup = Group?.Trim() ?? string.Empty;
-        if (!string.Equals(normalizedGroup, _loadedGroup, StringComparison.OrdinalIgnoreCase))
-        {
-            _loadedGroup = normalizedGroup;
-            items = string.IsNullOrWhiteSpace(normalizedGroup)
-                ? []
-                : (await CommonCodeClient.GetByGroupAsync(normalizedGroup))
-                    .OrderBy(x => x.SortOrder)
-                    .ThenBy(x => x.CodeName)
-                    .ToList();
-        }
-    }
-
-    private string? _loadedGroup;
-}

TaxBaik.Web/Components/Admin/_Imports.razor

@@ -8,9 +8,6 @@
 @using Microsoft.AspNetCore.Authorization
 @using Microsoft.JSInterop
 @using MudBlazor
-@using TaxBaik.Application.DTOs
 @using TaxBaik.Web.Services
-@using TaxBaik.Web.Services.AdminClients
 @using TaxBaik.Domain.Entities
 @using TaxBaik.Application.Services
-@using TaxBaik.Web.Components.Admin.Shared

TaxBaik.Web/Controllers/AdminDashboardController.cs

@@ -9,7 +9,7 @@ namespace TaxBaik.Web.Controllers;
 /// SOLID: Single Responsibility - 대시보드 데이터만 담당
 /// </summary>
 [ApiController]
-[Route("api/admin-dashboard")]
+[Route("api/[controller]")]
 [Authorize]
 public class AdminDashboardController : ControllerBase
 {

TaxBaik.Web/Controllers/BlogController.cs

@@ -32,16 +32,6 @@ public class BlogController : ControllerBase
         return Ok(post);
     }
 
-    [HttpGet("admin/{id:int}")]
-    [Authorize]
-    public async Task<IActionResult> GetById(int id)
-    {
-        var post = await _blogService.GetByIdAsync(id);
-        if (post == null)
-            return NotFound(new ProblemDetails { Title = "포스트를 찾을 수 없습니다.", Status = StatusCodes.Status404NotFound });
-        return Ok(post);
-    }
-
     [HttpGet("admin/all")]
     [Authorize]
     public async Task<IActionResult> GetAll()
@@ -94,7 +84,7 @@ public class BlogController : ControllerBase
     [Authorize]
     public async Task<IActionResult> Delete(int id)
     {
-        await _blogService.ArchiveAsync(id);
+        await _blogService.DeleteAsync(id);
         return NoContent();
     }
 }

TaxBaik.Web/Controllers/CommonCodeController.cs

@@ -1,80 +0,0 @@
-using Microsoft.AspNetCore.Authorization;
-using Microsoft.AspNetCore.Mvc;
-using TaxBaik.Application.Services;
-using TaxBaik.Domain.Entities;
-
-namespace TaxBaik.Web.Controllers;
-
-[ApiController]
-[Route("api/[controller]")]
-[Authorize]
-public class CommonCodeController(CommonCodeService commonCodeService) : ControllerBase
-{
-    [HttpGet]
-    public async Task<IActionResult> GetAllActive()
-    {
-        try
-        {
-            var codes = await commonCodeService.GetAllActiveAsync();
-            return Ok(codes);
-        }
-        catch (Exception ex)
-        {
-            return StatusCode(500, new { error = "공통코드 조회 실패", message = ex.Message });
-        }
-    }
-
-    [HttpGet("group/{group}")]
-    public async Task<IActionResult> GetByGroup(string group)
-    {
-        try
-        {
-            var codes = await commonCodeService.GetByGroupAsync(group);
-            return Ok(codes);
-        }
-        catch (Exception ex)
-        {
-            return StatusCode(500, new { error = "그룹별 공통코드 조회 실패", message = ex.Message });
-        }
-    }
-
-    [HttpGet("groups")]
-    public async Task<IActionResult> GetGroups()
-    {
-        try
-        {
-            var groups = await commonCodeService.GetAllGroupsAsync();
-            return Ok(groups);
-        }
-        catch (Exception ex)
-        {
-            return StatusCode(500, new { error = "공통코드 그룹 조회 실패", message = ex.Message });
-        }
-    }
-
-    [HttpGet("{group}/{value}")]
-    public async Task<IActionResult> Get(string group, string value)
-    {
-        var code = await commonCodeService.GetAsync(group, value);
-        return code is null ? NotFound() : Ok(code);
-    }
-
-    [HttpPost]
-    public async Task<IActionResult> Upsert([FromBody] CommonCode code)
-    {
-        if (string.IsNullOrWhiteSpace(code.CodeGroup) || string.IsNullOrWhiteSpace(code.CodeValue) || string.IsNullOrWhiteSpace(code.CodeName))
-            return BadRequest(new { error = "코드 그룹, 값, 이름은 필수입니다." });
-        if (code.CodeValue.Contains(' '))
-            return BadRequest(new { error = "code_value에는 공백을 사용할 수 없습니다." });
-
-        await commonCodeService.UpsertAsync(code);
-        return Ok(code);
-    }
-
-    [HttpDelete("{group}/{value}")]
-    public async Task<IActionResult> Delete(string group, string value)
-    {
-        await commonCodeService.DeleteAsync(group, value);
-        return NoContent();
-    }
-}

TaxBaik.Web/Controllers/ConsultingActivityController.cs

@@ -24,20 +24,6 @@ public class ConsultingActivityController(ConsultingActivityService service) : C
         }
     }
 
-    [HttpGet]
-    public async Task<IActionResult> GetAll()
-    {
-        try
-        {
-            var activities = await service.GetAllAsync();
-            return Ok(activities);
-        }
-        catch (Exception ex)
-        {
-            return StatusCode(500, new { error = "조회 실패", message = ex.Message });
-        }
-    }
-
     [HttpGet("{id:int}")]
     public async Task<IActionResult> GetById(int id)
     {

TaxBaik.Web/Controllers/ContractController.cs

@@ -24,20 +24,6 @@ public class ContractController(ContractService service) : ControllerBase
         }
     }
 
-    [HttpGet]
-    public async Task<IActionResult> GetAll()
-    {
-        try
-        {
-            var contracts = await service.GetAllAsync();
-            return Ok(contracts);
-        }
-        catch (Exception ex)
-        {
-            return StatusCode(500, new { error = "조회 실패", message = ex.Message });
-        }
-    }
-
     [HttpGet("{id:int}")]
     public async Task<IActionResult> GetById(int id)
     {

TaxBaik.Web/Controllers/InquiryController.cs

@@ -1,7 +1,6 @@
 using Microsoft.AspNetCore.Authorization;
 using Microsoft.AspNetCore.Mvc;
 using System.Security.Claims;
-using TaxBaik.Application.DTOs;
 using TaxBaik.Application.Services;
 
 namespace TaxBaik.Web.Controllers;
@@ -20,7 +19,7 @@ public class InquiryController : ControllerBase
     }
 
     [HttpPost]
-    public async Task<IActionResult> Submit([FromBody] SubmitInquiryDto request)
+    public async Task<IActionResult> Submit([FromBody] SubmitInquiryRequest request)
     {
         if (string.IsNullOrWhiteSpace(request.Name) || string.IsNullOrWhiteSpace(request.Phone))
             return BadRequest(new ProblemDetails { Title = "이름과 전화번호를 입력하세요.", Status = StatusCodes.Status400BadRequest });
@@ -100,23 +99,6 @@ public class InquiryController : ControllerBase
         }
     }
 
-    [HttpPut("{id}")]
-    [Authorize]
-    public async Task<IActionResult> Update(int id, [FromBody] UpdateInquiryDto request)
-    {
-        try
-        {
-            var result = await _inquiryService.UpdateAsync(id, request);
-            if (result == null)
-                return NotFound(new ProblemDetails { Title = "문의를 찾을 수 없습니다.", Status = StatusCodes.Status404NotFound });
-            return Ok(result);
-        }
-        catch (ValidationException ex)
-        {
-            return BadRequest(new ProblemDetails { Title = ex.Message, Status = StatusCodes.Status400BadRequest });
-        }
-    }
-
     [HttpPost("{id}/convert-to-client")]
     [Authorize]
     public async Task<IActionResult> ConvertToClient(int id, [FromBody] ConvertToClientRequest request)
@@ -147,6 +129,16 @@ public class InquiryController : ControllerBase
     }
 }
 
+public class SubmitInquiryRequest
+{
+    public string Name { get; set; } = string.Empty;
+    public string Phone { get; set; } = string.Empty;
+    public string? Email { get; set; }
+    public string ServiceType { get; set; } = string.Empty;
+    public string Message { get; set; } = string.Empty;
+    public bool SuppressNotification { get; set; }
+}
+
 public class UpdateStatusRequest
 {
     public string Status { get; set; } = string.Empty;