From f2a45cc33a9cdabac0f23394bd60d9e34254575a Mon Sep 17 00:00:00 2001
From: SeoJHeasdw <tjwpghangel@naver.com>
Date: Tue, 17 Jun 2025 14:42:42 +0900
Subject: [PATCH 01/11] release

---
 src/views/DashboardView.vue | 52 +++++++++++++++++++++++++++----------
 1 file changed, 39 insertions(+), 13 deletions(-)

diff --git a/src/views/DashboardView.vue b/src/views/DashboardView.vue
index f69614e..2b3b52b 100644
--- a/src/views/DashboardView.vue
+++ b/src/views/DashboardView.vue
@@ -975,8 +975,13 @@ const updateAiRecommendation = (aiData) => {
       title: aiData.tipContent ? aiData.tipContent.substring(0, 50) + '...' : 'AI 마케팅 추천',
       sections: {
         ideas: {
-          title: '추천 아이디어',
+          title: '1. 추천 아이디어',
           items: [aiData.tipContent || '맞춤형 마케팅 전략을 제안드립니다.']
+        },
+        costs: {
+          title: '2. 예상 효과',
+          items: ['고객 관심 유도 및 매출 상승', 'SNS를 통한 브랜드 인지도 상승'],
+          effects: ['재방문율 및 공유 유도', '지역 내 인지도 향상']
         }
       }
     }
@@ -987,6 +992,31 @@ const updateAiRecommendation = (aiData) => {
 }
 
 
+/**
+ * Fallback AI 추천 사용
+ */
+const useFallbackAiRecommendation = () => {
+  console.log('Fallback AI 추천 사용')
+  aiRecommendation.value = {
+    emoji: '☀️',
+    title: '여름 시즌 마케팅 전략',
+    sections: {
+      ideas: {
+        title: '1. 기본 추천사항',
+        items: [
+          '계절 메뉴 개발 및 프로모션',
+          'SNS 마케팅 활용',
+          '지역 고객 대상 이벤트 기획'
+        ]
+      },
+      costs: {
+        title: '2. 기대 효과',
+        items: ['매출 향상', '고객 만족도 증가'],
+        effects: ['브랜드 인지도 상승', '재방문 고객 증가']
+      }
+    }
+  }
+}
 
 // 계산된 속성들 (기존과 동일)
 const currentChartData = computed(() => chartData.value[chartPeriod.value])
@@ -1193,10 +1223,6 @@ const showDataTooltip = (index, event) => {
   
   if (!data) return
   
-  // 차트 영역의 위치 계산
-  const chartArea = event.target.closest('.chart-area')
-  const rect = chartArea.getBoundingClientRect()
-  
   // ⚠️ 원본 데이터가 있으면 사용, 없으면 기본 변환 로직 사용
   let actualSales, actualTarget
   
@@ -1215,8 +1241,8 @@ const showDataTooltip = (index, event) => {
   
   tooltip.value = {
     show: true,
-    x: event.clientX - rect.left,
-    y: event.clientY - rect.top - 80,
+    x: event.clientX,
+    y: event.clientY - 80,
     title: data.label,
     sales: actualSales,
     target: actualTarget
@@ -1454,7 +1480,6 @@ onMounted(async () => {
   top: 0;
   bottom: 0;
   width: 40px;
-  z-index: 0;
 }
 
 .y-label {
@@ -1470,7 +1495,6 @@ onMounted(async () => {
   right: 0;
   top: 0;
   bottom: 0;
-  z-index: 0;
 }
 
 .grid-line {
@@ -1487,7 +1511,6 @@ onMounted(async () => {
   top: 0;
   width: 100%;
   height: 100%;
-  z-index: 1;
 }
 
 .data-points {
@@ -1496,7 +1519,6 @@ onMounted(async () => {
   right: 0;
   top: 0;
   bottom: 0;
-  z-index: 2;
 }
 
 .data-point {
@@ -1547,8 +1569,8 @@ onMounted(async () => {
 }
 
 .chart-tooltip {
-  position: absolute;
-  z-index: 99999;
+  position: fixed;
+  z-index: 1000;
   pointer-events: none;
 }
 
@@ -1566,6 +1588,10 @@ onMounted(async () => {
   margin-bottom: 4px;
 }
 
+.tooltip-sales,
+.tooltip-target {
+  margin: 2px 0;
+}
 
 /* AI 추천 카드 새로운 스타일 */
 .ai-recommend-card {

From 30754fd3f20c14af4200d816ca48b702f089d5c5 Mon Sep 17 00:00:00 2001
From: SeoJHeasdw <tjwpghangel@naver.com>
Date: Tue, 17 Jun 2025 14:44:11 +0900
Subject: [PATCH 02/11] release

---
 src/views/LoginView.vue | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/src/views/LoginView.vue b/src/views/LoginView.vue
index f10d764..a1cfd37 100644
--- a/src/views/LoginView.vue
+++ b/src/views/LoginView.vue
@@ -29,7 +29,7 @@
                 @keyup.enter="handleLogin"
               />
 
-              <!-- 비밀번호 입력 -->
+              <!-- 비밀번호 입력  -->
               <v-text-field
                 v-model="credentials.password"
                 label="비밀번호"
@@ -45,6 +45,7 @@
                 @keyup.enter="handleLogin"
               />
 
+              
               <!-- 로그인 옵션 -->
               <div class="d-flex justify-space-between align-center mb-6">
                 <v-checkbox

From 31a75ba2292639918b4f1f2462fa3141fab1af45 Mon Sep 17 00:00:00 2001
From: SeoJHeasdw <tjwpghangel@naver.com>
Date: Tue, 17 Jun 2025 14:46:18 +0900
Subject: [PATCH 03/11] front

---
 src/views/LoginView.vue | 1 -
 1 file changed, 1 deletion(-)

diff --git a/src/views/LoginView.vue b/src/views/LoginView.vue
index a1cfd37..f6036cc 100644
--- a/src/views/LoginView.vue
+++ b/src/views/LoginView.vue
@@ -45,7 +45,6 @@
                 @keyup.enter="handleLogin"
               />
 
-              
               <!-- 로그인 옵션 -->
               <div class="d-flex justify-space-between align-center mb-6">
                 <v-checkbox

From d2356fb723d7d4e6a43ed5587b4c702f019b9111 Mon Sep 17 00:00:00 2001
From: SeoJHeasdw <tjwpghangel@naver.com>
Date: Tue, 17 Jun 2025 14:47:55 +0900
Subject: [PATCH 04/11] front test

---
 src/views/LoginView.vue | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/views/LoginView.vue b/src/views/LoginView.vue
index f6036cc..a1cfd37 100644
--- a/src/views/LoginView.vue
+++ b/src/views/LoginView.vue
@@ -45,6 +45,7 @@
                 @keyup.enter="handleLogin"
               />
 
+              
               <!-- 로그인 옵션 -->
               <div class="d-flex justify-space-between align-center mb-6">
                 <v-checkbox

From bfc4d600e21944629a3f5ddd77c4e0592685b3d3 Mon Sep 17 00:00:00 2001
From: SeoJHeasdw <tjwpghangel@naver.com>
Date: Tue, 17 Jun 2025 17:44:14 +0900
Subject: [PATCH 05/11] release

---
 src/services/content.js           |  273 +++---
 src/store/content.js              |  435 ++++++---
 src/utils/constants.js            |  294 +++---
 src/views/ContentCreationView.vue | 1502 +++++++++++++++--------------
 src/views/DashboardView.vue       |   48 +-
 5 files changed, 1399 insertions(+), 1153 deletions(-)

diff --git a/src/services/content.js b/src/services/content.js
index 1a3a44f..99ee797 100644
--- a/src/services/content.js
+++ b/src/services/content.js
@@ -1,157 +1,172 @@
-//* src/services/content.js - 기존 파일 수정 (API 설계서 기준)
+//* src/services/content.js
 import { contentApi, handleApiError, formatSuccessResponse } from './api.js'
 
 /**
  * 마케팅 콘텐츠 관련 API 서비스
- * API 설계서 기준으로 수정됨
+ * 백엔드 SnsContentCreateRequest DTO에 맞게 수정
  */
 class ContentService {
   /**
-   * SNS 게시물 생성 (CON-005: SNS 게시물 생성)
+   * SNS 게시물 생성
    * @param {Object} contentData - SNS 콘텐츠 생성 정보
    * @returns {Promise<Object>} 생성된 SNS 콘텐츠
    */
   async generateSnsContent(contentData) {
     try {
-      const response = await contentApi.post('/sns/generate', {
-        storeId: contentData.storeId,
-        platform: contentData.platform,
+      console.log('🚀 SNS 콘텐츠 생성 요청:', contentData)
+      
+      // 백엔드 SnsContentCreateRequest DTO에 맞는 데이터 구조
+      const requestData = {
+        // === 기본 정보 ===
+        storeId: contentData.storeId || 1,
+        storeName: contentData.storeName || '테스트 매장',
+        storeType: contentData.storeType || '음식점',
+        platform: this.mapPlatform(contentData.platform),
         title: contentData.title,
-        category: contentData.category,
-        requirement: contentData.requirement || contentData.requirements,
-        toneAndManner: contentData.toneAndManner,
-        emotionalIntensity: contentData.emotionalIntensity || contentData.emotionIntensity,
-        targetAudience: contentData.targetAudience,
-        promotionalType: contentData.promotionalType || contentData.promotionType,
-        eventName: contentData.eventName,
-        eventDate: contentData.eventDate,
-        hashtagStyle: contentData.hashtagStyle,
-        hashtagCount: contentData.hashtagCount || 10,
-        includeCallToAction: contentData.includeCallToAction || false,
-        includeEmoji: contentData.includeEmoji || true,
-        contentLength: contentData.contentLength || '보통'
-      })
+        
+        // === 콘텐츠 생성 조건 ===
+        category: contentData.category || this.mapTargetToCategory(contentData.targetType),
+        requirement: contentData.requirements || contentData.content || '',
+        target: contentData.targetType || '일반 고객',
+        contentType: 'SNS 게시물',
+        
+        // === 이벤트 정보 ===
+        eventName: contentData.eventName || null,
+        startDate: contentData.startDate ? this.formatDate(contentData.startDate) : null,
+        endDate: contentData.endDate ? this.formatDate(contentData.endDate) : null,
+        
+        // === 미디어 정보 ===
+        images: contentData.images || [],
+        photoStyle: this.mapPhotoStyle(contentData.aiOptions?.photoStyle),
+        
+        // === 추가 옵션 ===
+        includeHashtags: true,
+        includeEmojis: true,
+        includeCallToAction: true,
+        includeLocationInfo: false
+      }
 
-      return formatSuccessResponse(response.data.data, 'SNS 게시물이 생성되었습니다.')
+      console.log('📤 백엔드 DTO 맞춤 데이터:', requestData)
+      
+      const response = await contentApi.post('/sns/generate', requestData)
+      
+      console.log('📥 API 응답:', response.data)
+      
+      // 응답 데이터 구조에 맞게 처리
+      const responseData = response.data.data || response.data
+      
+      return formatSuccessResponse({
+        content: responseData.content || responseData,
+        hashtags: responseData.hashtags || [],
+        ...responseData
+      }, 'SNS 게시물이 생성되었습니다.')
     } catch (error) {
+      console.error('❌ SNS 콘텐츠 생성 실패:', error)
       return handleApiError(error)
     }
   }
 
   /**
-   * SNS 게시물 저장 (CON-010: SNS 게시물 저장)
+   * 플랫폼 매핑 (프론트엔드 -> 백엔드)
+   */
+  mapPlatform(platform) {
+    const mapping = {
+      'instagram': 'INSTAGRAM',
+      'naver_blog': 'NAVER_BLOG', 
+      'facebook': 'FACEBOOK',
+      'kakao_story': 'KAKAO_STORY'
+    }
+    return mapping[platform] || 'INSTAGRAM'
+  }
+
+  /**
+   * 타겟 타입을 카테고리로 매핑
+   */
+  mapTargetToCategory(targetType) {
+    const mapping = {
+      'new_menu': '메뉴소개',
+      'discount': '이벤트',
+      'store': '인테리어', 
+      'event': '이벤트'
+    }
+    return mapping[targetType] || '메뉴소개'
+  }
+
+  /**
+   * 날짜 형식 변환 (YYYY-MM-DD -> LocalDate)
+   */
+  formatDate(dateString) {
+    if (!dateString) return null
+    // YYYY-MM-DD 형식이 LocalDate와 호환됨
+    return dateString
+  }
+
+  /**
+   * 사진 스타일 매핑
+   */
+  mapPhotoStyle(style) {
+    const mapping = {
+      'bright': '밝고 화사한',
+      'calm': '차분하고 세련된',
+      'vintage': '빈티지한',
+      'modern': '모던한',
+      'natural': '자연스러운'
+    }
+    return mapping[style] || '밝고 화사한'
+  }
+
+  /**
+   * SNS 게시물 저장
    * @param {Object} saveData - 저장할 SNS 콘텐츠 정보
    * @returns {Promise<Object>} 저장 결과
    */
   async saveSnsContent(saveData) {
     try {
-      const response = await contentApi.post('/sns/save', {
+      console.log('💾 SNS 콘텐츠 저장 요청:', saveData)
+      
+      // 백엔드 SnsContentSaveRequest DTO에 맞는 구조로 변환
+      const requestData = {
         title: saveData.title,
         content: saveData.content,
-        hashtags: saveData.hashtags,
-        platform: saveData.platform,
-        category: saveData.category,
-        toneAndManner: saveData.toneAndManner,
-        targetAudience: saveData.targetAudience,
-        promotionalType: saveData.promotionalType,
+        hashtags: saveData.hashtags || [],
+        platform: this.mapPlatform(saveData.platform),
+        category: saveData.category || '메뉴소개',
+        // 백엔드 DTO에서 지원하는 필드들만 포함
         eventName: saveData.eventName,
         eventDate: saveData.eventDate,
         status: saveData.status || 'DRAFT'
-      })
+      }
+
+      console.log('📤 저장 요청 데이터:', requestData)
+
+      const response = await contentApi.post('/sns/save', requestData)
 
       return formatSuccessResponse(response.data.data, 'SNS 게시물이 저장되었습니다.')
     } catch (error) {
+      console.error('❌ SNS 콘텐츠 저장 실패:', error)
       return handleApiError(error)
     }
   }
 
   /**
-   * 홍보 포스터 생성 (CON-015: 홍보 포스터 생성)
-   * @param {Object} posterData - 포스터 생성 정보
-   * @returns {Promise<Object>} 생성된 포스터
-   */
-  async generatePoster(posterData) {
-    try {
-      const response = await contentApi.post('/poster/generate', {
-        storeId: posterData.storeId,
-        title: posterData.title,
-        targetType: posterData.targetType,
-        eventName: posterData.eventName,
-        eventDate: posterData.eventDate,
-        discountInfo: posterData.discountInfo,
-        designStyle: posterData.designStyle,
-        colorScheme: posterData.colorScheme,
-        includeQrCode: posterData.includeQrCode || false,
-        includeContact: posterData.includeContact || true,
-        imageStyle: posterData.imageStyle || posterData.photoStyle,
-        layoutType: posterData.layoutType,
-        sizes: posterData.sizes || ['1:1', '9:16', '16:9']
-      })
-
-      return formatSuccessResponse(response.data.data, '홍보 포스터가 생성되었습니다.')
-    } catch (error) {
-      return handleApiError(error)
-    }
-  }
-
-  /**
-   * 홍보 포스터 저장 (CON-016: 홍보 포스터 저장)
-   * @param {Object} saveData - 저장할 포스터 정보
-   * @returns {Promise<Object>} 저장 결과
-   */
-  async savePoster(saveData) {
-    try {
-      const response = await contentApi.post('/poster/save', {
-        title: saveData.title,
-        images: saveData.images,
-        posterSizes: saveData.posterSizes,
-        targetType: saveData.targetType,
-        eventName: saveData.eventName,
-        status: saveData.status || 'DRAFT'
-      })
-
-      return formatSuccessResponse(response.data.data, '홍보 포스터가 저장되었습니다.')
-    } catch (error) {
-      return handleApiError(error)
-    }
-  }
-
-  /**
-   * 콘텐츠 목록 조회 (CON-020: 마케팅 콘텐츠 이력)
-   * @param {Object} filters - 필터링 옵션
+   * 콘텐츠 목록 조회
+   * @param {Object} filters - 필터 조건
    * @returns {Promise<Object>} 콘텐츠 목록
    */
-  async getContents(filters = {}) {
+  async getContentList(filters = {}) {
     try {
-      const queryParams = new URLSearchParams()
-
-      if (filters.contentType) queryParams.append('contentType', filters.contentType)
-      if (filters.platform) queryParams.append('platform', filters.platform)
-      if (filters.period) queryParams.append('period', filters.period)
-      if (filters.sortBy) queryParams.append('sortBy', filters.sortBy || 'latest')
-      if (filters.page) queryParams.append('page', filters.page)
-      if (filters.size) queryParams.append('size', filters.size || 20)
-      if (filters.search) queryParams.append('search', filters.search)
-
-      const response = await contentApi.get(`/?${queryParams.toString()}`)
-
+      const params = new URLSearchParams()
+      
+      if (filters.contentType) params.append('contentType', filters.contentType)
+      if (filters.platform) params.append('platform', filters.platform)
+      if (filters.period) params.append('period', filters.period)
+      if (filters.sortBy) params.append('sortBy', filters.sortBy)
+      
+      const response = await contentApi.get(`/list?${params.toString()}`)
+      
       return formatSuccessResponse(response.data.data, '콘텐츠 목록을 조회했습니다.')
     } catch (error) {
-      return handleApiError(error)
-    }
-  }
-
-  /**
-   * 진행 중인 콘텐츠 조회
-   * @param {string} period - 조회 기간
-   * @returns {Promise<Object>} 진행 중인 콘텐츠 목록
-   */
-  async getOngoingContents(period = 'month') {
-    try {
-      const response = await contentApi.get(`/ongoing?period=${period}`)
-
-      return formatSuccessResponse(response.data.data, '진행 중인 콘텐츠를 조회했습니다.')
-    } catch (error) {
+      console.error('❌ 콘텐츠 목록 조회 실패:', error)
       return handleApiError(error)
     }
   }
@@ -164,51 +179,29 @@ class ContentService {
   async getContentDetail(contentId) {
     try {
       const response = await contentApi.get(`/${contentId}`)
-
+      
       return formatSuccessResponse(response.data.data, '콘텐츠 상세 정보를 조회했습니다.')
     } catch (error) {
+      console.error('❌ 콘텐츠 상세 조회 실패:', error)
       return handleApiError(error)
     }
   }
 
   /**
-   * 콘텐츠 수정
-   * @param {number} contentId - 콘텐츠 ID
-   * @param {Object} updateData - 수정할 콘텐츠 정보
-   * @returns {Promise<Object>} 수정 결과
-   */
-  async updateContent(contentId, updateData) {
-    try {
-      const response = await contentApi.put(`/${contentId}`, {
-        title: updateData.title,
-        content: updateData.content,
-        hashtags: updateData.hashtags,
-        startDate: updateData.startDate,
-        endDate: updateData.endDate,
-        status: updateData.status
-      })
-
-      return formatSuccessResponse(response.data.data, '콘텐츠가 수정되었습니다.')
-    } catch (error) {
-      return handleApiError(error)
-    }
-  }
-
-  /**
-   * 콘텐츠 삭제 (CON-025: 콘텐츠 삭제)
+   * 콘텐츠 삭제
    * @param {number} contentId - 콘텐츠 ID
    * @returns {Promise<Object>} 삭제 결과
    */
   async deleteContent(contentId) {
     try {
-      await contentApi.delete(`/${contentId}`)
-
+      const response = await contentApi.delete(`/${contentId}`)
+      
       return formatSuccessResponse(null, '콘텐츠가 삭제되었습니다.')
     } catch (error) {
+      console.error('❌ 콘텐츠 삭제 실패:', error)
       return handleApiError(error)
     }
   }
 }
 
-export const contentService = new ContentService()
-export default contentService
\ No newline at end of file
+export default new ContentService()
\ No newline at end of file
diff --git a/src/store/content.js b/src/store/content.js
index a1430e9..176e852 100644
--- a/src/store/content.js
+++ b/src/store/content.js
@@ -1,168 +1,307 @@
-//* src/store/content.js 수정 - 기존 구조 유지하고 API 연동만 추가
+//* src/store/content.js
 import { defineStore } from 'pinia'
-import { ref, computed } from 'vue'
-import contentService from '@/services/content'
+import ContentService from '@/services/content.js'
+import { PLATFORM_SPECS, PLATFORM_LABELS } from '@/utils/constants'
 
-export const useContentStore = defineStore('content', () => {
-  // 기존 상태들 유지
-  const contentList = ref([])
-  const ongoingContents = ref([])
-  const selectedContent = ref(null)
-  const generatedContent = ref(null)
-  const isLoading = ref(false)
-
-  // 기존 computed 속성들 유지
-  const contentCount = computed(() => contentList.value.length)
-  const ongoingContentCount = computed(() => ongoingContents.value.length)
-
-  // generateContent를 실제 API 호출로 수정
-  const generateContent = async (type, formData) => {
-    isLoading.value = true
+/**
+ * 콘텐츠 관련 상태 관리
+ */
+export const useContentStore = defineStore('content', {
+  state: () => ({
+    // 콘텐츠 목록
+    contentList: [],
+    totalCount: 0,
     
-    try {
-      let result
-      if (type === 'sns') {
-        result = await contentService.generateSnsContent(formData)
-      } else if (type === 'poster') {
-        result = await contentService.generatePoster(formData)
+    // 선택된 콘텐츠
+    selectedContent: null,
+    
+    // 로딩 상태
+    loading: false,
+    generating: false,
+    
+    // 필터 상태
+    filters: {
+      contentType: '',
+      platform: '',
+      period: '',
+      sortBy: 'createdAt_desc'
+    },
+    
+    // 페이지네이션
+    pagination: {
+      page: 1,
+      itemsPerPage: 10
+    }
+  }),
+
+  getters: {
+    /**
+     * 필터링된 콘텐츠 목록
+     */
+    filteredContents: (state) => {
+      let filtered = [...state.contentList]
+      
+      if (state.filters.contentType) {
+        filtered = filtered.filter(content => content.type === state.filters.contentType)
       }
       
-      if (result.success) {
-        generatedContent.value = result.data
-        return { success: true, data: result.data }
-      } else {
-        return { success: false, error: result.message }
-      }
-    } catch (error) {
-      return { success: false, error: '네트워크 오류가 발생했습니다.' }
-    } finally {
-      isLoading.value = false
-    }
-  }
-
-  // saveContent를 실제 API 호출로 수정
-  const saveContent = async (type, contentData) => {
-    isLoading.value = true
-    
-    try {
-      let result
-      if (type === 'sns') {
-        result = await contentService.saveSnsContent(contentData)
-      } else if (type === 'poster') {
-        result = await contentService.savePoster(contentData)
+      if (state.filters.platform) {
+        filtered = filtered.filter(content => content.platform === state.filters.platform)
       }
       
-      if (result.success) {
-        // 콘텐츠 목록 새로고침
-        await fetchContentList()
-        return { success: true, message: '콘텐츠가 저장되었습니다.' }
-      } else {
-        return { success: false, error: result.message }
-      }
-    } catch (error) {
-      return { success: false, error: '네트워크 오류가 발생했습니다.' }
-    } finally {
-      isLoading.value = false
-    }
-  }
-
-  // fetchContentList를 실제 API 호출로 수정
-  const fetchContentList = async (filters = {}) => {
-    isLoading.value = true
-    
-    try {
-      const result = await contentService.getContents(filters)
+      // 정렬
+      const [field, order] = state.filters.sortBy.split('_')
+      filtered.sort((a, b) => {
+        let aValue = a[field]
+        let bValue = b[field]
+        
+        if (field === 'createdAt' || field === 'updatedAt') {
+          aValue = new Date(aValue)
+          bValue = new Date(bValue)
+        }
+        
+        if (order === 'desc') {
+          return bValue > aValue ? 1 : -1
+        } else {
+          return aValue > bValue ? 1 : -1
+        }
+      })
       
-      if (result.success) {
-        contentList.value = result.data
-        return { success: true }
-      } else {
-        return { success: false, error: result.message }
-      }
-    } catch (error) {
-      return { success: false, error: '네트워크 오류가 발생했습니다.' }
-    } finally {
-      isLoading.value = false
-    }
-  }
+      return filtered
+    },
 
-  // fetchOngoingContents를 실제 API 호출로 수정
-  const fetchOngoingContents = async (period = 'month') => {
-    isLoading.value = true
-    
-    try {
-      const result = await contentService.getOngoingContents(period)
+    /**
+     * 페이지네이션된 콘텐츠 목록
+     */
+    paginatedContents: (state) => {
+      const start = (state.pagination.page - 1) * state.pagination.itemsPerPage
+      const end = start + state.pagination.itemsPerPage
+      return state.filteredContents.slice(start, end)
+    },
+
+    /**
+     * 총 페이지 수
+     */
+    totalPages: (state) => {
+      return Math.ceil(state.filteredContents.length / state.pagination.itemsPerPage)
+    }
+  },
+
+  actions: {
+    /**
+     * 콘텐츠 생성 (AI 기반)
+     */
+    async generateContent(contentData) {
+      this.generating = true
       
-      if (result.success) {
-        ongoingContents.value = result.data
-        return { success: true }
-      } else {
-        return { success: false, error: result.message }
+      try {
+        console.log('🎯 콘텐츠 생성 시작:', contentData)
+        
+        // 백엔드 DTO에 맞는 데이터 구조로 변환
+        const requestData = {
+          storeId: 1, // 현재는 하드코딩, 추후 로그인한 사용자의 매장 ID 사용
+          storeName: '테스트 매장', // 추후 실제 매장 정보 사용
+          storeType: '음식점', // 추후 실제 매장 업종 사용
+          platform: contentData.platform,
+          title: contentData.title,
+          category: contentData.category || this.mapTargetToCategory(contentData.targetType),
+          requirement: contentData.requirements || '',
+          target: contentData.targetType || '일반 고객',
+          contentType: 'SNS 게시물',
+          eventName: contentData.eventName,
+          startDate: contentData.startDate,
+          endDate: contentData.endDate,
+          images: contentData.images || [],
+          photoStyle: '밝고 화사한',
+          includeHashtags: true,
+          includeEmojis: true,
+          includeCallToAction: true,
+          includeLocationInfo: false
+        }
+        
+        const result = await ContentService.generateSnsContent(requestData)
+        
+        if (result.success) {
+          console.log('✅ 콘텐츠 생성 성공:', result.data)
+          return result.data
+        } else {
+          throw new Error(result.message || '콘텐츠 생성에 실패했습니다.')
+        }
+      } catch (error) {
+        console.error('❌ 콘텐츠 생성 실패:', error)
+        throw error
+      } finally {
+        this.generating = false
       }
-    } catch (error) {
-      return { success: false, error: '네트워크 오류가 발생했습니다.' }
-    } finally {
-      isLoading.value = false
-    }
-  }
+    },
 
-  // 콘텐츠 수정/삭제 메서드 추가
-  const updateContent = async (contentId, updateData) => {
-    isLoading.value = true
-    
-    try {
-      const result = await contentService.updateContent(contentId, updateData)
+    /**
+     * 타겟 타입을 카테고리로 매핑
+     */
+    mapTargetToCategory(targetType) {
+      const mapping = {
+        'new_menu': '메뉴소개',
+        'discount': '이벤트',
+        'store': '인테리어', 
+        'event': '이벤트'
+      }
+      return mapping[targetType] || '메뉴소개'
+    },
+
+    /**
+     * 플랫폼별 특성 조회
+     */
+    getPlatformSpec(platform) {
+      return PLATFORM_SPECS[platform] || null
+    },
+
+    /**
+     * 플랫폼 유효성 검사
+     */
+    validatePlatform(platform) {
+      return Object.keys(PLATFORM_SPECS).includes(platform)
+    },
+
+    /**
+     * 콘텐츠 저장
+     */
+    async saveContent(contentData) {
+      this.loading = true
       
-      if (result.success) {
-        await fetchContentList()
-        return { success: true, message: '콘텐츠가 수정되었습니다.' }
-      } else {
-        return { success: false, error: result.message }
+      try {
+        // 백엔드 DTO에 맞는 형식으로 데이터 정제
+        const saveData = {
+          title: contentData.title,
+          content: contentData.content,
+          hashtags: contentData.hashtags || [],
+          platform: contentData.platform, // 이미 백엔드 형식 (INSTAGRAM, NAVER_BLOG 등)
+          category: contentData.category || '메뉴소개',
+          eventName: contentData.eventName,
+          eventDate: contentData.eventDate,
+          status: contentData.status || 'DRAFT'
+        }
+        
+        const result = await ContentService.saveSnsContent(saveData)
+        
+        if (result.success) {
+          // 목록 새로고침
+          await this.fetchContentList()
+          return result.data
+        } else {
+          throw new Error(result.message || '콘텐츠 저장에 실패했습니다.')
+        }
+      } catch (error) {
+        console.error('❌ 콘텐츠 저장 실패:', error)
+        throw error
+      } finally {
+        this.loading = false
       }
-    } catch (error) {
-      return { success: false, error: '네트워크 오류가 발생했습니다.' }
-    } finally {
-      isLoading.value = false
-    }
-  }
+    },
 
-  const deleteContent = async (contentId) => {
-    isLoading.value = true
-    
-    try {
-      const result = await contentService.deleteContent(contentId)
+    /**
+     * 콘텐츠 목록 조회
+     */
+    async fetchContentList() {
+      this.loading = true
       
-      if (result.success) {
-        await fetchContentList()
-        return { success: true, message: '콘텐츠가 삭제되었습니다.' }
-      } else {
-        return { success: false, error: result.message }
+      try {
+        const result = await ContentService.getContentList(this.filters)
+        
+        if (result.success) {
+          this.contentList = result.data || []
+          this.totalCount = this.contentList.length
+        } else {
+          throw new Error(result.message || '콘텐츠 목록 조회에 실패했습니다.')
+        }
+      } catch (error) {
+        console.error('❌ 콘텐츠 목록 조회 실패:', error)
+        this.contentList = []
+        this.totalCount = 0
+      } finally {
+        this.loading = false
       }
-    } catch (error) {
-      return { success: false, error: '네트워크 오류가 발생했습니다.' }
-    } finally {
-      isLoading.value = false
-    }
-  }
+    },
 
-  return {
-    // 상태
-    contentList,
-    ongoingContents,
-    selectedContent,
-    generatedContent,
-    isLoading,
-    
-    // 컴퓨티드
-    contentCount,
-    ongoingContentCount,
-    
-    // 메서드
-    generateContent,
-    saveContent,
-    fetchContentList,
-    fetchOngoingContents,
-    updateContent,
-    deleteContent
+    /**
+     * 콘텐츠 상세 조회
+     */
+    async fetchContentDetail(contentId) {
+      this.loading = true
+      
+      try {
+        const result = await ContentService.getContentDetail(contentId)
+        
+        if (result.success) {
+          this.selectedContent = result.data
+          return result.data
+        } else {
+          throw new Error(result.message || '콘텐츠 상세 조회에 실패했습니다.')
+        }
+      } catch (error) {
+        console.error('❌ 콘텐츠 상세 조회 실패:', error)
+        throw error
+      } finally {
+        this.loading = false
+      }
+    },
+
+    /**
+     * 콘텐츠 삭제
+     */
+    async deleteContent(contentId) {
+      this.loading = true
+      
+      try {
+        const result = await ContentService.deleteContent(contentId)
+        
+        if (result.success) {
+          // 목록에서 제거
+          this.contentList = this.contentList.filter(content => content.id !== contentId)
+          this.totalCount = this.contentList.length
+          return true
+        } else {
+          throw new Error(result.message || '콘텐츠 삭제에 실패했습니다.')
+        }
+      } catch (error) {
+        console.error('❌ 콘텐츠 삭제 실패:', error)
+        throw error
+      } finally {
+        this.loading = false
+      }
+    },
+
+    /**
+     * 필터 설정
+     */
+    setFilters(newFilters) {
+      this.filters = { ...this.filters, ...newFilters }
+      this.pagination.page = 1 // 필터 변경 시 첫 페이지로
+    },
+
+    /**
+     * 페이지네이션 설정
+     */
+    setPagination(newPagination) {
+      this.pagination = { ...this.pagination, ...newPagination }
+    },
+
+    /**
+     * 상태 초기화
+     */
+    reset() {
+      this.contentList = []
+      this.selectedContent = null
+      this.totalCount = 0
+      this.filters = {
+        contentType: '',
+        platform: '',
+        period: '',
+        sortBy: 'createdAt_desc'
+      }
+      this.pagination = {
+        page: 1,
+        itemsPerPage: 10
+      }
+    }
   }
 })
\ No newline at end of file
diff --git a/src/utils/constants.js b/src/utils/constants.js
index 26b368f..eb7213a 100644
--- a/src/utils/constants.js
+++ b/src/utils/constants.js
@@ -7,15 +7,7 @@
 export const CONTENT_TYPES = {
   SNS: 'sns',
   POSTER: 'poster',
-  VIDEO: 'video',
-  BLOG: 'blog',
-}
-
-export const CONTENT_TYPE_LABELS = {
-  [CONTENT_TYPES.SNS]: 'SNS 게시물',
-  [CONTENT_TYPES.POSTER]: '홍보 포스터',
-  [CONTENT_TYPES.VIDEO]: '비디오',
-  [CONTENT_TYPES.BLOG]: '블로그 포스트',
+  BLOG: 'blog'
 }
 
 // 플랫폼
@@ -23,191 +15,201 @@ export const PLATFORMS = {
   INSTAGRAM: 'instagram',
   NAVER_BLOG: 'naver_blog',
   FACEBOOK: 'facebook',
-  TWITTER: 'twitter',
-  YOUTUBE: 'youtube',
-  KAKAO: 'kakao',
+  KAKAO_STORY: 'kakao_story'
 }
 
+// 플랫폼 라벨
 export const PLATFORM_LABELS = {
   [PLATFORMS.INSTAGRAM]: '인스타그램',
   [PLATFORMS.NAVER_BLOG]: '네이버 블로그',
   [PLATFORMS.FACEBOOK]: '페이스북',
-  [PLATFORMS.TWITTER]: '트위터',
-  [PLATFORMS.YOUTUBE]: '유튜브',
-  [PLATFORMS.KAKAO]: '카카오',
+  [PLATFORMS.KAKAO_STORY]: '카카오스토리'
 }
 
+// 플랫폼 컬러
 export const PLATFORM_COLORS = {
-  [PLATFORMS.INSTAGRAM]: 'purple',
+  [PLATFORMS.INSTAGRAM]: 'pink',
   [PLATFORMS.NAVER_BLOG]: 'green',
   [PLATFORMS.FACEBOOK]: 'blue',
-  [PLATFORMS.TWITTER]: 'light-blue',
-  [PLATFORMS.YOUTUBE]: 'red',
-  [PLATFORMS.KAKAO]: 'yellow',
+  [PLATFORMS.KAKAO_STORY]: 'amber'
 }
 
-// 콘텐츠 상태
-export const CONTENT_STATUS = {
-  DRAFT: 'draft',
-  PUBLISHED: 'published',
-  SCHEDULED: 'scheduled',
-  ARCHIVED: 'archived',
-  FAILED: 'failed',
+// 플랫폼 아이콘
+export const PLATFORM_ICONS = {
+  [PLATFORMS.INSTAGRAM]: 'mdi-instagram',
+  [PLATFORMS.NAVER_BLOG]: 'mdi-web',
+  [PLATFORMS.FACEBOOK]: 'mdi-facebook',
+  [PLATFORMS.KAKAO_STORY]: 'mdi-chat'
 }
 
-export const CONTENT_STATUS_LABELS = {
-  [CONTENT_STATUS.DRAFT]: '임시저장',
-  [CONTENT_STATUS.PUBLISHED]: '발행됨',
-  [CONTENT_STATUS.SCHEDULED]: '예약됨',
-  [CONTENT_STATUS.ARCHIVED]: '보관됨',
-  [CONTENT_STATUS.FAILED]: '실패',
-}
-
-export const CONTENT_STATUS_COLORS = {
-  [CONTENT_STATUS.DRAFT]: 'orange',
-  [CONTENT_STATUS.PUBLISHED]: 'success',
-  [CONTENT_STATUS.SCHEDULED]: 'info',
-  [CONTENT_STATUS.ARCHIVED]: 'grey',
-  [CONTENT_STATUS.FAILED]: 'error',
-}
-
-// 매장 업종
-export const BUSINESS_TYPES = {
-  RESTAURANT: 'restaurant',
-  CAFE: 'cafe',
-  SNACK_BAR: 'snack_bar',
-  FAST_FOOD: 'fast_food',
-  BAKERY: 'bakery',
-  DESSERT: 'dessert',
-  CONVENIENCE: 'convenience',
-  OTHER: 'other',
-}
-
-export const BUSINESS_TYPE_LABELS = {
-  [BUSINESS_TYPES.RESTAURANT]: '일반음식점',
-  [BUSINESS_TYPES.CAFE]: '카페',
-  [BUSINESS_TYPES.SNACK_BAR]: '분식점',
-  [BUSINESS_TYPES.FAST_FOOD]: '패스트푸드',
-  [BUSINESS_TYPES.BAKERY]: '제과점',
-  [BUSINESS_TYPES.DESSERT]: '디저트카페',
-  [BUSINESS_TYPES.CONVENIENCE]: '편의점',
-  [BUSINESS_TYPES.OTHER]: '기타',
+// 플랫폼 사양 정의 (누락된 PLATFORM_SPECS 추가)
+export const PLATFORM_SPECS = {
+  [PLATFORMS.INSTAGRAM]: {
+    name: '인스타그램',
+    icon: 'mdi-instagram',
+    color: 'pink',
+    maxLength: 2200,
+    hashtags: true,
+    imageRequired: true,
+    format: 'sns'
+  },
+  [PLATFORMS.NAVER_BLOG]: {
+    name: '네이버 블로그',
+    icon: 'mdi-web',
+    color: 'green',
+    maxLength: 5000,
+    hashtags: false,
+    imageRequired: false,
+    format: 'blog'
+  },
+  [PLATFORMS.FACEBOOK]: {
+    name: '페이스북',
+    icon: 'mdi-facebook',
+    color: 'blue',
+    maxLength: 63206,
+    hashtags: true,
+    imageRequired: false,
+    format: 'sns'
+  },
+  [PLATFORMS.KAKAO_STORY]: {
+    name: '카카오스토리',
+    icon: 'mdi-chat',
+    color: 'amber',
+    maxLength: 1000,
+    hashtags: true,
+    imageRequired: false,
+    format: 'sns'
+  }
 }
 
 // 톤앤매너
 export const TONE_AND_MANNER = {
   FRIENDLY: 'friendly',
   PROFESSIONAL: 'professional',
-  HUMOROUS: 'humorous',
-  ELEGANT: 'elegant',
   CASUAL: 'casual',
-  TRENDY: 'trendy',
-}
-
-export const TONE_AND_MANNER_LABELS = {
-  [TONE_AND_MANNER.FRIENDLY]: '친근함',
-  [TONE_AND_MANNER.PROFESSIONAL]: '전문적',
-  [TONE_AND_MANNER.HUMOROUS]: '유머러스',
-  [TONE_AND_MANNER.ELEGANT]: '고급스러운',
-  [TONE_AND_MANNER.CASUAL]: '캐주얼',
-  [TONE_AND_MANNER.TRENDY]: '트렌디',
+  HUMOROUS: 'humorous'
 }
 
 // 감정 강도
 export const EMOTION_INTENSITY = {
-  CALM: 'calm',
-  NORMAL: 'normal',
-  ENTHUSIASTIC: 'enthusiastic',
-  EXCITING: 'exciting',
-}
-
-export const EMOTION_INTENSITY_LABELS = {
-  [EMOTION_INTENSITY.CALM]: '차분함',
-  [EMOTION_INTENSITY.NORMAL]: '보통',
-  [EMOTION_INTENSITY.ENTHUSIASTIC]: '열정적',
-  [EMOTION_INTENSITY.EXCITING]: '과장된',
+  LOW: 'low',
+  MEDIUM: 'medium',
+  HIGH: 'high'
 }
 
 // 프로모션 타입
 export const PROMOTION_TYPES = {
-  DISCOUNT: 'discount',
-  EVENT: 'event',
-  NEW_MENU: 'new_menu',
-  NONE: 'none',
+  DISCOUNT: 'DISCOUNT',
+  EVENT: 'EVENT',
+  NEW_PRODUCT: 'NEW_PRODUCT',
+  REVIEW: 'REVIEW'
 }
 
-export const PROMOTION_TYPE_LABELS = {
-  [PROMOTION_TYPES.DISCOUNT]: '할인 정보',
-  [PROMOTION_TYPES.EVENT]: '이벤트 정보',
-  [PROMOTION_TYPES.NEW_MENU]: '신메뉴 알림',
-  [PROMOTION_TYPES.NONE]: '없음',
-}
-
-// 이미지 스타일
+// 사진 스타일
 export const PHOTO_STYLES = {
   MODERN: 'modern',
-  CLASSIC: 'classic',
-  EMOTIONAL: 'emotional',
+  VINTAGE: 'vintage',
   MINIMALIST: 'minimalist',
+  COLORFUL: 'colorful',
+  BRIGHT: 'bright',
+  CALM: 'calm',
+  NATURAL: 'natural'
 }
 
-export const PHOTO_STYLE_LABELS = {
-  [PHOTO_STYLES.MODERN]: '모던',
-  [PHOTO_STYLES.CLASSIC]: '클래식',
-  [PHOTO_STYLES.EMOTIONAL]: '감성적',
-  [PHOTO_STYLES.MINIMALIST]: '미니멀',
+// 콘텐츠 상태
+export const CONTENT_STATUS = {
+  DRAFT: 'draft',
+  PUBLISHED: 'published',
+  ARCHIVED: 'archived'
 }
 
-// 파일 업로드 제한
-export const FILE_LIMITS = {
-  MAX_SIZE: 10 * 1024 * 1024, // 10MB
-  ALLOWED_TYPES: ['image/jpeg', 'image/png', 'image/gif', 'image/webp'],
-  ALLOWED_EXTENSIONS: ['.jpg', '.jpeg', '.png', '.gif', '.webp'],
+// 타겟 대상
+export const TARGET_TYPES = {
+  NEW_MENU: 'new_menu',
+  DISCOUNT: 'discount',
+  STORE: 'store',
+  EVENT: 'event'
+}
+
+// 타겟 대상 라벨
+export const TARGET_TYPE_LABELS = {
+  [TARGET_TYPES.NEW_MENU]: '신메뉴',
+  [TARGET_TYPES.DISCOUNT]: '할인 이벤트',
+  [TARGET_TYPES.STORE]: '매장 홍보',
+  [TARGET_TYPES.EVENT]: '일반 이벤트'
+}
+
+// 백엔드 플랫폼 매핑 (프론트엔드 -> 백엔드)
+export const BACKEND_PLATFORM_MAPPING = {
+  [PLATFORMS.INSTAGRAM]: 'INSTAGRAM',
+  [PLATFORMS.NAVER_BLOG]: 'NAVER_BLOG',
+  [PLATFORMS.FACEBOOK]: 'FACEBOOK',
+  [PLATFORMS.KAKAO_STORY]: 'KAKAO_STORY'
+}
+
+// 백엔드에서 프론트엔드로 매핑 (백엔드 -> 프론트엔드)
+export const FRONTEND_PLATFORM_MAPPING = {
+  'INSTAGRAM': PLATFORMS.INSTAGRAM,
+  'NAVER_BLOG': PLATFORMS.NAVER_BLOG,
+  'FACEBOOK': PLATFORMS.FACEBOOK,
+  'KAKAO_STORY': PLATFORMS.KAKAO_STORY
 }
 
 // API 응답 상태
 export const API_STATUS = {
   SUCCESS: 'success',
   ERROR: 'error',
-  LOADING: 'loading',
-  IDLE: 'idle',
+  LOADING: 'loading'
 }
 
-// 페이지네이션
-export const PAGINATION = {
-  DEFAULT_PAGE_SIZE: 20,
-  PAGE_SIZE_OPTIONS: [10, 20, 50, 100],
+// 페이지 크기
+export const PAGE_SIZES = {
+  SMALL: 10,
+  MEDIUM: 20,
+  LARGE: 50
+}
+
+// 정렬 방향
+export const SORT_DIRECTION = {
+  ASC: 'asc',
+  DESC: 'desc'
+}
+
+// 날짜 포맷
+export const DATE_FORMATS = {
+  DISPLAY: 'YYYY-MM-DD HH:mm',
+  API: 'YYYY-MM-DD',
+  FULL: 'YYYY-MM-DD HH:mm:ss'
+}
+
+// 파일 업로드 제한
+export const FILE_LIMITS = {
+  MAX_SIZE: 10485760, // 10MB
+  ALLOWED_TYPES: ['image/jpeg', 'image/png', 'image/gif', 'image/webp'],
+  MAX_FILES: 5
+}
+
+// 콘텐츠 생성 제한
+export const CONTENT_LIMITS = {
+  TITLE_MAX_LENGTH: 100,
+  DESCRIPTION_MAX_LENGTH: 500,
+  REQUIREMENTS_MAX_LENGTH: 1000,
+  MAX_HASHTAGS: 30
+}
+
+// 알림 타입
+export const NOTIFICATION_TYPES = {
+  SUCCESS: 'success',
+  ERROR: 'error',
+  WARNING: 'warning',
+  INFO: 'info'
 }
 
 // 로컬 스토리지 키
 export const STORAGE_KEYS = {
-  AUTH_TOKEN: 'auth_token',
-  USER_INFO: 'user_info',
-  APP_SETTINGS: 'app_settings',
-  CONTENT_FILTERS: 'content_filters',
-}
-
-// 시간 관련 상수
-export const TIME_FORMATS = {
-  DATE: 'YYYY-MM-DD',
-  DATETIME: 'YYYY-MM-DD HH:mm:ss',
-  TIME: 'HH:mm',
-}
-
-export const DATE_RANGES = {
-  TODAY: 'today',
-  WEEK: 'week',
-  MONTH: 'month',
-  QUARTER: 'quarter',
-  YEAR: 'year',
-  ALL: 'all',
-}
-
-export const DATE_RANGE_LABELS = {
-  [DATE_RANGES.TODAY]: '오늘',
-  [DATE_RANGES.WEEK]: '최근 1주일',
-  [DATE_RANGES.MONTH]: '최근 1개월',
-  [DATE_RANGES.QUARTER]: '최근 3개월',
-  [DATE_RANGES.YEAR]: '최근 1년',
-  [DATE_RANGES.ALL]: '전체',
-}
+  ACCESS_TOKEN: 'accessToken',
+  REFRESH_TOKEN: 'refreshToken',
+  USER_INFO: 'userInfo',
+  THEME: 'theme',
+  LANGUAGE: 'language'
+}
\ No newline at end of file
diff --git a/src/views/ContentCreationView.vue b/src/views/ContentCreationView.vue
index be215ed..370b9d8 100644
--- a/src/views/ContentCreationView.vue
+++ b/src/views/ContentCreationView.vue
@@ -9,301 +9,251 @@
         :class="['left-panel', { 'left-panel-full': generatedVersions.length === 0 }]"
       >
         <v-card flat tile style="height: 100vh; overflow-y: auto;">
-          <!-- 헤더 - 제목 형태로 변경 -->
+          <!-- 헤더 -->
           <div class="pa-4 d-flex align-center" style="min-height: 64px;">
+            <v-btn
+              icon="mdi-arrow-left"
+              variant="text"
+              @click="$router.go(-1)"
+              class="mr-2"
+            />
             <v-icon class="mr-2" color="primary">mdi-creation</v-icon>
-            <h2 class="text-h5 font-weight-bold">콘텐츠 생성 (최대 3개)</h2>
+            <h2 class="text-h5 font-weight-bold">콘텐츠 생성</h2>
+            <v-spacer />
+            <v-chip color="info" size="small">
+              생성 가능: {{ remainingGenerations }}회
+            </v-chip>
           </div>
 
           <v-divider />
 
           <v-card-text class="pa-4">
-            <!-- 첫번째 화면 -->
-            <div v-if="currentStep === 1">
-              <!-- 1. 콘텐츠 타입 선택 -->
-              <v-card class="mb-4" elevation="1">
-                <v-card-title class="text-h6 py-3">콘텐츠 유형 선택</v-card-title>
-                <v-card-text>
-                  <v-row>
-                    <v-col
-                      v-for="type in contentTypes"
-                      :key="type.value"
-                      cols="6"
+            <!-- 콘텐츠 타입 선택 -->
+            <v-card class="mb-4" elevation="1">
+              <v-card-title class="text-h6 py-3">콘텐츠 유형 선택</v-card-title>
+              <v-card-text>
+                <v-row>
+                  <v-col
+                    v-for="type in contentTypes"
+                    :key="type.value"
+                    cols="6"
+                  >
+                    <v-card
+                      :color="selectedType === type.value ? 'primary' : 'grey-lighten-4'"
+                      :elevation="selectedType === type.value ? 8 : 2"
+                      class="pa-3 text-center cursor-pointer"
+                      @click="selectContentType(type.value)"
                     >
-                      <v-card
-                        :color="selectedType === type.value ? 'primary' : 'grey-lighten-4'"
-                        :elevation="selectedType === type.value ? 8 : 2"
-                        class="pa-3 text-center cursor-pointer"
-                        @click="selectContentType(type.value)"
+                      <v-icon
+                        :color="selectedType === type.value ? 'white' : type.color"
+                        size="32"
+                        class="mb-2"
                       >
-                        <v-icon
-                          :color="selectedType === type.value ? 'white' : type.color"
-                          size="32"
-                          class="mb-2"
-                        >
-                          {{ type.icon }}
-                        </v-icon>
-                        <div
-                          class="text-body-2 font-weight-medium"
-                          :class="selectedType === type.value ? 'text-white' : ''"
-                        >
-                          {{ type.label }}
-                        </div>
-                        <div
-                          class="text-caption"
-                          :class="selectedType === type.value ? 'text-white' : 'text-grey'"
-                        >
-                          {{ type.description }}
-                        </div>
-                      </v-card>
-                    </v-col>
-                  </v-row>
+                        {{ type.icon }}
+                      </v-icon>
+                      <div
+                        class="text-body-2 font-weight-medium"
+                        :class="selectedType === type.value ? 'text-white' : ''"
+                      >
+                        {{ type.label }}
+                      </div>
+                      <div
+                        class="text-caption"
+                        :class="selectedType === type.value ? 'text-white' : 'text-grey'"
+                      >
+                        {{ type.description }}
+                      </div>
+                    </v-card>
+                  </v-col>
+                </v-row>
+              </v-card-text>
+            </v-card>
+
+            <!-- 콘텐츠 생성 폼 -->
+            <div v-if="selectedType">
+              <!-- 기본 정보 -->
+              <v-card class="mb-4" elevation="1">
+                <v-card-title class="text-h6 py-3">기본 정보</v-card-title>
+                <v-card-text>
+                  <v-form ref="contentForm" v-model="formValid">
+                    <!-- 제목 -->
+                    <v-text-field
+                      v-model="formData.title"
+                      label="제목"
+                      variant="outlined"
+                      :rules="titleRules"
+                      required
+                      density="compact"
+                      class="mb-3"
+                      placeholder="예: 신메뉴 출시 이벤트"
+                    />
+
+                    <!-- 플랫폼 선택 -->
+                    <v-select
+                      v-model="formData.platform"
+                      :items="platformOptions"
+                      label="발행 플랫폼"
+                      variant="outlined"
+                      :rules="platformRules"
+                      required
+                      density="compact"
+                      class="mb-3"
+                    >
+                      <template v-slot:item="{ props, item }">
+                        <v-list-item v-bind="props">
+                          <template v-slot:prepend>
+                            <v-icon :color="getPlatformColor(item.value)">
+                              {{ getPlatformIcon(item.value) }}
+                            </v-icon>
+                          </template>
+                        </v-list-item>
+                      </template>
+                    </v-select>
+
+                    <!-- 홍보 대상 -->
+                    <v-select
+                      v-model="formData.targetType"
+                      :items="targetTypes"
+                      label="홍보 대상"
+                      variant="outlined"
+                      :rules="targetRules"
+                      required
+                      density="compact"
+                      class="mb-3"
+                    />
+
+                    <!-- 이벤트명 (홍보 대상이 이벤트인 경우) -->
+                    <v-text-field
+                      v-if="formData.targetType === 'event'"
+                      v-model="formData.eventName"
+                      label="이벤트명"
+                      variant="outlined"
+                      :rules="eventNameRules"
+                      density="compact"
+                      class="mb-3"
+                      placeholder="예: 신메뉴 할인 이벤트"
+                    />
+
+                    <!-- 이벤트 기간 (이벤트인 경우) -->
+                    <v-row v-if="formData.targetType === 'event'">
+                      <v-col cols="6">
+                        <v-text-field
+                          v-model="formData.startDate"
+                          label="시작일"
+                          type="date"
+                          variant="outlined"
+                          density="compact"
+                          :rules="startDateRules"
+                        />
+                      </v-col>
+                      <v-col cols="6">
+                        <v-text-field
+                          v-model="formData.endDate"
+                          label="종료일"
+                          type="date"
+                          variant="outlined"
+                          density="compact"
+                          :rules="endDateRules"
+                        />
+                      </v-col>
+                    </v-row>
+                  </v-form>
                 </v-card-text>
               </v-card>
 
-              <!-- 콘텐츠 생성 폼 -->
-              <div v-if="selectedType">
-                <!-- 2. 기본 정보 -->
-                <v-card class="mb-4" elevation="1">
-                  <v-card-title class="text-h6 py-3">기본 정보</v-card-title>
-                  <v-card-text>
-                    <v-form ref="contentForm" v-model="formValid">
-                      <!-- 제목 -->
-                      <v-text-field
-                        v-model="formData.title"
-                        label="제목"
-                        variant="outlined"
-                        :rules="titleRules"
-                        required
-                        density="compact"
-                        class="mb-3"
-                      />
-
-                      <!-- 플랫폼 선택 -->
-                      <v-select
-                        v-model="formData.platform"
-                        :items="platformOptions"
-                        label="발행 플랫폼"
-                        variant="outlined"
-                        :rules="platformRules"
-                        required
-                        density="compact"
-                        class="mb-3"
-                      >
-                        <template v-slot:item="{ props, item }">
-                          <v-list-item v-bind="props">
-                            <template v-slot:prepend>
-                              <v-icon :color="getPlatformColor(item.value)">
-                                {{ getPlatformIcon(item.value) }}
-                              </v-icon>
-                            </template>
-                          </v-list-item>
-                        </template>
-                      </v-select>
-
-                      <!-- 홍보 대상 -->
-                      <v-select
-                        v-model="formData.targetType"
-                        :items="targetTypes"
-                        label="홍보 대상"
-                        variant="outlined"
-                        :rules="targetRules"
-                        required
-                        density="compact"
-                        class="mb-3"
-                      />
-
-                      <!-- 이벤트명 (홍보 대상이 이벤트인 경우) -->
-                      <v-text-field
-                        v-if="formData.targetType === 'event'"
-                        v-model="formData.eventName"
-                        label="이벤트명"
-                        variant="outlined"
-                        :rules="eventNameRules"
-                        density="compact"
-                        class="mb-3"
-                      />
-
-                      <!-- 시작일, 종료일 (모든 홍보 대상에 대해 표시) -->
-                      <v-row v-if="formData.targetType">
-                        <v-col cols="6">
-                          <v-text-field
-                            v-model="formData.startDate"
-                            label="시작일"
-                            type="date"
-                            variant="outlined"
-                            :rules="startDateRules"
-                            density="compact"
-                          />
-                        </v-col>
-                        <v-col cols="6">
-                          <v-text-field
-                            v-model="formData.endDate"
-                            label="종료일"
-                            type="date"
-                            variant="outlined"
-                            :rules="endDateRules"
-                            density="compact"
-                          />
-                        </v-col>
-                      </v-row>
-                    </v-form>
-                  </v-card-text>
-                </v-card>
-
-                <!-- 4. 이미지 업로드 -->
-                <v-card class="mb-4" elevation="1">
-                  <v-card-title class="text-h6 py-3">이미지 첨부</v-card-title>
-                  <v-card-text>
-                    <v-file-input
-                      v-model="uploadedFiles"
-                      label="이미지 선택"
-                      multiple
-                      accept="image/*"
-                      variant="outlined"
-                      density="compact"
-                      prepend-icon="mdi-camera"
-                      @change="handleFileUpload"
-                      class="mb-3"
-                    />
-                    
-                    <!-- 업로드된 이미지 미리보기 -->
-                    <div v-if="previewImages.length" class="image-preview-grid">
-                      <div
-                        v-for="(image, index) in previewImages"
-                        :key="index"
-                        class="image-preview-item"
-                      >
-                        <v-img
-                          :src="image.url"
-                          aspect-ratio="1"
-                          cover
-                          class="rounded"
-                        />
-                        <v-btn
-                          icon
-                          size="small"
-                          color="error"
-                          class="remove-btn"
-                          @click="removeImage(index)"
-                        >
-                          <v-icon size="small">mdi-close</v-icon>
-                        </v-btn>
-                      </div>
-                    </div>
-                  </v-card-text>
-                </v-card>
-
-                <!-- 다음 버튼 -->
-                <v-card elevation="1">
-                  <v-card-text>
-                    <v-btn
-                      color="primary"
-                      size="large"
-                      block
-                      :disabled="!canProceedToNext"
-                      @click="goToNextStep"
-                    >
-                      <v-icon class="mr-2">mdi-arrow-right</v-icon>
-                      다음
-                    </v-btn>
-                  </v-card-text>
-                </v-card>
-              </div>
-            </div>
-
-            <!-- 두번째 화면 -->
-            <div v-if="currentStep === 2">
-              <!-- 이전 버튼 -->
-              <v-btn
-                variant="text"
-                color="primary"
-                class="mb-4"
-                @click="goToPreviousStep"
-              >
-                <v-icon class="mr-2">mdi-arrow-left</v-icon>
-                이전
-              </v-btn>
-
-              <!-- 3. AI 옵션 설정 -->
-              <v-card class="mb-4" elevation="1" v-if="useAI">
-                <v-card-title class="text-h6 py-3">AI 옵션 설정</v-card-title>
+              <!-- AI 설정 (백엔드 지원 필드만) -->
+              <v-card class="mb-4" elevation="1">
+                <v-card-title class="text-h6 py-3">
+                  <v-icon class="mr-2" color="primary">mdi-robot</v-icon>
+                  AI 설정
+                </v-card-title>
                 <v-card-text>
-                  <!-- 타겟 연령층 - 간단하고 확실한 방법으로 수정 -->
+                  <!-- 사진 스타일 -->
                   <v-select
-                    v-model="aiOptions.targetAge"
-                    :items="targetAgeOptions"
-                    label="타겟 연령층"
-                    variant="outlined"
-                    density="compact"
-                    class="mb-3"
-                    prepend-inner-icon="mdi-account-group"
-                  >
-                    <template #item="{ props, item }">
-                      <v-list-item
-                        v-bind="props"
-                        :prepend-icon="getAgeIcon(item.value)"
-                        :title="item.title"
-                      />
-                    </template>
-                    <template #selection="{ item }">
-                      <v-chip size="small" color="primary" class="ml-1">
-                        <v-icon start size="small">{{ getAgeIcon(item.value) }}</v-icon>
-                        {{ item.title }}
-                      </v-chip>
-                    </template>
-                  </v-select>
-                  <!-- 포토 스타일 (포스터인 경우) -->
-                  <v-select
-                    v-if="selectedType === 'poster'"
                     v-model="aiOptions.photoStyle"
                     :items="photoStyleOptions"
-                    label="포토 스타일"
+                    label="사진 스타일"
                     variant="outlined"
                     density="compact"
                     class="mb-3"
                   />
 
-                  <!-- 추가 요구사항 -->
+                  <!-- 요구사항 -->
                   <v-textarea
-                    v-model="aiOptions.requirements"
-                    label="추가 요구사항"
+                    v-model="formData.requirements"
+                    label="구체적인 요구사항 (선택사항)"
                     variant="outlined"
                     rows="3"
                     density="compact"
-                    placeholder="특별히 포함하고 싶은 내용이나 요구사항을 입력해주세요"
+                    placeholder="예: 젊은 고객층을 타겟으로 트렌디한 문구를 사용하고 싶어요"
                   />
                 </v-card-text>
               </v-card>
 
-            
-
-              <!-- 생성 방식 선택 및 버튼 -->
-              <v-card elevation="1">
+              <!-- 사진 업로드 -->
+              <v-card class="mb-4" elevation="1">
+                <v-card-title class="text-h6 py-3">
+                  <v-icon class="mr-2" color="primary">mdi-camera</v-icon>
+                  사진 업로드 (선택사항)
+                </v-card-title>
                 <v-card-text>
-                  <!-- AI 사용 여부 토글 -->
-  
+                  <v-file-input
+                    v-model="uploadedFiles"
+                    label="사진을 선택하세요"
+                    variant="outlined"
+                    multiple
+                    accept="image/*"
+                    prepend-icon="mdi-camera"
+                    @change="handleFileUpload"
+                    density="compact"
+                  />
+                  
+                  <!-- 미리보기 -->
+                  <div v-if="previewImages.length > 0" class="mt-3">
+                    <v-row>
+                      <v-col
+                        v-for="(image, index) in previewImages"
+                        :key="index"
+                        cols="3"
+                      >
+                        <v-card class="position-relative">
+                          <v-img
+                            :src="image.url"
+                            aspect-ratio="1"
+                            cover
+                          />
+                          <v-btn
+                            icon="mdi-close"
+                            size="small"
+                            color="error"
+                            class="position-absolute"
+                            style="top: 4px; right: 4px;"
+                            @click="removeImage(index)"
+                          />
+                        </v-card>
+                      </v-col>
+                    </v-row>
+                  </div>
+                </v-card-text>
+              </v-card>
 
-                  <!-- 생성 버튼 -->
+              <!-- 생성 버튼 -->
+              <v-card class="mb-4" elevation="1">
+                <v-card-text class="text-center">
                   <v-btn
                     color="primary"
                     size="large"
-                    block
-                    :loading="isGenerating"
-                    :disabled="!canGenerate || remainingGenerations <= 0"
+                    :disabled="!formValid || remainingGenerations <= 0 || contentStore.generating"
+                    :loading="contentStore.generating"
                     @click="generateContent"
-                    class="mb-2"
+                    class="px-8"
                   >
-                    <v-icon class="mr-2">
-                      {{ useAI ? 'mdi-robot' : 'mdi-content-save' }}
-                    </v-icon>
-                    {{ useAI ? `AI 콘텐츠 신규 생성 (${remainingGenerations}회)` : '콘텐츠 저장' }}
+                    <v-icon class="mr-2">mdi-robot</v-icon>
+                    AI로 콘텐츠 생성하기
                   </v-btn>
-
-                  <!-- 생성 횟수 안내 -->
-                  <div v-if="useAI" class="text-caption text-grey text-center">
-                    <v-icon size="small" class="mr-1">mdi-information</v-icon>
-                    AI 생성은 최대 3회까지 가능합니다. (남은 횟수: {{ remainingGenerations }}회)
+                  
+                  <div v-if="remainingGenerations <= 0" class="text-caption text-error mt-2">
+                    생성 가능 횟수를 모두 사용했습니다.
                   </div>
                 </v-card-text>
               </v-card>
@@ -312,140 +262,155 @@
         </v-card>
       </v-col>
 
-      <!-- 오른쪽 패널: 생성된 콘텐츠 버전 관리 -->
-      <v-col v-if="generatedVersions.length > 0" cols="6" class="right-panel">
+      <!-- 오른쪽 패널: 생성된 콘텐츠 미리보기 -->
+      <v-col 
+        v-if="generatedVersions.length > 0"
+        cols="6"
+        class="right-panel"
+      >
         <v-card flat tile style="height: 100vh; overflow-y: auto;">
-          <!-- 헤더 - 제목 형태로 변경 -->
-          <div class="pa-4 d-flex align-center justify-between">
-            <div class="d-flex align-center" style="min-height: 32px;">
-              <v-icon class="mr-2" color="primary">mdi-file-document-multiple</v-icon>
-              <h2 class="text-h5 font-weight-bold">콘텐츠 생성 결과</h2>
-            </div>
+          <!-- 헤더 -->
+          <div class="pa-4 d-flex align-center" style="min-height: 64px;">
+            <v-icon class="mr-2" color="success">mdi-eye</v-icon>
+            <h2 class="text-h5 font-weight-bold">생성된 콘텐츠</h2>
+            <v-spacer />
+            <v-chip color="success" size="small">
+              {{ generatedVersions.length }}개 생성됨
+            </v-chip>
           </div>
 
           <v-divider />
 
           <v-card-text class="pa-4">
-            <!-- 생성된 콘텐츠가 없는 경우 -->
-            <div v-if="generatedVersions.length === 0" class="text-center pa-8">
-              <v-icon size="64" color="grey-lighten-1" class="mb-4">
-                mdi-file-document-outline
-              </v-icon>
-              <h3 class="text-h6 text-grey-darken-1 mb-2">
-                아직 생성된 콘텐츠가 없습니다
-              </h3>
-              <p class="text-grey">
-                왼쪽에서 정보를 입력하고 '{{ useAI ? 'AI 콘텐츠 생성' : '콘텐츠 저장' }}' 버튼을 클릭해주세요
-              </p>
+            <!-- 버전 목록 -->
+            <div class="mb-4">
+              <h3 class="text-h6 mb-3">생성된 버전들</h3>
+              <v-row>
+                <v-col
+                  v-for="(version, index) in generatedVersions"
+                  :key="index"
+                  cols="12"
+                  class="mb-3"
+                >
+                  <v-card
+                    :color="selectedVersion === index ? 'primary' : 'grey-lighten-5'"
+                    :elevation="selectedVersion === index ? 8 : 2"
+                    class="cursor-pointer"
+                    @click="selectVersion(index)"
+                  >
+                    <v-card-text class="pa-3">
+                      <div class="d-flex justify-space-between align-center">
+                        <div>
+                          <div class="font-weight-medium text-subtitle-2">
+                            버전 {{ index + 1 }}
+                          </div>
+                          <div class="text-caption text-grey">
+                            {{ formatDateTime(version.createdAt) }}
+                          </div>
+                        </div>
+                        <div class="d-flex align-center">
+                          <v-chip
+                            :color="getStatusColor(version.status)"
+                            size="x-small"
+                            class="mr-2"
+                          >
+                            {{ getStatusText(version.status) }}
+                          </v-chip>
+                          <v-icon
+                            :color="selectedVersion === index ? 'white' : 'grey'"
+                            size="20"
+                          >
+                            mdi-chevron-right
+                          </v-icon>
+                        </div>
+                      </div>
+                    </v-card-text>
+                  </v-card>
+                </v-col>
+              </v-row>
             </div>
 
-            <!-- 생성된 콘텐츠 버전들 -->
-            <div v-else>
-              <v-card
-                v-for="(version, index) in generatedVersions"
-                :key="version.id"
-                class="mb-4 version-card"
-                :elevation="selectedVersion === index ? 4 : 2"
-                :color="selectedVersion === index ? 'primary' : ''"
-                :variant="selectedVersion === index ? 'elevated' : 'outlined'"
-                @click="selectVersion(index)"
-              >
-                <v-card-title class="pa-3">
-                  <div class="d-flex align-center">
-                    <v-chip
-                      :color="selectedVersion === index ? 'white' : 'primary'"
-                      :text-color="selectedVersion === index ? 'primary' : 'white'"
-                      size="small"
-                      class="mr-2"
-                    >
-                      버전 {{ index + 1 }}
-                    </v-chip>
-                    <span :class="selectedVersion === index ? 'text-white' : ''" class="flex-grow-1">
-                      {{ version.title }}
-                    </span>
-                  </div>
-                </v-card-title>
-
-                <v-card-text class="pa-3" :class="selectedVersion === index ? 'text-white' : ''">
-                  <!-- 플랫폼 정보 -->
-                  <div class="mb-2">
-                    <v-chip
-                      :color="getPlatformColor(version.platform)"
-                      size="small"
-                      class="mr-2"
-                    >
-                      <v-icon left size="small">{{ getPlatformIcon(version.platform) }}</v-icon>
-                      {{ getPlatformLabel(version.platform) }}
-                    </v-chip>
-                    <small :class="selectedVersion === index ? 'text-white' : 'text-grey'">
-                      {{ formatDate(version.createdAt) }}
-                    </small>
-                  </div>
-
-                  <!-- 콘텐츠 내용 미리보기 -->
-                  <div class="content-preview mb-2">
-                    <p class="text-body-2 content-text">
-                      {{ truncateText(version.content, 120) }}
-                    </p>
-                  </div>
-
-                  <!-- 해시태그 -->
-                  <div v-if="version.hashtags?.length" class="hashtags mb-2">
-                    <v-chip
-                      v-for="tag in version.hashtags.slice(0, 3)"
-                      :key="tag"
-                      size="x-small"
-                      variant="outlined"
-                      :color="selectedVersion === index ? 'white' : 'primary'"
-                      class="mr-1 mb-1"
-                    >
-                      #{{ tag }}
-                    </v-chip>
-                    <span v-if="version.hashtags.length > 3" 
-                          :class="selectedVersion === index ? 'text-white' : 'text-grey'"
-                          class="text-caption">
-                      +{{ version.hashtags.length - 3 }}개 더
-                    </span>
-                  </div>
-
-                  <!-- 이미지 -->
-                  <div v-if="version.images?.length" class="images">
-                    <v-row>
-                      <v-col
-                        v-for="(image, imgIndex) in version.images.slice(0, 2)"
-                        :key="imgIndex"
-                        cols="6"
-                      >
-                        <v-img
-                          :src="image"
-                          aspect-ratio="1"
-                          cover
-                          class="rounded"
-                        />
-                      </v-col>
-                    </v-row>
-                    <p v-if="version.images.length > 2" 
-                       :class="selectedVersion === index ? 'text-white' : 'text-grey'"
-                       class="text-caption mt-1">
-                      +{{ version.images.length - 2 }}개 이미지 더
-                    </p>
-                  </div>
-                </v-card-text>
-
-                <!-- 버전별 액션 (수정 버튼 제거, 삭제 기능 제거) -->
-                <v-card-actions class="pa-3">
+            <!-- 선택된 버전 미리보기 -->
+            <div v-if="currentVersion">
+              <h3 class="text-h6 mb-3">미리보기</h3>
+              <v-card elevation="4" class="preview-card">
+                <v-card-title class="d-flex align-center py-2">
+                  <v-icon :color="getPlatformColor(currentVersion.platform)" class="mr-2">
+                    {{ getPlatformIcon(currentVersion.platform) }}
+                  </v-icon>
+                  {{ getPlatformLabel(currentVersion.platform) }}
                   <v-spacer />
                   <v-btn
-                    :color="selectedVersion === index ? 'white' : 'primary'"
-                    :text-color="selectedVersion === index ? 'primary' : 'white'"
+                    color="primary"
                     size="small"
-                    @click.stop="publishVersion(index)"
-                    :loading="isPublishing && publishingIndex === index"
+                    @click="showDetailDialog = true"
                   >
-                    <v-icon size="small" class="mr-1">mdi-send</v-icon>
-                    발행
+                    자세히 보기
                   </v-btn>
-                </v-card-actions>
+                </v-card-title>
+                
+                <v-divider />
+                
+                <v-card-text class="pa-3">
+                  <!-- 제목 -->
+                  <div class="font-weight-bold text-h6 mb-2">
+                    {{ currentVersion.title }}
+                  </div>
+                  
+                  <!-- 콘텐츠 내용 (HTML 렌더링) -->
+                  <div class="text-body-2 mb-3" style="line-height: 1.6;">
+                    <div v-if="isHtmlContent(currentVersion.content)" 
+                         class="html-content preview-content">
+                      <!-- 미리보기용 축약 HTML -->
+                      <div v-html="truncateHtmlContent(currentVersion.content, 200)"></div>
+                      <div v-if="currentVersion.content.length > 500" class="text-caption text-grey mt-2">
+                        ... 더 보려면 '자세히 보기'를 클릭하세요
+                      </div>
+                    </div>
+                    <div v-else>{{ truncateText(currentVersion.content, 150) }}</div>
+                  </div>
+
+                  
+                  <!-- 해시태그 -->
+                  <div v-if="currentVersion.hashtags && currentVersion.hashtags.length > 0" class="mb-3">
+                    <v-chip
+                      v-for="(hashtag, idx) in currentVersion.hashtags.slice(0, 5)"
+                      :key="idx"
+                      size="small"
+                      color="primary"
+                      variant="outlined"
+                      class="mr-1 mb-1"
+                    >
+                      {{ hashtag }}
+                    </v-chip>
+                    <span v-if="currentVersion.hashtags.length > 5" class="text-caption text-grey">
+                      +{{ currentVersion.hashtags.length - 5 }}개 더
+                    </span>
+                  </div>
+                  
+                  <!-- 액션 버튼 -->
+                  <div class="d-flex gap-2">
+                    <v-btn
+                      color="success"
+                      variant="flat"
+                      @click="saveVersion(selectedVersion)"
+                      :loading="isPublishing && publishingIndex === selectedVersion"
+                      :disabled="currentVersion.status === 'published'"
+                    >
+                      <v-icon class="mr-1">mdi-content-save</v-icon>
+                      저장하기
+                    </v-btn>
+                    
+                    <v-btn
+                      color="primary"
+                      variant="outlined"
+                      @click="copyToClipboard(currentVersion.content)"
+                    >
+                      <v-icon class="mr-1">mdi-content-copy</v-icon>
+                      복사
+                    </v-btn>
+                  </div>
+                </v-card-text>
               </v-card>
             </div>
           </v-card-text>
@@ -453,90 +418,125 @@
       </v-col>
     </v-row>
 
-    <!-- 상세 보기 다이얼로그 -->
+    <!-- 상세 다이얼로그 -->
     <v-dialog
       v-model="showDetailDialog"
       max-width="800"
       scrollable
     >
-      <v-card v-if="selectedVersionData">
-        <v-card-title class="text-h6 d-flex align-center">
-          {{ selectedVersionData.title }} (버전 {{ selectedVersion + 1 }})
+      <v-card v-if="currentVersion">
+        <v-card-title class="d-flex align-center">
+          <v-icon :color="getPlatformColor(currentVersion.platform)" class="mr-2">
+            {{ getPlatformIcon(currentVersion.platform) }}
+          </v-icon>
+          {{ currentVersion.title }}
           <v-spacer />
-          <v-btn icon @click="showDetailDialog = false">
-            <v-icon>mdi-close</v-icon>
-          </v-btn>
+          <v-btn
+            icon="mdi-close"
+            variant="text"
+            @click="showDetailDialog = false"
+          />
         </v-card-title>
-
+        
         <v-divider />
+        
+        <v-card-text class="pa-4" style="max-height: 500px;">
 
-        <v-card-text class="pa-4">
-          <!-- 플랫폼 정보 -->
+          <!-- 전체 콘텐츠 (HTML 렌더링) -->
           <div class="mb-4">
-            <v-chip
-              :color="getPlatformColor(selectedVersionData.platform)"
-              size="small"
-              class="mr-2"
-            >
-              <v-icon left>{{ getPlatformIcon(selectedVersionData.platform) }}</v-icon>
-              {{ getPlatformLabel(selectedVersionData.platform) }}
-            </v-chip>
-            <small class="text-grey">{{ formatDate(selectedVersionData.createdAt) }}</small>
-          </div>
-
-          <!-- 콘텐츠 내용 -->
-          <div class="content-full mb-4">
             <h4 class="text-h6 mb-2">콘텐츠</h4>
-            <div class="text-body-1 content-text">
-              {{ selectedVersionData.content }}
+            <div v-if="isHtmlContent(currentVersion.content)" 
+                 class="pa-3 bg-grey-lighten-5 rounded html-content" 
+                 style="line-height: 1.6;"
+                 v-html="currentVersion.content">
+            </div>
+            <div v-else 
+                 class="text-body-2 pa-3 bg-grey-lighten-5 rounded" 
+                 style="white-space: pre-wrap; line-height: 1.6;">
+              {{ currentVersion.content }}
             </div>
           </div>
 
+        
+          
           <!-- 해시태그 -->
-          <div v-if="selectedVersionData.hashtags?.length" class="hashtags mb-4">
+          <div v-if="currentVersion.hashtags && currentVersion.hashtags.length > 0" class="mb-4">
             <h4 class="text-h6 mb-2">해시태그</h4>
-            <v-chip
-              v-for="tag in selectedVersionData.hashtags"
-              :key="tag"
-              variant="outlined"
-              class="mr-1 mb-1"
-            >
-              #{{ tag }}
-            </v-chip>
-          </div>
-
-          <!-- 이미지 -->
-          <div v-if="selectedVersionData.images?.length" class="images">
-            <h4 class="text-h6 mb-2">이미지</h4>
-            <v-row>
-              <v-col
-                v-for="(image, index) in selectedVersionData.images"
-                :key="index"
-                cols="6"
+            <div>
+              <v-chip
+                v-for="(hashtag, idx) in currentVersion.hashtags"
+                :key="idx"
+                size="small"
+                color="primary"
+                variant="outlined"
+                class="mr-1 mb-1"
               >
-                <v-img :src="image" aspect-ratio="1" cover class="rounded" />
-              </v-col>
-            </v-row>
+                {{ hashtag }}
+              </v-chip>
+            </div>
+          </div>
+          
+          <!-- 메타 정보 -->
+          <div>
+            <h4 class="text-h6 mb-2">정보</h4>
+            <v-list density="compact">
+              <v-list-item>
+                <v-list-item-title>플랫폼</v-list-item-title>
+                <template v-slot:append>
+                  <v-chip size="small" :color="getPlatformColor(currentVersion.platform)">
+                    {{ getPlatformLabel(currentVersion.platform) }}
+                  </v-chip>
+                </template>
+              </v-list-item>
+              <v-list-item>
+                <v-list-item-title>홍보 대상</v-list-item-title>
+                <template v-slot:append>
+                  {{ currentVersion.targetType }}
+                </template>
+              </v-list-item>
+              <v-list-item v-if="currentVersion.eventName">
+                <v-list-item-title>이벤트명</v-list-item-title>
+                <template v-slot:append>
+                  {{ currentVersion.eventName }}
+                </template>
+              </v-list-item>
+              <v-list-item>
+                <v-list-item-title>생성일시</v-list-item-title>
+                <template v-slot:append>
+                  {{ formatDateTime(currentVersion.createdAt) }}
+                </template>
+              </v-list-item>
+            </v-list>
           </div>
         </v-card-text>
-
+        
         <v-divider />
-
-        <v-card-actions class="pa-4 d-flex justify-end">
+        
+        <v-card-actions class="px-4 py-3">
+          <v-spacer />
           <v-btn
             color="primary"
-            @click="publishVersion(selectedVersion)"
-            :loading="isPublishing && publishingIndex === selectedVersion"
+            variant="outlined"
+            @click="copyFullContent(currentVersion)"
           >
-            <v-icon class="mr-1">mdi-send</v-icon>
-            발행하기
+            <v-icon class="mr-1">mdi-content-copy</v-icon>
+            전체 복사
+          </v-btn>
+          <v-btn
+            color="success"
+            @click="saveVersion(selectedVersion); showDetailDialog = false"
+            :loading="isPublishing && publishingIndex === selectedVersion"
+            :disabled="currentVersion.status === 'published'"
+          >
+            <v-icon class="mr-1">mdi-content-save</v-icon>
+            저장하기
           </v-btn>
         </v-card-actions>
       </v-card>
     </v-dialog>
 
     <!-- 로딩 오버레이 -->
-    <v-overlay v-if="isGenerating" class="align-center justify-center">
+    <v-overlay v-model="contentStore.generating" contained persistent class="d-flex align-center justify-center">
       <div class="text-center">
         <v-progress-circular color="primary" indeterminate size="64" class="mb-4" />
         <h3 class="text-h6 text-white mb-2">AI가 콘텐츠를 생성 중입니다</h3>
@@ -547,20 +547,10 @@
 </template>
 
 <script setup>
-import { ref, computed, watch } from 'vue'
+import { ref, computed, watch, onMounted } from 'vue'
 import { useRouter } from 'vue-router'
 import { useContentStore } from '@/store/content'
 import { useAppStore } from '@/store/app'
-import {
-  CONTENT_TYPES,
-  PLATFORMS,
-  TONE_AND_MANNER,
-  EMOTION_INTENSITY,
-  PROMOTION_TYPES,
-  PHOTO_STYLES,
-  PLATFORM_LABELS,
-  PLATFORM_COLORS,
-} from '@/utils/constants'
 
 /**
  * 콘텐츠 생성 페이지
@@ -572,19 +562,15 @@ const contentStore = useContentStore()
 const appStore = useAppStore()
 
 // 반응형 데이터
-const currentStep = ref(1) // 현재 단계 (1: 첫번째 화면, 2: 두번째 화면)
-const selectedType = ref('')
+const selectedType = ref('sns')
 const formValid = ref(false)
-const useAI = ref(true)
 const uploadedFiles = ref([])
 const previewImages = ref([])
-const isGenerating = ref(false)
 const isPublishing = ref(false)
 const publishingIndex = ref(-1)
 const showDetailDialog = ref(false)
 const selectedVersion = ref(0)
 const generatedVersions = ref([])
-const hashtagInput = ref('')
 const remainingGenerations = ref(3) // AI 생성 가능 횟수
 
 // 폼 데이터
@@ -595,130 +581,84 @@ const formData = ref({
   eventName: '',
   startDate: '',
   endDate: '',
-  content: '',
-  hashtags: [],
-})
-
-// AI 옵션
-const aiOptions = ref({
-  toneAndManner: 'friendly',
-  promotion: 'none',
-  emotionIntensity: 'normal',
-  photoStyle: 'modern',
   requirements: '',
 })
 
-// 콘텐츠 타입 옵션
+// AI 옵션 (백엔드 DTO에 맞게 단순화)
+const aiOptions = ref({
+  photoStyle: 'bright' // 백엔드에서 지원하는 photoStyle만 유지
+})
+
+// 상수 정의
 const contentTypes = [
   {
-    value: CONTENT_TYPES.SNS,
+    value: 'sns',
     label: 'SNS 게시물',
-    description: '인스타그램, 블로그 게시물',
+    description: '인스타그램, 페이스북 등',
     icon: 'mdi-instagram',
-    color: 'purple',
+    color: 'pink'
   },
   {
-    value: CONTENT_TYPES.POSTER,
+    value: 'poster',
     label: '홍보 포스터',
-    description: '이벤트, 메뉴 홍보 포스터',
+    description: '이벤트, 할인 포스터',
     icon: 'mdi-image',
-    color: 'orange',
-  },
+    color: 'blue'
+  }
 ]
 
-// 플랫폼 옵션
 const platformOptions = [
-  { title: '인스타그램', value: PLATFORMS.INSTAGRAM },
-  { title: '네이버 블로그', value: PLATFORMS.NAVER_BLOG },
-  { title: '페이스북', value: PLATFORMS.FACEBOOK },
+  { title: '인스타그램', value: 'instagram' },
+  { title: '네이버 블로그', value: 'naver_blog' },
+  { title: '페이스북', value: 'facebook' },
+  { title: '카카오스토리', value: 'kakao_story' }
 ]
 
-// 홍보 대상 타입
 const targetTypes = [
-  { title: '메뉴', value: 'menu' },
-  { title: '매장', value: 'store' },
-  { title: '이벤트', value: 'event' },
-]
-
-// AI 옵션들 - 중복 제거 및 명시적 매핑
-const toneOptions = [
-  { title: '친근함', value: 'friendly' },
-  { title: '전문적', value: 'professional' },
-  { title: '유머러스', value: 'humorous' },
-  { title: '고급스러운', value: 'luxurious' },
-]
-
-const promotionOptions = [
-  { title: '할인 정보', value: 'discount' },
-  { title: '이벤트 정보', value: 'event' },
-  { title: '신메뉴 알림', value: 'new_menu' },
-  { title: '없음', value: 'none' },
-]
-
-const emotionOptions = [
-  { title: '차분함', value: 'calm' },
-  { title: '보통', value: 'normal' },
-  { title: '열정적', value: 'enthusiastic' },
-  { title: '과장된', value: 'exaggerated' },
+  { title: '신메뉴', value: 'new_menu' },
+  { title: '할인 이벤트', value: 'discount' },
+  { title: '매장 홍보', value: 'store' },
+  { title: '일반 이벤트', value: 'event' }
 ]
 
+// 백엔드에서 지원하지 않는 옵션들은 제거
 const photoStyleOptions = [
-  { title: '모던', value: 'modern' },
-  { title: '클래식', value: 'classic' },
-  { title: '감성적', value: 'emotional' },
-  { title: '미니멀', value: 'minimal' },
+  { title: '밝고 화사한', value: 'bright' },
+  { title: '차분하고 세련된', value: 'calm' },
+  { title: '빈티지한', value: 'vintage' },
+  { title: '모던한', value: 'modern' },
+  { title: '자연스러운', value: 'natural' }
 ]
 
 // 유효성 검사 규칙
 const titleRules = [
-  (v) => !!v || '제목을 입력해주세요',
-  (v) => v.length <= 100 || '제목은 100자 이내로 입력해주세요',
+  v => !!v || '제목은 필수입니다',
+  v => (v && v.length <= 100) || '제목은 100자 이하로 입력해주세요'
 ]
 
-const platformRules = [(v) => !!v || '플랫폼을 선택해주세요']
+const platformRules = [
+  v => !!v || '플랫폼을 선택해주세요'
+]
 
-const targetRules = [(v) => !!v || '홍보 대상을 선택해주세요']
+const targetRules = [
+  v => !!v || '홍보 대상을 선택해주세요'
+]
 
 const eventNameRules = [
-  (v) => formData.value.targetType !== 'event' || !!v || '이벤트명을 입력해주세요',
+  v => !formData.value.targetType || formData.value.targetType !== 'event' || !!v || '이벤트명은 필수입니다'
 ]
 
-const startDateRules = [(v) => !!v || '시작일을 선택해주세요']
+const startDateRules = [
+  v => !formData.value.targetType || formData.value.targetType !== 'event' || !!v || '시작일은 필수입니다'
+]
 
 const endDateRules = [
-  (v) => !!v || '종료일을 선택해주세요',
-  (v) =>
-    !formData.value.startDate ||
-    v >= formData.value.startDate ||
-    '종료일은 시작일보다 늦어야 합니다',
+  v => !formData.value.targetType || formData.value.targetType !== 'event' || !!v || '종료일은 필수입니다',
+  v => !formData.value.startDate || !v || new Date(v) >= new Date(formData.value.startDate) || '종료일은 시작일보다 이후여야 합니다'
 ]
 
-const contentRules = [
-  (v) => useAI.value || !!v || '콘텐츠 내용을 입력해주세요',
-]
-
-// 컴퓨티드 속성
-const canProceedToNext = computed(() => {
-  if (!selectedType.value || !formData.value.title || !formData.value.platform || !formData.value.targetType) {
-    return false
-  }
-  
-  if (formData.value.targetType === 'event' && (!formData.value.eventName || !formData.value.startDate || !formData.value.endDate)) {
-    return false
-  }
-  
-  return true
-})
-
-const canGenerate = computed(() => {
-  if (!useAI.value && !formData.value.content) {
-    return false
-  }
-  
-  return true
-})
-
-const selectedVersionData = computed(() => {
+// Computed
+const currentVersion = computed(() => {
   return generatedVersions.value[selectedVersion.value] || null
 })
 
@@ -727,279 +667,443 @@ const selectContentType = (type) => {
   selectedType.value = type
 }
 
-const goToNextStep = () => {
-  if (canProceedToNext.value) {
-    currentStep.value = 2
-  }
-}
-
-const goToPreviousStep = () => {
-  currentStep.value = 1
-}
-
-const handleFileUpload = (files) => {
-  if (files?.length) {
-    previewImages.value = []
-    const imagePromises = files.map(file => {
-      return new Promise((resolve) => {
-        const reader = new FileReader()
-        reader.onload = (e) => resolve({
+const handleFileUpload = () => {
+  previewImages.value = []
+  
+  if (uploadedFiles.value && uploadedFiles.value.length > 0) {
+    uploadedFiles.value.forEach(file => {
+      const reader = new FileReader()
+      reader.onload = (e) => {
+        previewImages.value.push({
           file,
-          url: e.target.result,
-          name: file.name
+          url: e.target.result
         })
-        reader.readAsDataURL(file)
-      })
-    })
-    
-    Promise.all(imagePromises).then(images => {
-      previewImages.value = images
+      }
+      reader.readAsDataURL(file)
     })
   }
 }
 
 const removeImage = (index) => {
   previewImages.value.splice(index, 1)
-  // 파일 입력도 업데이트
-  const dt = new DataTransfer()
-  previewImages.value.forEach(img => dt.items.add(img.file))
-  uploadedFiles.value = dt.files
-}
-
-const addHashtag = () => {
-  const tag = hashtagInput.value.trim().replace('#', '')
-  if (tag && !formData.value.hashtags.includes(tag)) {
-    formData.value.hashtags.push(tag)
-    hashtagInput.value = ''
-  }
-}
-
-const removeHashtag = (index) => {
-  formData.value.hashtags.splice(index, 1)
+  uploadedFiles.value.splice(index, 1)
 }
 
 const generateContent = async () => {
-  if (!canGenerate.value || remainingGenerations.value <= 0) return
-
-  // 최대 3개 버전 체크
-  if (generatedVersions.value.length >= 3) {
-    appStore.showSnackbar('최대 3개의 버전까지만 생성할 수 있습니다.', 'warning')
+  if (!formValid.value) {
+    appStore.showSnackbar('모든 필수 항목을 입력해주세요.', 'warning')
+    return
+  }
+
+  if (remainingGenerations.value <= 0) {
+    appStore.showSnackbar('생성 가능 횟수를 모두 사용했습니다.', 'warning')
     return
   }
 
-  isGenerating.value = true
-  
   try {
+    console.log('🎯 콘텐츠 생성 요청 시작')
+    
+    // 백엔드 DTO에 맞는 데이터 구조
     const contentData = {
+      // 기본 정보
       title: formData.value.title,
-      type: selectedType.value,
-      platform: formData.value.platform,
+      platform: formData.value.platform, // 원본 플랫폼 값 그대로 전송
       targetType: formData.value.targetType,
+      
+      // 이벤트 정보
       eventName: formData.value.eventName,
       startDate: formData.value.startDate,
       endDate: formData.value.endDate,
+      
+      // 콘텐츠 정보
+      requirements: formData.value.requirements,
+      category: getCategory(formData.value.targetType),
+      
+      // 미디어
       images: previewImages.value.map(img => img.url),
-      aiOptions: useAI.value ? aiOptions.value : null,
-      content: useAI.value ? null : formData.value.content,
-      hashtags: useAI.value ? null : formData.value.hashtags,
+      
+      // AI 옵션 (UI에서 설정된 값들)
+      aiOptions: aiOptions.value,
+      
+      // 메타 정보
+      type: selectedType.value
     }
 
-    let newContent
-    if (useAI.value) {
-      // AI 콘텐츠 생성
-      const generated = await contentStore.generateContent(contentData)
-      newContent = {
-        id: Date.now() + Math.random(),
-        ...contentData,
-        content: generated.content,
-        hashtags: generated.hashtags,
-        createdAt: new Date(),
-        status: 'draft',
-      }
-      // AI 생성 횟수 차감
-      remainingGenerations.value--
-    } else {
-      // 수동 입력 콘텐츠
-      newContent = {
-        id: Date.now() + Math.random(),
-        ...contentData,
-        createdAt: new Date(),
-        status: 'draft',
+    console.log('📤 전송할 데이터:', contentData)
+
+    const generated = await contentStore.generateContent(contentData)
+
+      // ✅ 핵심: AI 생성 결과에 이미지를 직접 추가
+    let finalContent = generated.content
+    
+    // 업로드된 이미지가 있으면 콘텐츠 최상단에 추가
+    if (previewImages.value.length > 0) {
+      const imageHtml = previewImages.value.map(img => 
+        `<div style="margin-bottom: 15px; text-align: center;">
+          <img src="${img.url}" style="width: 100%; max-width: 400px; border-radius: 12px; box-shadow: 0 4px 12px rgba(0,0,0,0.1);" />
+         </div>`
+      ).join('')
+      
+      // HTML 콘텐츠인지 확인하고 이미지를 맨 앞에 추가
+      if (isHtmlContent(finalContent)) {
+        finalContent = imageHtml + finalContent
+      } else {
+        // 일반 텍스트면 HTML로 변환해서 이미지 추가
+        finalContent = imageHtml + `<div style="padding: 15px; font-family: 'Noto Sans KR', Arial, sans-serif; line-height: 1.6;">${finalContent.replace(/\n/g, '<br>')}</div>`
       }
     }
+    
+    const newContent = {
+      id: Date.now() + Math.random(),
+      ...contentData,
+      content: finalContent,
+      hashtags: generated.hashtags || [],
+      createdAt: new Date(),
+      status: 'draft',
+       uploadedImages: previewImages.value
+    }
 
     generatedVersions.value.push(newContent)
     selectedVersion.value = generatedVersions.value.length - 1
+    remainingGenerations.value--
     
     appStore.showSnackbar(`콘텐츠 버전 ${generatedVersions.value.length}이 생성되었습니다!`, 'success')
   } catch (error) {
-    console.error('콘텐츠 생성 실패:', error)
-    appStore.showSnackbar('콘텐츠 생성 중 오류가 발생했습니다.', 'error')
-  } finally {
-    isGenerating.value = false
+    console.error('❌ 콘텐츠 생성 실패:', error)
+    appStore.showSnackbar(error.message || '콘텐츠 생성 중 오류가 발생했습니다.', 'error')
   }
 }
 
+const getCategory = (targetType) => {
+  const mapping = {
+    'new_menu': '메뉴소개',
+    'discount': '이벤트',
+    'store': '인테리어',
+    'event': '이벤트'
+  }
+  return mapping[targetType] || '기타'
+}
+
 const selectVersion = (index) => {
   selectedVersion.value = index
-  showDetailDialog.value = true
 }
 
-const publishVersion = async (index) => {
+const saveVersion = async (index) => {
   isPublishing.value = true
   publishingIndex.value = index
   
   try {
     const version = generatedVersions.value[index]
     
-    // 실제로는 발행 API 호출
-    await new Promise(resolve => setTimeout(resolve, 1500))
+    // 백엔드 DTO에 맞는 저장 데이터 구성
+    await contentStore.saveContent({
+      title: version.title,
+      content: version.content,
+      hashtags: version.hashtags,
+      platform: version.platform, // 원본 플랫폼 값 그대로 전송
+      category: getCategory(version.targetType),
+      eventName: version.eventName,
+      eventDate: version.eventDate,
+      status: 'PUBLISHED'
+    })
     
     version.status = 'published'
     version.publishedAt = new Date()
     
-    appStore.showSnackbar(`버전 ${index + 1}이 성공적으로 발행되었습니다!`, 'success')
-    showDetailDialog.value = false
+    appStore.showSnackbar(`버전 ${index + 1}이 성공적으로 저장되었습니다!`, 'success')
     
-    // 발행 후 콘텐츠 관리 페이지로 이동할지 물어보기
+    // 저장 후 콘텐츠 관리 페이지로 이동할지 물어보기
     setTimeout(() => {
-      if (confirm('발행된 콘텐츠를 확인하시겠습니까?')) {
+      if (confirm('저장된 콘텐츠를 확인하시겠습니까?')) {
         router.push('/content')
       }
     }, 1000)
   } catch (error) {
-    console.error('콘텐츠 발행 실패:', error)
-    appStore.showSnackbar('콘텐츠 발행 중 오류가 발생했습니다.', 'error')
+    console.error('❌ 콘텐츠 저장 실패:', error)
+    appStore.showSnackbar(error.message || '콘텐츠 저장 중 오류가 발생했습니다.', 'error')
   } finally {
     isPublishing.value = false
     publishingIndex.value = -1
   }
 }
 
-// 유틸리티 함수
-const getPlatformColor = (platform) => {
-  return PLATFORM_COLORS[platform] || 'grey'
+const copyToClipboard = async (content) => {
+  try {
+    // HTML 콘텐츠인 경우 텍스트만 추출해서 복사
+    const textToCopy = isHtmlContent(content) ? extractTextFromHtml(content) : content
+    
+    await navigator.clipboard.writeText(textToCopy)
+    appStore.showSnackbar('클립보드에 복사되었습니다.', 'success')
+  } catch (error) {
+    console.error('클립보드 복사 실패:', error)
+    appStore.showSnackbar('복사에 실패했습니다.', 'error')
+  }
 }
 
+// 전체 콘텐츠 복사 (콘텐츠 + 해시태그)
+const copyFullContent = async (version) => {
+  try {
+    let fullContent = ''
+    
+    // 콘텐츠 추가 (HTML인 경우 텍스트만 추출)
+    if (isHtmlContent(version.content)) {
+      fullContent += extractTextFromHtml(version.content)
+    } else {
+      fullContent += version.content
+    }
+    
+    // 해시태그 추가
+    if (version.hashtags && version.hashtags.length > 0) {
+      fullContent += '\n\n' + version.hashtags.join(' ')
+    }
+    
+    await navigator.clipboard.writeText(fullContent)
+    appStore.showSnackbar('전체 콘텐츠가 클립보드에 복사되었습니다.', 'success')
+  } catch (error) {
+    console.error('전체 콘텐츠 복사 실패:', error)
+    appStore.showSnackbar('복사에 실패했습니다.', 'error')
+  }
+}
+
+// 유틸리티 함수들
 const getPlatformIcon = (platform) => {
   const icons = {
-    [PLATFORMS.INSTAGRAM]: 'mdi-instagram',
-    [PLATFORMS.FACEBOOK]: 'mdi-facebook',
-    [PLATFORMS.NAVER_BLOG]: 'mdi-post',
+    'instagram': 'mdi-instagram',
+    'naver_blog': 'mdi-web',
+    'facebook': 'mdi-facebook',
+    'kakao_story': 'mdi-chat',
+    // 백엔드에서 받는 값에 대한 매핑 추가
+    'INSTAGRAM': 'mdi-instagram',
+    'NAVER_BLOG': 'mdi-web',
+    'FACEBOOK': 'mdi-facebook',
+    'KAKAO_STORY': 'mdi-chat'
   }
   return icons[platform] || 'mdi-web'
 }
 
-const getPlatformLabel = (platform) => {
-  return PLATFORM_LABELS[platform] || platform
+const getPlatformColor = (platform) => {
+  const colors = {
+    'instagram': 'pink',
+    'naver_blog': 'green',
+    'facebook': 'blue',
+    'kakao_story': 'amber',
+    // 백엔드에서 받는 값에 대한 매핑 추가
+    'INSTAGRAM': 'pink',
+    'NAVER_BLOG': 'green',
+    'FACEBOOK': 'blue',
+    'KAKAO_STORY': 'amber'
+  }
+  return colors[platform] || 'grey'
 }
 
-const formatDate = (date) => {
-  return new Date(date).toLocaleString('ko-KR', {
+const getPlatformLabel = (platform) => {
+  const labels = {
+    'instagram': '인스타그램',
+    'naver_blog': '네이버 블로그',
+    'facebook': '페이스북',
+    'kakao_story': '카카오스토리',
+    // 백엔드에서 받는 값에 대한 매핑 추가
+    'INSTAGRAM': '인스타그램',
+    'NAVER_BLOG': '네이버 블로그',
+    'FACEBOOK': '페이스북',
+    'KAKAO_STORY': '카카오스토리'
+  }
+  return labels[platform] || platform
+}
+
+const getStatusColor = (status) => {
+  const colors = {
+    'draft': 'grey',
+    'published': 'success'
+  }
+  return colors[status] || 'grey'
+}
+
+const getStatusText = (status) => {
+  const texts = {
+    'draft': '임시저장',
+    'published': '발행됨'
+  }
+  return texts[status] || status
+}
+
+const formatDateTime = (date) => {
+  if (!date) return ''
+  
+  return new Intl.DateTimeFormat('ko-KR', {
+    year: 'numeric',
     month: '2-digit',
     day: '2-digit',
     hour: '2-digit',
-    minute: '2-digit',
-  })
+    minute: '2-digit'
+  }).format(new Date(date))
 }
 
-const truncateText = (text, length) => {
-  if (!text || text.length <= length) return text
-  return text.substring(0, length) + '...'
+const truncateText = (text, maxLength) => {
+  if (!text) return ''
+  
+  // HTML 태그가 있으면 제거하고 텍스트만 추출
+  const textOnly = text.replace(/<[^>]*>/g, '')
+  
+  if (textOnly.length <= maxLength) return textOnly
+  return textOnly.substring(0, maxLength) + '...'
 }
 
-// 오늘 날짜를 기본값으로 설정
-const today = new Date().toISOString().substr(0, 10)
-formData.value.startDate = today
-formData.value.endDate = today
+// HTML 콘텐츠 감지 함수
+const isHtmlContent = (content) => {
+  if (!content) return false
+  // HTML 태그가 포함되어 있으면 HTML 콘텐츠로 판단
+  return /<[^>]+>/.test(content)
+}
+
+// HTML에서 텍스트만 추출하는 함수
+const extractTextFromHtml = (html) => {
+  if (!html) return ''
+  // 임시 div 엘리먼트를 만들어서 텍스트만 추출
+  const tempDiv = document.createElement('div')
+  tempDiv.innerHTML = html
+  return tempDiv.textContent || tempDiv.innerText || ''
+}
+
+// HTML 콘텐츠를 축약하는 함수 (미리보기용)
+const truncateHtmlContent = (html, maxLength) => {
+  if (!html) return ''
+  
+  // 텍스트 길이가 maxLength보다 짧으면 그대로 반환
+  const textContent = extractTextFromHtml(html)
+  if (textContent.length <= maxLength) {
+    return html
+  }
+  
+  // HTML을 간단하게 축약
+  const tempDiv = document.createElement('div')
+  tempDiv.innerHTML = html
+  
+  // 첫 번째 섹션만 가져오기 (보통 제목 부분)
+  const firstSection = tempDiv.querySelector('div[style*="background"]')
+  if (firstSection) {
+    return firstSection.outerHTML
+  }
+  
+  // 첫 번째 섹션이 없으면 텍스트만 축약해서 반환
+  return `<div style="padding: 10px; font-family: 'Noto Sans KR', Arial, sans-serif;">${truncateText(textContent, maxLength)}</div>`
+}
+
+// 라이프사이클
+onMounted(() => {
+  console.log('📱 콘텐츠 생성 페이지 로드됨')
+})
 </script>
 
 <style scoped>
 .left-panel {
-  background-color: #fafafa;
   border-right: 1px solid #e0e0e0;
+  transition: all 0.3s ease;
 }
 
 .left-panel-full {
-  border-right: none !important;
+  border-right: none;
 }
 
 .right-panel {
-  background-color: #f5f5f5;
+  background-color: #fafafa;
 }
 
 .cursor-pointer {
   cursor: pointer;
 }
 
-.version-card {
-  cursor: pointer;
-  transition: all 0.3s ease;
+.preview-card {
+  border: 2px solid #e3f2fd;
+  background: linear-gradient(135deg, #ffffff 0%, #f8f9ff 100%);
 }
 
-.version-card:hover {
-  transform: translateY(-2px);
+.sortable-header:hover {
+  background-color: rgba(0, 0, 0, 0.04);
 }
 
-.content-preview {
-  max-height: 80px;
-  overflow: hidden;
+/* 모바일 최적화 */
+@media (max-width: 960px) {
+  .left-panel {
+    border-right: none;
+  }
+  
+  .right-panel {
+    position: fixed;
+    top: 0;
+    left: 0;
+    width: 100vw;
+    height: 100vh;
+    z-index: 1000;
+    background: white;
+  }
 }
 
-.content-text {
-  white-space: pre-wrap;
+/* HTML 콘텐츠 스타일링 */
+:deep(.html-content) {
+  font-family: 'Noto Sans KR', Arial, sans-serif;
+}
+
+:deep(.html-content h1),
+:deep(.html-content h2),
+:deep(.html-content h3) {
+  margin: 0;
+  font-weight: bold;
+}
+
+:deep(.html-content p) {
+  margin: 0 0 10px 0;
+}
+
+:deep(.html-content br) {
+  line-height: 1.6;
+}
+
+:deep(.html-content span[style*="color"]) {
+  font-weight: 500;
+}
+
+/* 해시태그 스타일 보정 */
+:deep(.html-content span[style*="#1DA1F2"]) {
+  color: #1976d2 !important; /* Vuetify primary 색상으로 조정 */
+}
+
+/* 미리보기 카드 내 HTML 콘텐츠 스타일 */
+.preview-card :deep(.html-content) {
+  font-size: 14px;
   line-height: 1.5;
 }
 
-.hashtags {
-  display: flex;
-  flex-wrap: wrap;
-  gap: 4px;
+.preview-card :deep(.html-content div[style*="background"]) {
+  border-radius: 8px;
+  overflow: hidden;
 }
 
-.images {
-  margin-top: 8px;
-}
-
-.image-preview-grid {
-  display: grid;
-  grid-template-columns: repeat(auto-fill, minmax(100px, 1fr));
-  gap: 8px;
-  margin-top: 8px;
-}
-
-.image-preview-item {
+/* 미리보기 콘텐츠 최대 높이 제한 */
+.preview-content {
+  max-height: 300px;
+  overflow: hidden;
   position: relative;
 }
 
-.remove-btn {
+.preview-content::after {
+  content: '';
   position: absolute;
-  top: 4px;
-  right: 4px;
-  background-color: rgba(255, 255, 255, 0.9);
+  bottom: 0;
+  left: 0;
+  right: 0;
+  height: 30px;
+  background: linear-gradient(transparent, white);
+  pointer-events: none;
 }
 
-/* 스크롤바 스타일링 */
-::-webkit-scrollbar {
-  width: 8px;
+/* 다이얼로그 내 HTML 콘텐츠 스타일 */
+.v-dialog :deep(.html-content) {
+  max-width: 100%;
+  overflow-x: auto;
 }
 
-::-webkit-scrollbar-track {
-  background: #f1f1f1;
-}
-
-::-webkit-scrollbar-thumb {
-  background: #c1c1c1;
-  border-radius: 4px;
-}
-
-::-webkit-scrollbar-thumb:hover {
-  background: #a8a8a8;
-}
-
-@media (max-width: 600px) {
-  .text-h4 {
-    font-size: 1.5rem !important;
-  }
+.v-dialog :deep(.html-content div[style*="max-width"]) {
+  max-width: 100% !important;
 }
 </style>
\ No newline at end of file
diff --git a/src/views/DashboardView.vue b/src/views/DashboardView.vue
index 2b3b52b..280e3ba 100644
--- a/src/views/DashboardView.vue
+++ b/src/views/DashboardView.vue
@@ -122,7 +122,7 @@
                     <div class="y-axis-labels">
                       <div v-for="(label, i) in yAxisLabels" :key="i" 
                            class="y-label" 
-                           :style="{ bottom: `${i * 20}%` }">
+                           :style="{ bottom: `${i * 18}%` }">
                         {{ label }}
                       </div>
                     </div>
@@ -139,7 +139,7 @@
                       ref="chartCanvas" 
                       class="chart-canvas"
                       width="800" 
-                      height="300"
+                      height="600"
                       @mousemove="handleMouseMove"
                       @mouseleave="hideTooltip">
                     </canvas>
@@ -176,7 +176,7 @@
 
                   <!-- X축 라벨 - 데이터 포인트와 동일한 위치에 배치 -->
                   <div class="x-axis-labels mt-3" style="position: relative; height: 20px;">
-                    <div class="x-axis-container" style="position: relative; padding-left: 60px; padding-right: 20px;">
+                    <div class="x-axis-container" style="position: relative; padding-left: 60px; padding-right: 60px;">
                       <span 
                         v-for="(point, index) in chartDataPoints" 
                         :key="index" 
@@ -975,13 +975,8 @@ const updateAiRecommendation = (aiData) => {
       title: aiData.tipContent ? aiData.tipContent.substring(0, 50) + '...' : 'AI 마케팅 추천',
       sections: {
         ideas: {
-          title: '1. 추천 아이디어',
+          title: '추천 아이디어',
           items: [aiData.tipContent || '맞춤형 마케팅 전략을 제안드립니다.']
-        },
-        costs: {
-          title: '2. 예상 효과',
-          items: ['고객 관심 유도 및 매출 상승', 'SNS를 통한 브랜드 인지도 상승'],
-          effects: ['재방문율 및 공유 유도', '지역 내 인지도 향상']
         }
       }
     }
@@ -1025,17 +1020,30 @@ const chartDataPoints = computed(() => {
   const data = currentChartData.value
   if (!data || data.length === 0) return []
   
-  const maxSales = Math.max(...data.map(d => Math.max(d.sales, d.target)))
+  const maxValue = Math.max(...data.map(d => Math.max(d.sales, d.target)))
+  
+  // Canvas의 실제 padding과 일치하는 좌표 계산
+  const padding = 60 // drawChart에서 사용하는 padding과 동일
+  const canvasWidth = 800 // Canvas width와 동일
+  const canvasHeight = 300 // Canvas height와 동일
+  const chartWidth = canvasWidth - padding * 2
+  const chartHeight = canvasHeight - padding * 2
   
   return data.map((item, index) => {
-    const chartStartPercent = 8
-    const chartEndPercent = 92
-    const chartWidth = chartEndPercent - chartStartPercent
+    // Canvas에서 그려지는 실제 좌표 계산
+    const canvasX = padding + (index * chartWidth / (data.length - 1))
+    const canvasY = padding + chartHeight - ((item.sales / maxValue) * chartHeight)
+    const targetCanvasY = padding + chartHeight - ((item.target / maxValue) * chartHeight)
+    
+    // 백분율로 변환하되, data-points의 padding을 고려
+    const xPercent = (canvasX / canvasWidth) * 100
+    const yPercent = ((canvasHeight - canvasY + padding) / canvasHeight) * 100 - 15
+    const targetYPercent = ((canvasHeight - targetCanvasY + padding) / canvasHeight) * 100 - 15
     
     return {
-      x: chartStartPercent + (index * chartWidth / (data.length - 1)),
-      y: 10 + ((item.sales / maxSales) * 80),
-      targetY: 10 + ((item.target / maxSales) * 80),
+      x: xPercent,
+      y: yPercent,
+      targetY: targetYPercent,
       sales: item.sales,
       target: item.target,
       label: item.label
@@ -1479,7 +1487,7 @@ onMounted(async () => {
   left: 0;
   top: 0;
   bottom: 0;
-  width: 40px;
+  width: 50px;
 }
 
 .y-label {
@@ -1491,8 +1499,8 @@ onMounted(async () => {
 
 .chart-grid {
   position: absolute;
-  left: 40px;
-  right: 0;
+  left: 60px;
+  right: 60px;
   top: 0;
   bottom: 0;
 }
@@ -1515,7 +1523,7 @@ onMounted(async () => {
 
 .data-points {
   position: absolute;
-  left: 40px;
+  left: 0;
   right: 0;
   top: 0;
   bottom: 0;

From ccdc2c91bbcf14e35bf3ac7b1b085daa62e788f9 Mon Sep 17 00:00:00 2001
From: unknown <yyoooona@gmail.com>
Date: Wed, 18 Jun 2025 10:17:32 +0900
Subject: [PATCH 06/11] StoreManagementView.vue services/api.js edit

---
 public/images/menu-placeholder.png  |  Bin 0 -> 98463 bytes
 src/services/api.js                 |  170 ++-
 src/store/index.js                  |  152 +-
 src/views/ContentManagementView.vue |  950 ++++++------
 src/views/StoreManagementView.vue   | 2166 ++++++++++++++++-----------
 5 files changed, 1933 insertions(+), 1505 deletions(-)
 create mode 100644 public/images/menu-placeholder.png

diff --git a/public/images/menu-placeholder.png b/public/images/menu-placeholder.png
new file mode 100644
index 0000000000000000000000000000000000000000..f097a4be651469bbf2d7db2b1d022fa6a458c09c
GIT binary patch
literal 98463
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
H*5UsF{(mWZ

literal 0
HcmV?d00001

diff --git a/src/services/api.js b/src/services/api.js
index 6fbd09d..6ac5977 100644
--- a/src/services/api.js
+++ b/src/services/api.js
@@ -1,4 +1,5 @@
-//* src/services/api.js - 수정된 API URL 설정
+//* src/services/api.js - 수정된 버전 (createImageApiInstance 함수 추가)
+
 import axios from 'axios'
 
 // 런타임 환경 설정에서 API URL 가져오기
@@ -11,10 +12,9 @@ const getApiUrls = () => {
     STORE_URL: config.STORE_URL || 'http://localhost:8082/api/store',
     CONTENT_URL: config.CONTENT_URL || 'http://localhost:8083/api/content',
     MENU_URL: config.MENU_URL || 'http://localhost:8082/api/menu',
-    // ⚠️ 수정: 매출 API는 store 서비스 (포트 8082)
     SALES_URL: config.SALES_URL || 'http://localhost:8082/api/sales',
-    // ⚠️ 수정: 추천 API는 ai-recommend 서비스 (포트 8084)
-    RECOMMEND_URL: config.RECOMMEND_URL || 'http://localhost:8084/api/recommendations'
+    RECOMMEND_URL: config.RECOMMEND_URL || 'http://localhost:8084/api/recommendations',
+    IMAGE_URL: config.IMAGE_URL || 'http://localhost:8082/api/images'
   }
 }
 
@@ -37,7 +37,6 @@ const createApiInstance = (baseURL) => {
         config.headers.Authorization = `Bearer ${token}`
       }
       
-      // ⚠️ 추가: 요청 로깅 (개발 환경에서만)
       if (import.meta.env.DEV) {
         console.log(`🌐 [API_REQ] ${config.method?.toUpperCase()} ${config.baseURL}${config.url}`)
       }
@@ -52,14 +51,12 @@ const createApiInstance = (baseURL) => {
   // 응답 인터셉터 - 토큰 갱신 및 에러 처리
   instance.interceptors.response.use(
     (response) => {
-      // ⚠️ 추가: 응답 로깅 (개발 환경에서만)
       if (import.meta.env.DEV) {
         console.log(`✅ [API_RES] ${response.status} ${response.config?.method?.toUpperCase()} ${response.config?.url}`)
       }
       return response
     },
     async (error) => {
-      // ⚠️ 추가: 에러 로깅 (개발 환경에서만)
       if (import.meta.env.DEV) {
         console.error(`❌ [API_ERR] ${error.response?.status || 'Network'} ${error.config?.method?.toUpperCase()} ${error.config?.url}`, error.response?.data)
       }
@@ -102,10 +99,155 @@ const createApiInstance = (baseURL) => {
   return instance
 }
 
+// ✅ 이미지 업로드 전용 API 인스턴스 생성 함수 추가
+const createImageApiInstance = (baseURL) => {
+  const instance = axios.create({
+    baseURL,
+    timeout: 60000, // 이미지 업로드는 시간이 더 걸릴 수 있음
+    headers: {
+      Accept: 'application/json',
+    },
+  })
+
+  // 요청 인터셉터 - JWT 토큰 자동 추가
+  instance.interceptors.request.use(
+    (config) => {
+      const token = localStorage.getItem('accessToken')
+      if (token) {
+        config.headers.Authorization = `Bearer ${token}`
+      }
+      
+      if (import.meta.env.DEV) {
+        console.log(`🌐 [IMG_REQ] ${config.method?.toUpperCase()} ${config.baseURL}${config.url}`)
+        console.log('FormData 포함:', config.data instanceof FormData)
+      }
+      
+      return config
+    },
+    (error) => {
+      return Promise.reject(error)
+    },
+  )
+
+  // 응답 인터셉터
+  instance.interceptors.response.use(
+    (response) => {
+      if (import.meta.env.DEV) {
+        console.log(`✅ [IMG_RES] ${response.status} ${response.config?.method?.toUpperCase()} ${response.config?.url}`)
+      }
+      return response
+    },
+    async (error) => {
+      if (import.meta.env.DEV) {
+        console.error(`❌ [IMG_ERR] ${error.response?.status || 'Network'} ${error.config?.method?.toUpperCase()} ${error.config?.url}`, error.response?.data)
+      }
+      
+      // 토큰 갱신 로직은 기존과 동일
+      const originalRequest = error.config
+      if (error.response?.status === 401 && !originalRequest._retry) {
+        originalRequest._retry = true
+        try {
+          const refreshToken = localStorage.getItem('refreshToken')
+          if (refreshToken) {
+            const refreshResponse = await axios.post(`${getApiUrls().AUTH_URL}/refresh`, {
+              refreshToken,
+            })
+            const { accessToken, refreshToken: newRefreshToken } = refreshResponse.data.data
+            localStorage.setItem('accessToken', accessToken)
+            localStorage.setItem('refreshToken', newRefreshToken)
+            originalRequest.headers.Authorization = `Bearer ${accessToken}`
+            return instance(originalRequest)
+          }
+        } catch (refreshError) {
+          localStorage.removeItem('accessToken')
+          localStorage.removeItem('refreshToken')
+          localStorage.removeItem('userInfo')
+          window.location.href = '/login'
+        }
+      }
+      return Promise.reject(error)
+    },
+  )
+
+  return instance
+}
+
+// ✅ 메뉴 이미지 업로드 전용 API 인스턴스 생성 함수 추가
+const createMenuImageApiInstance = (baseURL) => {
+  const instance = axios.create({
+    baseURL,
+    timeout: 60000, // 이미지 업로드는 시간이 더 걸릴 수 있음
+    headers: {
+      Accept: 'application/json',
+    },
+  })
+
+  // 요청 인터셉터 - JWT 토큰 자동 추가
+  instance.interceptors.request.use(
+    (config) => {
+      const token = localStorage.getItem('accessToken')
+      if (token) {
+        config.headers.Authorization = `Bearer ${token}`
+      }
+      
+      if (import.meta.env.DEV) {
+        console.log(`🌐 [MENU_IMG_REQ] ${config.method?.toUpperCase()} ${config.baseURL}${config.url}`)
+        console.log('FormData 포함:', config.data instanceof FormData)
+      }
+      
+      return config
+    },
+    (error) => {
+      return Promise.reject(error)
+    },
+  )
+
+  // 응답 인터셉터
+  instance.interceptors.response.use(
+    (response) => {
+      if (import.meta.env.DEV) {
+        console.log(`✅ [MENU_IMG_RES] ${response.status} ${response.config?.method?.toUpperCase()} ${response.config?.url}`)
+      }
+      return response
+    },
+    async (error) => {
+      if (import.meta.env.DEV) {
+        console.error(`❌ [MENU_IMG_ERR] ${error.response?.status || 'Network'} ${error.config?.method?.toUpperCase()} ${error.config?.url}`, error.response?.data)
+      }
+      
+      // 토큰 갱신 로직은 기존과 동일
+      const originalRequest = error.config
+      if (error.response?.status === 401 && !originalRequest._retry) {
+        originalRequest._retry = true
+        try {
+          const refreshToken = localStorage.getItem('refreshToken')
+          if (refreshToken) {
+            const refreshResponse = await axios.post(`${getApiUrls().AUTH_URL}/refresh`, {
+              refreshToken,
+            })
+            const { accessToken, refreshToken: newRefreshToken } = refreshResponse.data.data
+            localStorage.setItem('accessToken', accessToken)
+            localStorage.setItem('refreshToken', newRefreshToken)
+            originalRequest.headers.Authorization = `Bearer ${accessToken}`
+            return instance(originalRequest)
+          }
+        } catch (refreshError) {
+          localStorage.removeItem('accessToken')
+          localStorage.removeItem('refreshToken')
+          localStorage.removeItem('userInfo')
+          window.location.href = '/login'
+        }
+      }
+      return Promise.reject(error)
+    },
+  )
+
+  return instance
+}
+
 // API 인스턴스들 생성
 const apiUrls = getApiUrls()
 
-// ⚠️ 추가: API URL 확인 로깅 (개발 환경에서만)
 if (import.meta.env.DEV) {
   console.log('🔧 [API_CONFIG] API URLs 설정:', apiUrls)
 }
@@ -115,8 +257,11 @@ export const authApi = createApiInstance(apiUrls.AUTH_URL)
 export const storeApi = createApiInstance(apiUrls.STORE_URL)
 export const contentApi = createApiInstance(apiUrls.CONTENT_URL)
 export const menuApi = createApiInstance(apiUrls.MENU_URL)
+export const menuImageApi = createMenuImageApiInstance(apiUrls.MENU_URL) // ✅ 추가
 export const salesApi = createApiInstance(apiUrls.SALES_URL)
 export const recommendApi = createApiInstance(apiUrls.RECOMMEND_URL)
+export const imageApi = createApiInstance(apiUrls.IMAGE_URL)
+export const apiWithImage = imageApi // 별칭 (기존 코드 호환성)
 
 // 기본 API 인스턴스 (Gateway URL 사용)
 export const api = createApiInstance(apiUrls.GATEWAY_URL)
@@ -185,7 +330,7 @@ export const formatSuccessResponse = (data, message = '요청이 성공적으로
   }
 }
 
-// ⚠️ 추가: API 상태 확인 함수
+// API 상태 확인 함수
 export const checkApiHealth = async () => {
   const results = {}
   
@@ -214,11 +359,14 @@ export const checkApiHealth = async () => {
   return results
 }
 
-// ⚠️ 추가: 개발 환경에서 전역 노출
+// 개발 환경에서 전역 노출
 if (import.meta.env.DEV) {
   window.__api_debug__ = {
     urls: apiUrls,
-    instances: { memberApi, authApi, storeApi, contentApi, menuApi, salesApi, recommendApi },
+    instances: { 
+      memberApi, authApi, storeApi, contentApi, menuApi, menuImageApi, 
+      salesApi, recommendApi, imageApi 
+    },
     checkHealth: checkApiHealth
   }
   console.log('🔧 [DEBUG] API 인스턴스가 window.__api_debug__에 노출됨')
diff --git a/src/store/index.js b/src/store/index.js
index 8ff224a..98da823 100644
--- a/src/store/index.js
+++ b/src/store/index.js
@@ -79,80 +79,88 @@ export const useStoreStore = defineStore('store', {
       }
     },
 
-    /**
-     * 메뉴 목록 조회 - 실제 API 연동 (매장 ID 필요) - ✅ ID 필드 보장
-     */
-    async fetchMenus() {
-      console.log('=== Store 스토어: 메뉴 목록 조회 시작 ===')
+    // src/store/index.js에서 fetchMenus 부분만 수정
+
+/**
+ * 메뉴 목록 조회 - 실제 API 연동 (매장 ID 필요) - ✅ 이미지 필드 매핑 수정
+ */
+async fetchMenus() {
+  console.log('=== Store 스토어: 메뉴 목록 조회 시작 ===')
+  
+  try {
+    // 매장 정보에서 storeId 가져오기
+    const storeId = this.storeInfo?.storeId
+    if (!storeId) {
+      console.warn('매장 ID가 없습니다. 매장 정보를 먼저 조회해주세요.')
+      return { success: false, message: '매장 정보가 필요합니다', data: [] }
+    }
+    
+    // 메뉴 서비스 임포트
+    const { menuService } = await import('@/services/menu')
+    
+    console.log('메뉴 목록 API 호출, 매장 ID:', storeId)
+    const result = await menuService.getMenus(storeId)
+    
+    console.log('=== Store 스토어: 메뉴 API 응답 분석 ===')
+    console.log('Result:', result)
+    console.log('Result.success:', result.success)
+    console.log('Result.data:', result.data)
+    console.log('Result.message:', result.message)
+    
+    if (result.success && result.data) {
+      // ✅ 백엔드 MenuResponse의 필드명에 맞게 매핑 수정
+      const menusWithId = (result.data || []).map(menu => {
+        // ID 필드가 확실히 있도록 보장
+        const menuId = menu.menuId || menu.id
+        
+        if (!menuId) {
+          console.warn('⚠️ 메뉴 ID가 없는 항목 발견:', menu)
+        }
+        
+        console.log('메뉴 원본 데이터:', menu) // 디버깅용
+        
+        return {
+          ...menu,
+          id: menuId, // ✅ id 필드 확실히 설정
+          menuId: menuId, // ✅ menuId 필드도 설정
+          // 기타 필드들 보장
+          menuName: menu.menuName || menu.name || '이름 없음',
+          category: menu.category || '기타',
+          price: menu.price || 0,
+          description: menu.description || '',
+          available: menu.available !== undefined ? menu.available : true,
+          recommended: menu.recommended !== undefined ? menu.recommended : false,
+          // ✅ 이미지 필드 수정: 백엔드는 'image' 필드 사용
+          imageUrl: menu.image || menu.imageUrl || '/images/menu-placeholder.png',
+          image: menu.image || menu.imageUrl, // 백엔드 호환성
+          createdAt: menu.createdAt,
+          updatedAt: menu.updatedAt
+        }
+      })
       
-      try {
-        // 매장 정보에서 storeId 가져오기
-        const storeId = this.storeInfo?.storeId
-        if (!storeId) {
-          console.warn('매장 ID가 없습니다. 매장 정보를 먼저 조회해주세요.')
-          return { success: false, message: '매장 정보가 필요합니다', data: [] }
-        }
-        
-        // 메뉴 서비스 임포트
-        const { menuService } = await import('@/services/menu')
-        
-        console.log('메뉴 목록 API 호출, 매장 ID:', storeId)
-        const result = await menuService.getMenus(storeId)
-        
-        console.log('=== Store 스토어: 메뉴 API 응답 분석 ===')
-        console.log('Result:', result)
-        console.log('Result.success:', result.success)
-        console.log('Result.data:', result.data)
-        console.log('Result.message:', result.message)
-        
-        if (result.success && result.data) {
-          // ✅ 메뉴 데이터 ID 필드 보장 처리
-          const menusWithId = (result.data || []).map(menu => {
-            // ID 필드가 확실히 있도록 보장
-            const menuId = menu.menuId || menu.id
-            
-            if (!menuId) {
-              console.warn('⚠️ 메뉴 ID가 없는 항목 발견:', menu)
-            }
-            
-            return {
-              ...menu,
-              id: menuId, // ✅ id 필드 확실히 설정
-              menuId: menuId, // ✅ menuId 필드도 설정
-              // 기타 필드들 보장
-              menuName: menu.menuName || menu.name || '이름 없음',
-              category: menu.category || '기타',
-              price: menu.price || 0,
-              description: menu.description || '',
-              available: menu.available !== undefined ? menu.available : true,
-              recommended: menu.recommended !== undefined ? menu.recommended : false,
-              imageUrl: menu.imageUrl || '/images/menu-placeholder.png'
-            }
-          })
-          
-          // 메뉴 목록이 있는 경우
-          console.log('✅ 메뉴 목록 설정 (ID 보장됨):', menusWithId)
-          this.menus = menusWithId
-          return { success: true, data: menusWithId }
-        } else {
-          // 메뉴가 없거나 조회 실패한 경우
-          console.log('⚠️ 메뉴 목록 없음 또는 조회 실패')
-          this.menus = []
-          
-          if (result.message === '등록된 메뉴가 없습니다') {
-            return { success: false, message: '등록된 메뉴가 없습니다', data: [] }
-          } else {
-            return { success: false, message: result.message || '메뉴 목록 조회에 실패했습니다', data: [] }
-          }
-        }
-      } catch (error) {
-        console.error('=== Store 스토어: 메뉴 목록 조회 실패 ===')
-        console.error('Error:', error)
-        
-        this.menus = []
-        return { success: false, message: error.message || '메뉴 목록을 불러오는데 실패했습니다', data: [] }
+      // 메뉴 목록이 있는 경우
+      console.log('✅ 메뉴 목록 설정 (이미지 필드 매핑 완료):', menusWithId)
+      this.menus = menusWithId
+      return { success: true, data: menusWithId }
+    } else {
+      // 메뉴가 없거나 조회 실패한 경우
+      console.log('⚠️ 메뉴 목록 없음 또는 조회 실패')
+      this.menus = []
+      
+      if (result.message === '등록된 메뉴가 없습니다') {
+        return { success: false, message: '등록된 메뉴가 없습니다', data: [] }
+      } else {
+        return { success: false, message: result.message || '메뉴 목록 조회에 실패했습니다', data: [] }
       }
-    },
+    }
+    } catch (error) {
+      console.error('=== Store 스토어: 메뉴 목록 조회 실패 ===')
+      console.error('Error:', error)
+      
+      this.menus = []
+      return { success: false, message: error.message || '메뉴 목록을 불러오는데 실패했습니다', data: [] }
+    }
+  },
 
     /**
      * 매장 등록
diff --git a/src/views/ContentManagementView.vue b/src/views/ContentManagementView.vue
index 26006c9..c927e13 100644
--- a/src/views/ContentManagementView.vue
+++ b/src/views/ContentManagementView.vue
@@ -1,351 +1,359 @@
 //* src/views/ContentManagementView.vue
 <template>
-  <v-container fluid class="pa-4">
-    <!-- 필터 영역 -->
-    <v-card class="mb-6">
-      <v-card-text>
-        <v-row align="center">
-          <!-- 콘텐츠 타입 필터 - 칩 형태로 변경 -->
-          <v-col cols="12" md="6">
-            <div class="d-flex align-center flex-wrap ga-2">
-              <span class="text-subtitle-2 font-weight-medium mr-2">콘텐츠 타입:</span>
-              <v-chip
-                v-for="type in contentTypeOptions"
-                :key="type.value"
-                :color="selectedContentType === type.value ? type.color : 'default'"
-                :variant="selectedContentType === type.value ? 'flat' : 'outlined'"
-                size="small"
-                class="mr-1 chip-hover"
-                @click="selectContentType(type.value)"
-              >
-                <span class="mr-1">{{ type.emoji }}</span>
-                {{ type.title.replace(type.emoji + ' ', '') }}
-                <span v-if="type.value !== 'all'" class="ml-1">({{ getTypeCount(type.value) }})</span>
-                <span v-else class="ml-1">({{ getTotalCount() }})</span>
-              </v-chip>
-            </div>
-          </v-col>
-
-          <!-- 검색 및 새콘텐츠생성 버튼 -->
-          <v-col cols="12" md="6">
-            <div class="d-flex align-center ga-2">
-              <!-- 제목 검색 -->
-              <v-text-field
-                v-model="searchQuery"
-                label="제목, 해시태그로 검색"
-                prepend-inner-icon="mdi-magnify"
-                variant="outlined"
-                density="compact"
-                clearable
-                hide-details
-                @update:model-value="applyFilters"
-              />
-              
-              <!-- 새 콘텐츠 생성 버튼 -->
-              <v-btn
-                color="primary"
-                prepend-icon="mdi-plus"
-                @click="$router.push('/content/create')"
-                class="ml-2"
-              >
-                새콘텐츠생성
-              </v-btn>
-            </div>
-          </v-col>
-        </v-row>
-      </v-card-text>
-    </v-card>
-
-    <!-- 선택된 항목 일괄 작업 -->
-    <div v-if="selectedItems.length > 0" class="mb-4">
-      <v-alert color="info" variant="tonal">
-        <div class="d-flex justify-space-between align-center">
-          <span>{{ selectedItems.length }}개 항목이 선택됨</span>
-          <v-btn
-            color="error"
-            variant="text"
-            @click="deleteSelectedItems"
-          >
-            선택 항목 삭제
-          </v-btn>
-        </div>
-      </v-alert>
+  <v-container fluid class="pa-6">
+    <!-- 페이지 헤더 -->
+    <div class="d-flex align-center mb-6">
+      <v-icon @click="$router.go(-1)" class="mr-3 cursor-pointer">mdi-arrow-left</v-icon>
+      <h1 class="text-h4 font-weight-bold">콘텐츠 관리</h1>
     </div>
 
-    <!-- 콘텐츠 목록 -->
-    <v-card>
-      <v-card-text class="pa-0">
-        <div v-if="loading" class="text-center pa-8">
-          <v-progress-circular indeterminate color="primary" />
-          <div class="mt-4">콘텐츠를 불러오는 중...</div>
-        </div>
-
-        <div v-else-if="paginatedContents.length === 0" class="text-center pa-8">
-          <v-icon size="64" color="grey-lighten-1" class="mb-4">mdi-file-document-outline</v-icon>
-          <div class="text-h6 mb-2">표시할 콘텐츠가 없습니다</div>
-          <div class="text-body-2 text-grey-600 mb-4">새로운 콘텐츠를 생성해보세요</div>
-          <v-btn
-            color="primary"
-            @click="$router.push('/content/create')"
+    <!-- 컨트롤 영역 -->
+    <v-row class="mb-4">
+      <!-- 콘텐츠 타입 필터 -->
+      <v-col cols="12" md="6">
+        <v-chip-group
+          v-model="selectedContentType"
+          selected-class="text-white"
+          mandatory
+          class="mb-3"
+        >
+          <v-chip
+            v-for="option in contentTypeOptions"
+            :key="option.value"
+            :value="option.value"
+            :color="option.color"
+            @click="selectContentType(option.value)"
+            class="mr-2"
           >
-            콘텐츠 생성하기
-          </v-btn>
-        </div>
+            <span class="mr-1">{{ option.emoji }}</span>
+            {{ option.title }}
+          </v-chip>
+        </v-chip-group>
+      </v-col>
 
-        <!-- 리스트 뷰 - 정렬 가능한 테이블 -->
-        <div v-else>
-          <v-table>
-            <thead>
-              <tr>
-                <th width="50">
-                  <v-checkbox
-                    v-model="selectAll"
-                    @change="toggleSelectAll"
-                    density="compact"
-                  />
-                </th>
-                <th width="450">제목</th>
-                <th width="150">플랫폼</th>
-                <!-- 프로모션 기간 - 정렬 가능 -->
-                <th 
-                  width="200" 
-                  class="sortable-header cursor-pointer"
-                  @click="sortByPromotionDate"
+      <!-- 검색 및 정렬 -->
+      <v-col cols="12" md="6">
+        <div class="d-flex gap-3">
+          <!-- 검색 -->
+          <v-text-field
+            v-model="searchQuery"
+            placeholder="제목, 내용, 해시태그로 검색..."
+            prepend-inner-icon="mdi-magnify"
+            variant="outlined"
+            density="compact"
+            hide-details
+            clearable
+            @input="applyFilters"
+            class="flex-grow-1"
+          />
+          
+          <!-- 정렬 -->
+          <v-select
+            v-model="sortBy"
+            :items="sortOptions"
+            item-title="title"
+            item-value="value"
+            variant="outlined"
+            density="compact"
+            hide-details
+            style="min-width: 140px;"
+          />
+        </div>
+      </v-col>
+    </v-row>
+
+    <!-- 액션 버튼 영역 -->
+    <div class="d-flex justify-space-between align-center mb-4">
+      <div class="d-flex align-center">
+        <span class="text-body-2 text-grey-600">
+          총 {{ filteredContents.length }}개 콘텐츠
+        </span>
+        <v-btn
+          v-if="selectedItems.length > 0"
+          color="error"
+          variant="text"
+          prepend-icon="mdi-delete"
+          @click="deleteSelectedItems"
+          class="ml-4"
+        >
+          선택 삭제 ({{ selectedItems.length }})
+        </v-btn>
+      </div>
+
+      <v-btn
+        color="primary"
+        prepend-icon="mdi-plus"
+        @click="$router.push('/content/create')"
+      >
+        새 콘텐츠 생성
+      </v-btn>
+    </div>
+
+    <!-- 로딩 상태 -->
+    <div v-if="loading" class="text-center py-8">
+      <v-progress-circular indeterminate color="primary" size="64" />
+      <div class="mt-4 text-body-1">콘텐츠를 불러오는 중...</div>
+    </div>
+
+    <!-- 콘텐츠가 없는 경우 -->
+    <div v-else-if="filteredContents.length === 0" class="text-center py-12">
+      <v-icon size="120" color="grey-lighten-2" class="mb-4">mdi-file-document-outline</v-icon>
+      <div class="text-h6 mb-2">표시할 콘텐츠가 없습니다</div>
+      <div class="text-body-2 text-grey-600 mb-4">새로운 콘텐츠를 생성해보세요</div>
+      <v-btn color="primary" @click="$router.push('/content/create')">
+        콘텐츠 생성하기
+      </v-btn>
+    </div>
+
+    <!-- 리스트 뷰 - 정렬 가능한 테이블 -->
+    <div v-else>
+      <v-table>
+        <thead>
+          <tr>
+            <th width="50">
+              <v-checkbox
+                v-model="selectAll"
+                @change="toggleSelectAll"
+                density="compact"
+              />
+            </th>
+            <th width="450">제목</th>
+            <th width="150">플랫폼</th>
+            <!-- 프로모션 기간 - 정렬 가능 -->
+            <th 
+              width="200" 
+              class="sortable-header cursor-pointer"
+              @click="sortByPromotionDate"
+            >
+              <div class="d-flex align-center">
+                <span>프로모션 기간</span>
+                <v-icon 
+                  :color="promotionSortOrder === 'none' ? 'grey-lighten-1' : 'primary'"
+                  size="16" 
+                  class="ml-1"
                 >
-                  <div class="d-flex align-center">
-                    <span>프로모션 기간</span>
-                    <v-icon 
-                      :color="promotionSortOrder === 'none' ? 'grey-lighten-1' : 'primary'"
-                      size="16" 
-                      class="ml-1"
-                    >
-                      {{
-                        promotionSortOrder === 'asc' ? 'mdi-arrow-up' :
-                        promotionSortOrder === 'desc' ? 'mdi-arrow-down' :
-                        'mdi-unfold-more-horizontal'
-                      }}
-                    </v-icon>
-                  </div>
-                </th>
-                <th width="120">액션</th>
-              </tr>
-            </thead>
-            <tbody>
-              <tr v-for="content in paginatedContents" :key="content.id" class="cursor-pointer" @click="showDetail(content)">
-                <td @click.stop>
-                  <v-checkbox
-                    v-model="selectedItems"
-                    :value="content.id"
-                    density="compact"
-                  />
-                </td>
-                <td>
-                  <div class="d-flex flex-column">
-                    <div class="d-flex align-center mb-1">
-                      <span class="font-weight-medium text-subtitle-2 mr-2">{{ content.title }}</span>
-                      <v-chip
-                        :color="getStatusColor(content.status)"
-                        size="x-small"
-                        variant="tonal"
-                      >
-                        {{ getStatusText(content.status) }}
-                      </v-chip>
-                    </div>
-                    <div class="text-caption text-truncate grey--text" style="max-width: 400px;">
-                      {{ content.content ? content.content.substring(0, 80) + '...' : '' }}
-                    </div>
-                  </div>
-                </td>
-                <td>
+                  {{
+                    promotionSortOrder === 'asc' ? 'mdi-arrow-up' :
+                    promotionSortOrder === 'desc' ? 'mdi-arrow-down' :
+                    'mdi-unfold-more-horizontal'
+                  }}
+                </v-icon>
+              </div>
+            </th>
+            <th width="120">액션</th>
+          </tr>
+        </thead>
+        <tbody>
+          <tr v-for="content in paginatedContents" :key="content.id" class="cursor-pointer" @click="showDetail(content)">
+            <td @click.stop>
+              <v-checkbox
+                v-model="selectedItems"
+                :value="content.id"
+                density="compact"
+              />
+            </td>
+            <td>
+              <div class="d-flex flex-column">
+                <div class="d-flex align-center mb-1">
+                  <span class="font-weight-medium text-subtitle-2 mr-2">{{ content.title }}</span>
                   <v-chip
-                    :color="getPlatformColor(content.platform)"
-                    size="small"
+                    :color="getStatusColor(content.status)"
+                    size="x-small"
                     variant="tonal"
                   >
-                    {{ getPlatformText(content.platform) }}
+                    {{ getStatusText(content.status) }}
                   </v-chip>
-                </td>
-                <td>
-                  <div class="text-body-2">
-                    {{ formatDateRange(content.startDate, content.endDate) }}
-                  </div>
-                </td>
-                <td @click.stop>
-                  <div class="d-flex ga-1">
-                    <v-btn
-                      icon="mdi-eye"
-                      size="small"
-                      variant="text"
-                      @click="showDetail(content)"
-                    />
-                    <v-btn
-                      icon="mdi-pencil"
-                      size="small"
-                      variant="text"
-                      @click="showDetailWithEdit(content)"
-                    />
-                    <v-btn
-                      icon="mdi-delete"
-                      size="small"
-                      variant="text"
-                      color="error"
-                      @click="confirmDelete(content)"
-                    />
-                  </div>
-                </td>
-              </tr>
-            </tbody>
-          </v-table>
-        </div>
-      </v-card-text>
-    </v-card>
+                </div>
+                <div class="text-caption text-truncate grey--text" style="max-width: 400px;">
+                  {{ content.content ? content.content.substring(0, 100) + '...' : '' }}
+                </div>
+              </div>
+            </td>
+            <td>
+              <v-chip
+                :color="getPlatformColor(content.platform)"
+                size="small"
+                variant="tonal"
+              >
+                {{ getPlatformText(content.platform) }}
+              </v-chip>
+            </td>
+            <td>
+              <div class="text-body-2">
+                {{ formatDateRange(content.startDate, content.endDate) }}
+              </div>
+            </td>
+            <td @click.stop>
+              <div class="d-flex">
+                <v-btn
+                  icon="mdi-pencil"
+                  size="small"
+                  variant="text"
+                  @click="showDetailWithEdit(content)"
+                />
+                <v-btn
+                  icon="mdi-delete"
+                  size="small"
+                  variant="text"
+                  color="error"
+                  @click="confirmDelete(content)"
+                />
+              </div>
+            </td>
+          </tr>
+        </tbody>
+      </v-table>
 
-    <!-- 페이지네이션 -->
-    <div v-if="totalPages > 1" class="d-flex justify-center mt-6">
-      <v-pagination
-        v-model="currentPage"
-        :length="totalPages"
-        :total-visible="7"
-        color="primary"
-        @update:model-value="scrollToTop"
-      />
+      <!-- 페이지네이션 -->
+      <div class="d-flex justify-center mt-6" v-if="totalPages > 1">
+        <v-pagination
+          v-model="currentPage"
+          :length="totalPages"
+          :total-visible="7"
+          @update:model-value="scrollToTop"
+        />
+      </div>
     </div>
 
-    <!-- 상세 보기/수정 다이얼로그 -->
+    <!-- 상세/수정 다이얼로그 -->
     <v-dialog v-model="showDetailDialog" max-width="800px" scrollable>
       <v-card>
         <v-card-title class="d-flex justify-space-between align-center">
-          <span>{{ isEditMode ? '콘텐츠 수정' : '콘텐츠 상세 정보' }}</span>
-          <v-btn
-            icon="mdi-close"
-            variant="text"
-            @click="closeDialog"
-          />
+          <span class="text-h6">{{ isEditMode ? '콘텐츠 수정' : '콘텐츠 상세' }}</span>
+          <v-btn icon="mdi-close" variant="text" @click="closeDialog" />
         </v-card-title>
-        
-        <v-divider />
-        
-        <v-card-text class="pa-4" style="max-height: 70vh;">
-          <v-form ref="editForm" v-model="editFormValid" v-if="selectedContent">
-            <!-- 제목 -->
-            <div class="mb-4">
-              <label class="text-subtitle-2 font-weight-medium mb-2 d-block">제목</label>
-              <v-text-field
-                v-if="isEditMode"
-                v-model="editingContent.title"
-                :rules="titleRules"
-                variant="outlined"
-                density="compact"
-              />
-              <div v-else class="text-body-1 font-weight-medium">
-                {{ selectedContent.title }}
-              </div>
-            </div>
 
-            <!-- 플랫폼 (수정 시 비활성화) -->
-            <div class="mb-4">
-              <label class="text-subtitle-2 font-weight-medium mb-2 d-block">플랫폼</label>
-              <v-chip :color="getPlatformColor(selectedContent.platform)" variant="tonal">
-                {{ getPlatformText(selectedContent.platform) }}
-              </v-chip>
-              <div v-if="isEditMode" class="text-caption text-grey-600 mt-1">
-                플랫폼은 수정할 수 없습니다.
-              </div>
-            </div>
-
-            <!-- 홍보 기간 -->
-            <div class="mb-4">
-              <label class="text-subtitle-2 font-weight-medium mb-2 d-block">홍보 기간</label>
-              <div v-if="isEditMode" class="d-flex ga-2">
+        <v-card-text v-if="selectedContent">
+          <v-form ref="editForm" v-model="editFormValid" v-if="isEditMode">
+            <!-- 수정 모드 -->
+            <v-text-field
+              v-model="editingContent.title"
+              label="제목"
+              :rules="titleRules"
+              variant="outlined"
+              class="mb-4"
+            />
+            
+            <v-textarea
+              v-model="editingContent.content"
+              label="내용"
+              rows="8"
+              variant="outlined"
+              class="mb-4"
+            />
+            
+            <v-text-field
+              v-model="editingContent.hashtags"
+              label="해시태그 (쉼표로 구분)"
+              variant="outlined"
+              class="mb-4"
+              hint="예: #맛집, #신메뉴, #이벤트"
+            />
+            
+            <v-row>
+              <v-col cols="6">
                 <v-text-field
                   v-model="editingContent.startDate"
-                  type="date"
                   label="시작일"
+                  type="date"
                   variant="outlined"
-                  density="compact"
                 />
+              </v-col>
+              <v-col cols="6">
                 <v-text-field
                   v-model="editingContent.endDate"
-                  type="date"
                   label="종료일"
+                  type="date"
                   variant="outlined"
-                  density="compact"
                 />
-              </div>
-              <div v-else class="text-body-1">
-                {{ formatDateRange(selectedContent.startDate, selectedContent.endDate) }}
-              </div>
-            </div>
+              </v-col>
+            </v-row>
+          </v-form>
 
-            <!-- 내용 (수정 시 비활성화) -->
+          <div v-else>
+            <!-- 상세 보기 모드 -->
             <div class="mb-4">
-              <label class="text-subtitle-2 font-weight-medium mb-2 d-block">내용</label>
-              <div v-if="isEditMode" class="pa-3 bg-grey-lighten-4 rounded">
-                <div class="text-body-2 text-grey-600 mb-2">
-                  내용은 수정할 수 없습니다. 새로 생성해주세요.
-                </div>
-              </div>
-              <div v-else class="text-body-1" style="white-space: pre-wrap;">
-                {{ selectedContent.content }}
-              </div>
+              <div class="text-subtitle-2 text-grey-600 mb-1">제목</div>
+              <div class="text-body-1">{{ selectedContent.title }}</div>
             </div>
-
-            <!-- 해시태그 (수정 시 비활성화) -->
+            
             <div class="mb-4">
-              <label class="text-subtitle-2 font-weight-medium mb-2 d-block">해시태그</label>
-              <div class="d-flex flex-wrap ga-1">
+              <div class="text-subtitle-2 text-grey-600 mb-1">플랫폼</div>
+              <v-chip :color="getPlatformColor(selectedContent.platform)" size="small" variant="tonal">
+                {{ getPlatformText(selectedContent.platform) }}
+              </v-chip>
+            </div>
+            
+            <div class="mb-4">
+              <div class="text-subtitle-2 text-grey-600 mb-1">내용</div>
+              <div class="text-body-1 content-preview">{{ selectedContent.content }}</div>
+            </div>
+            
+            <div class="mb-4" v-if="selectedContent.hashtags && selectedContent.hashtags.length > 0">
+              <div class="text-subtitle-2 text-grey-600 mb-1">해시태그</div>
+              <div class="d-flex flex-wrap gap-1">
                 <v-chip
                   v-for="tag in selectedContent.hashtags"
                   :key="tag"
-                  class="mr-1 mb-1"
                   size="small"
+                  variant="outlined"
                   color="primary"
                 >
-                  #{{ tag }}
+                  {{ tag }}
                 </v-chip>
               </div>
-              <div v-if="isEditMode" class="text-caption text-grey-600 mt-1">
-                해시태그는 수정할 수 없습니다. 새로 생성해주세요.
-              </div>
             </div>
-          </v-form>
+            
+            <div class="mb-4">
+              <div class="text-subtitle-2 text-grey-600 mb-1">프로모션 기간</div>
+              <div class="text-body-1">{{ formatDateRange(selectedContent.startDate, selectedContent.endDate) }}</div>
+            </div>
+            
+            <div class="mb-4">
+              <div class="text-subtitle-2 text-grey-600 mb-1">상태</div>
+              <v-chip :color="getStatusColor(selectedContent.status)" size="small" variant="tonal">
+                {{ getStatusText(selectedContent.status) }}
+              </v-chip>
+            </div>
+            
+            <div class="mb-4">
+              <div class="text-subtitle-2 text-grey-600 mb-1">생성일</div>
+              <div class="text-body-1">{{ formatDateTime(selectedContent.createdAt) }}</div>
+            </div>
+          </div>
         </v-card-text>
-        
-        <!-- 개선된 버튼 영역 -->
-        <v-card-actions class="pa-4">
-          <v-spacer />
-          <div v-if="isEditMode" class="d-flex ga-3">
-            <v-btn 
+
+        <v-card-actions v-if="selectedContent">
+          <div v-if="isEditMode" class="d-flex justify-end w-100 gap-2">
+            <v-btn
               variant="outlined"
-              color="grey"
               @click="cancelEdit"
-              class="px-6"
+              :disabled="updating"
             >
               취소
             </v-btn>
-            <v-btn 
-              color="primary" 
+            <v-btn
+              color="primary"
               @click="saveEdit"
               :loading="updating"
               :disabled="!editFormValid"
-              class="px-6 elevation-2"
+              class="px-6 elevation-1"
             >
               저장
             </v-btn>
           </div>
-          <div v-else class="d-flex ga-3">
-            <v-btn 
+          
+          <div v-else class="d-flex justify-end w-100 gap-2">
+            <v-btn
               variant="outlined"
-              color="primary"
-              prepend-icon="mdi-pencil"
               @click="showEditMode"
               class="px-6 elevation-1"
             >
               수정
             </v-btn>
-            <v-btn 
-              variant="outlined"
+            <v-btn
               color="error"
+              variant="outlined"
               prepend-icon="mdi-delete"
               @click="confirmDelete(selectedContent)"
               class="px-6 elevation-1"
@@ -372,6 +380,7 @@
 import { ref, computed, onMounted, watch } from 'vue'
 import { useRouter } from 'vue-router'
 import { useContentStore } from '@/store/content'
+import { useAuthStore } from '@/store/auth'
 
 /**
  * 콘텐츠 관리 화면
@@ -383,6 +392,7 @@ import { useContentStore } from '@/store/content'
 
 // 스토어 및 라우터
 const contentStore = useContentStore()
+const authStore = useAuthStore()
 const router = useRouter()
 
 // 반응형 데이터
@@ -519,26 +529,73 @@ const totalPages = computed(() => {
 const loadContents = async () => {
   loading.value = true
   try {
-    await contentStore.loadContents()
+    console.log('=== 콘텐츠 목록 조회 시작 ===')
+    
+    // 📋 API 설계서에 따른 쿼리 파라미터 준비
+    const filters = {
+      contentType: selectedContentType.value !== 'all' ? selectedContentType.value : null,
+      platform: getPlatformForAPI(selectedContentType.value),
+      period: 'all', // 기본값
+      sortBy: sortBy.value || 'latest'
+    }
+    
+    console.log('API 요청 필터:', filters)
+    
+    // 📡 콘텐츠 스토어를 통해 API 호출
+    await contentStore.loadContents(filters)
+    
+    console.log('✅ 콘텐츠 로딩 완료, 개수:', contentStore.contents?.length || 0)
+    
   } catch (error) {
-    console.error('콘텐츠 로딩 실패:', error)
+    console.error('❌ 콘텐츠 로딩 실패:', error)
     showError.value = true
-    errorMessage.value = '콘텐츠를 불러오는데 실패했습니다.'
+    errorMessage.value = error.message || '콘텐츠를 불러오는데 실패했습니다.'
   } finally {
     loading.value = false
   }
 }
 
+// 플랫폼 값을 API 요청용으로 변환
+const getPlatformForAPI = (contentType) => {
+  const platformMapping = {
+    'instagram': 'INSTAGRAM',
+    'blog': 'NAVER_BLOG', 
+    'poster': 'POSTER',
+    'all': null
+  }
+  return platformMapping[contentType] || null
+}
+
 const selectContentType = (type) => {
   selectedContentType.value = type
   currentPage.value = 1
-  // 필터 변경 시 정렬 상태 초기화하지 않음 (별도 처리)
+  // 타입 변경 시 다시 로딩
+  loadContents()
 }
 
 const applyFilters = () => {
   currentPage.value = 1
 }
 
+const sortByPromotionDate = () => {
+  // 프로모션 기간 정렬 토글
+  if (promotionSortOrder.value === 'none') {
+    promotionSortOrder.value = 'desc'
+  } else if (promotionSortOrder.value === 'desc') {
+    promotionSortOrder.value = 'asc'
+  } else {
+    promotionSortOrder.value = 'none'
+  }
+}
+
+const toggleSelectAll = () => {
+  if (selectAll.value) {
+    selectedItems.value = paginatedContents.value.map(content => content.id)
+  } else {
+    selectedItems.value = []
+  }
+}
+
 const scrollToTop = () => {
   window.scrollTo({ top: 0, behavior: 'smooth' })
 }
@@ -626,274 +683,123 @@ const deleteSelectedItems = async () => {
   }
 }
 
-const toggleSelectAll = () => {
-  if (selectAll.value) {
-    selectedItems.value = paginatedContents.value.map(content => content.id)
-  } else {
-    selectedItems.value = []
+// 유틸리티 함수들
+const getStatusColor = (status) => {
+  const statusColors = {
+    'DRAFT': 'orange',
+    'PUBLISHED': 'green', 
+    'SCHEDULED': 'blue',
+    'ARCHIVED': 'grey'
   }
+  return statusColors[status] || 'grey'
 }
 
-const sortByPromotionDate = () => {
-  if (promotionSortOrder.value === 'none') {
-    promotionSortOrder.value = 'asc'
-  } else if (promotionSortOrder.value === 'asc') {
-    promotionSortOrder.value = 'desc'
-  } else {
-    promotionSortOrder.value = 'none'
+const getStatusText = (status) => {
+  const statusTexts = {
+    'DRAFT': '임시저장',
+    'PUBLISHED': '발행됨',
+    'SCHEDULED': '예약됨', 
+    'ARCHIVED': '보관됨'
   }
-}
-
-// 헬퍼 메서드
-const getTotalCount = () => {
-  return contentStore.contents?.length || 0
-}
-
-const getTypeCount = (type) => {
-  if (type === 'all') return getTotalCount()
-  return contentStore.contents?.filter(content => {
-    // 플랫폼 매핑 처리
-    const platformMapping = {
-      'instagram': ['instagram', 'INSTAGRAM'],
-      'blog': ['blog', 'NAVER_BLOG', 'naver_blog'],
-      'poster': ['poster', 'POSTER']
-    }
-    
-    const allowedPlatforms = platformMapping[type] || [type]
-    return allowedPlatforms.includes(content.platform)
-  }).length || 0
+  return statusTexts[status] || status
 }
 
 const getPlatformColor = (platform) => {
-  const colors = {
-    'instagram': 'pink',
+  const platformColors = {
     'INSTAGRAM': 'pink',
-    'blog': 'green',
+    'instagram': 'pink',
     'NAVER_BLOG': 'green',
-    'poster': 'orange',
-    'POSTER': 'orange'
+    'blog': 'green',
+    'naver_blog': 'green',
+    'POSTER': 'orange',
+    'poster': 'orange'
   }
-  return colors[platform] || 'grey'
+  return platformColors[platform] || 'grey'
 }
 
 const getPlatformText = (platform) => {
-  const texts = {
-    'instagram': 'Instagram',
-    'INSTAGRAM': 'Instagram',
-    'blog': '네이버 블로그',
+  const platformTexts = {
+    'INSTAGRAM': '인스타그램',
+    'instagram': '인스타그램',
     'NAVER_BLOG': '네이버 블로그',
-    'poster': '포스터',
-    'POSTER': '포스터'
+    'blog': '네이버 블로그',
+    'naver_blog': '네이버 블로그',
+    'POSTER': '포스터',
+    'poster': '포스터'
   }
-  return texts[platform] || platform
-}
-
-const getStatusColor = (status) => {
-  const colors = {
-    'published': 'success',
-    'draft': 'warning',
-    'archived': 'grey'
-  }
-  return colors[status] || 'grey'
+  return platformTexts[platform] || platform
 }
 
 const formatDateRange = (startDate, endDate) => {
-  if (!startDate && !endDate) return '-'
-  
-  const formatDate = (date) => {
-    if (!date) return ''
-    return new Date(date).toLocaleDateString('ko-KR', {
-      year: 'numeric',
-      month: 'short',
-      day: 'numeric'
-    })
-  }
-  
-  const start = formatDate(startDate)
-  const end = formatDate(endDate)
-  
-  if (start && end) {
-    return `${start} ~ ${end}`
-  } else if (start) {
-    return `${start} ~`
-  } else if (end) {
-    return `~ ${end}`
-  }
-  
-  return '-'
+  if (!startDate && !endDate) return '기간 미설정'
+  if (!endDate) return formatDate(startDate) + ' ~'
+  if (!startDate) return '~ ' + formatDate(endDate)
+  return formatDate(startDate) + ' ~ ' + formatDate(endDate)
 }
 
-// 라이프사이클
-onMounted(async () => {
-  loading.value = true
+const formatDate = (dateString) => {
+  if (!dateString) return ''
   try {
-    await contentStore.loadContents()
+    const date = new Date(dateString)
+    return date.toLocaleDateString('ko-KR', {
+      year: 'numeric',
+      month: '2-digit',
+      day: '2-digit'
+    })
   } catch (error) {
-    console.error('콘텐츠 로딩 실패:', error)
-    showError.value = true
-    errorMessage.value = '콘텐츠를 불러오는데 실패했습니다.'
-  } finally {
-    loading.value = false
+    return dateString
   }
+}
+
+const formatDateTime = (dateString) => {
+  if (!dateString) return ''
+  try {
+    const date = new Date(dateString)
+    return date.toLocaleString('ko-KR', {
+      year: 'numeric',
+      month: '2-digit',
+      day: '2-digit',
+      hour: '2-digit',
+      minute: '2-digit'
+    })
+  } catch (error) {
+    return dateString
+  }
+}
+
+// 정렬 변경 감지
+watch(sortBy, () => {
+  // 일반 정렬 선택 시 프로모션 정렬 초기화
+  promotionSortOrder.value = 'none'
 })
 
-// 와처
-watch(selectedItems, (newVal) => {
-  selectAll.value = newVal.length === paginatedContents.value.length && newVal.length > 0
-})
-
-// 프로모션 정렬 상태가 변경될 때 다른 정렬 옵션 리셋
-watch(promotionSortOrder, (newVal) => {
-  if (newVal !== 'none') {
-    // 프로모션 정렬이 활성화될 때는 다른 정렬 옵션을 비활성화
-    console.log(`프로모션 기간 정렬: ${newVal === 'asc' ? '오름차순' : '내림차순'}`)
+// 컴포넌트 마운트 시 데이터 로드
+onMounted(() => {
+  console.log('🔄 ContentManagementView 마운트됨')
+  
+  // 인증 확인
+  if (!authStore.isAuthenticated) {
+    console.log('❌ 인증되지 않은 사용자')
+    router.push('/login')
+    return
   }
+  
+  // 콘텐츠 로딩
+  loadContents()
 })
 </script>
 
 <style scoped>
-.cursor-pointer {
-  cursor: pointer;
-}
-
-.text-truncate {
-  white-space: nowrap;
-  overflow: hidden;
-  text-overflow: ellipsis;
-}
-
-/* 정렬 가능한 헤더 스타일 */
-.sortable-header {
-  transition: background-color 0.2s ease-in-out;
-}
-
 .sortable-header:hover {
   background-color: rgba(0, 0, 0, 0.04);
 }
 
-.sortable-header .v-icon {
-  transition: color 0.2s ease-in-out;
+.content-preview {
+  white-space: pre-wrap;
+  word-break: break-word;
 }
 
-/* 칩 hover 효과 강화 */
-.v-chip {
+.cursor-pointer {
   cursor: pointer;
-  transition: all 0.2s ease-in-out;
-}
-
-.v-chip:hover {
-  transform: translateY(-1px);
-  box-shadow: 0 2px 4px rgba(0, 0, 0, 0.1);
-}
-
-.chip-hover:hover {
-  transform: translateY(-2px);
-  box-shadow: 0 4px 8px rgba(0, 0, 0, 0.15);
-}
-
-/* 선택된 칩 강조 */
-.v-chip.v-chip--variant-flat {
-  font-weight: 600;
-  box-shadow: 0 2px 6px rgba(0, 0, 0, 0.2);
-}
-
-/* 버튼 hover 효과 */
-.v-btn {
-  transition: all 0.2s ease-in-out;
-}
-
-.v-btn:hover {
-  transform: translateY(-1px);
-}
-
-/* 테이블 행 hover 효과 */
-.v-table tbody tr:hover {
-  background-color: rgba(0, 0, 0, 0.04);
-}
-
-/* 카드 hover 효과 */
-.v-card.cursor-pointer:hover {
-  transform: translateY(-2px);
-  box-shadow: 0 4px 12px rgba(0, 0, 0, 0.15);
-  transition: all 0.2s ease-in-out;
-}
-
-/* 다이얼로그 버튼 스타일링 */
-.v-card-actions .v-btn {
-  font-weight: 500;
-  letter-spacing: 0.5px;
-}
-
-.v-card-actions .v-btn.elevation-2:hover {
-  box-shadow: 0 4px 8px rgba(0, 0, 0, 0.2);
-}
-
-.v-card-actions .v-btn.elevation-1:hover {
-  box-shadow: 0 2px 6px rgba(0, 0, 0, 0.15);
-}
-
-/* 비활성화된 입력 필드 스타일 */
-.bg-grey-lighten-4 {
-  background-color: #f5f5f5;
-  border: 1px solid #e0e0e0;
-}
-
-/* 테이블 스타일 개선 */
-.v-table {
-  border-radius: 8px;
-  overflow: hidden;
-}
-
-.v-table thead th {
-  background-color: #f8f9fa;
-  font-weight: 600;
-  color: #495057;
-  position: relative;
-}
-
-.v-table tbody td {
-  vertical-align: middle;
-}
-
-/* 필터 카드 스타일 */
-.v-card {
-  box-shadow: 0 2px 8px rgba(0, 0, 0, 0.1);
-}
-
-/* 반응형 디자인 */
-@media (max-width: 768px) {
-  .d-flex.justify-space-between.align-center {
-    flex-direction: column;
-    align-items: stretch;
-    gap: 16px;
-  }
-  
-  .v-row .v-col {
-    margin-bottom: 8px;
-  }
-  
-  .v-table {
-    font-size: 0.875rem;
-  }
-  
-  .v-table th,
-  .v-table td {
-    padding: 8px 4px;
-  }
-  
-  .sortable-header {
-    font-size: 0.8rem;
-  }
-}
-
-/* 정렬 아이콘 애니메이션 */
-@keyframes sortActive {
-  0% { transform: scale(1); }
-  50% { transform: scale(1.1); }
-  100% { transform: scale(1); }
-}
-
-.sortable-header .v-icon[style*="color: rgb(25, 118, 210)"] {
-  animation: sortActive 0.3s ease-in-out;
 }
 </style>
\ No newline at end of file
diff --git a/src/views/StoreManagementView.vue b/src/views/StoreManagementView.vue
index ddea127..7584086 100644
--- a/src/views/StoreManagementView.vue
+++ b/src/views/StoreManagementView.vue
@@ -1,7 +1,18 @@
-//* src/views/StoreManagementView.vue - 완전한 매장 관리 화면 (이미지 업로드 포함)
-
 <template>
   <v-container fluid class="pa-4">
+    <!-- 뒤로가기 버튼과 제목 -->
+    <div class="d-flex align-center mb-4">
+      <v-btn
+        icon
+        variant="text"
+        @click="$router.go(-1)"
+        class="me-2"
+      >
+        <v-icon>mdi-arrow-left</v-icon>
+      </v-btn>
+      <h1 class="text-h5 font-weight-bold">매장 관리</h1>
+    </div>
+
     <!-- 매장 정보가 없는 경우 -->
     <div v-if="!storeStore.hasStoreInfo && !storeStore.loading">
       <v-row justify="center">
@@ -113,50 +124,44 @@
                 
                     <v-col cols="12" sm="6">
                       <div class="info-item">
-                        <v-icon class="mr-2" color="grey">mdi-calendar-remove</v-icon>
+                        <v-icon class="mr-2" color="grey">mdi-account-group</v-icon>
                         <div>
-                          <div class="text-caption text-grey">휴무일</div>
-                          <div class="text-body-1">
-                            {{ formatClosedDays(storeInfo.closedDays) }}
-                          </div>
-                        </div>
-                      </div>
-                    </v-col>
-                  </v-row>
-
-                  <!-- SNS 정보 -->
-                  <v-divider class="my-6" />
-                  
-                  <h4 class="text-h6 font-weight-bold mb-4">
-                    <v-icon class="mr-2" color="primary">mdi-share-variant</v-icon>
-                    SNS 정보
-                  </h4>
-                  
-                  <v-row>
-                    <v-col cols="12" sm="6">
-                      <div class="info-item">
-                        <v-icon class="mr-2" color="pink">mdi-instagram</v-icon>
-                        <div>
-                          <div class="text-caption text-grey">인스타그램</div>
-                          <div class="text-body-1">
-                            {{ storeInfo.instaAccounts || '미연동' }}
-                          </div>
+                          <div class="text-caption text-grey">좌석 수</div>
+                          <div class="text-body-1">{{ storeInfo.seatCount || 0 }}석</div>
                         </div>
                       </div>
                     </v-col>
                     
                     <v-col cols="12" sm="6">
                       <div class="info-item">
-                        <v-icon class="mr-2" color="green">mdi-post</v-icon>
+                        <v-icon class="mr-2" color="grey">mdi-calendar-off</v-icon>
                         <div>
-                          <div class="text-caption text-grey">네이버 블로그</div>
-                          <div class="text-body-1">
-                            {{ storeInfo.blogAccounts || '미연동' }}
-                          </div>
+                          <div class="text-caption text-grey">휴무일</div>
+                          <div class="text-body-1">{{ formatClosedDays(storeInfo.holidays) }}</div>
+                        </div>
+                      </div>
+                    </v-col>
+                    
+                    <v-col cols="12" sm="6">
+                      <div class="info-item">
+                        <v-icon class="mr-2" color="grey">mdi-instagram</v-icon>
+                        <div>
+                          <div class="text-caption text-grey">인스타그램</div>
+                          <div class="text-body-1">{{ storeInfo.instaAccounts || '미입력' }}</div>
                         </div>
                       </div>
                     </v-col>
                   </v-row>
+                  
+                  <!-- 매장 소개 -->
+                  <v-divider class="my-4" />
+                  <div class="info-item">
+                    <v-icon class="mr-2" color="grey">mdi-text</v-icon>
+                    <div>
+                      <div class="text-caption text-grey">매장 소개</div>
+                      <div class="text-body-1">{{ storeInfo.description || '매장 소개가 없습니다' }}</div>
+                    </div>
+                  </div>
                 </v-col>
               </v-row>
             </v-card-text>
@@ -165,46 +170,48 @@
 
         <!-- 메뉴 관리 탭 -->
         <v-tabs-window-item value="menu">
-          <!-- 메뉴 관리 도구 -->
-          <v-card class="mb-4">
-            <v-card-title class="pa-4 d-flex align-center justify-space-between">
-              <div class="d-flex align-center">
-                <v-icon class="mr-2" color="primary">mdi-food</v-icon>
-                메뉴 관리
-              </div>
-              <v-btn
-                color="primary"
-                prepend-icon="mdi-plus"
-                @click="openCreateMenuDialog"
-              >
-                메뉴 등록
-              </v-btn>
-            </v-card-title>
-            
-            <v-divider />
-            
-            <v-card-text class="pa-4">
-              <!-- 검색 및 필터 -->
-              <v-row class="mb-4">
-                <v-col cols="12" sm="6">
+          <!-- 검색 및 필터 섹션 -->
+          <v-card class="mb-4" elevation="2">
+            <v-card-text>
+              <v-row>
+                <v-col cols="12" md="6">
                   <v-text-field
                     v-model="menuSearch"
+                    prepend-inner-icon="mdi-magnify"
                     label="메뉴 검색"
                     variant="outlined"
-                    prepend-inner-icon="mdi-magnify"
+                    density="compact"
                     clearable
-                    hide-details
                   />
                 </v-col>
-                <v-col cols="12" sm="3">
+                <v-col cols="12" md="3">
                   <v-select
                     v-model="menuCategoryFilter"
-                    label="카테고리 필터"
-                    variant="outlined"
                     :items="['전체', ...menuCategories]"
-                    hide-details
+                    label="카테고리"
+                    variant="outlined"
+                    density="compact"
                   />
                 </v-col>
+                <v-col cols="12" md="3" class="d-flex align-center gap-2">
+                  <v-btn
+                    color="primary"
+                    variant="outlined"
+                    prepend-icon="mdi-filter-off"
+                    @click="clearFilters"
+                    size="small"
+                  >
+                    필터 초기화
+                  </v-btn>
+                  <v-btn
+                    color="primary"
+                    prepend-icon="mdi-plus"
+                    @click="openCreateMenuDialog"
+                    size="small"
+                  >
+                    메뉴 추가
+                  </v-btn>
+                </v-col>
               </v-row>
             </v-card-text>
           </v-card>
@@ -214,166 +221,147 @@
             <v-row>
               <v-col
                 v-for="menu in filteredMenus"
-                :key="menu.id"
+                :key="menu.id || menu.menuId"
                 cols="12"
                 sm="6"
                 md="4"
                 lg="3"
               >
                 <v-card
-                  class="menu-card h-100 position-relative"
+                  class="menu-card h-100"
                   elevation="2"
                   @click="viewMenuDetail(menu)"
                 >
-                  <!-- 메뉴 상태 배지 -->
-                  <div class="position-absolute top-0 right-0 pa-2" style="z-index: 1;">
-                    <v-chip
-                      :color="menu.available ? 'success' : 'error'"
-                      size="small"
-                      variant="elevated"
+                  <div class="position-relative">
+                    <!-- 메뉴 카드에서 이미지 표시 수정 -->
+                    <v-img
+                      :src="getMenuImageUrl(menu)"
+                      height="200"
+                      cover
+                      class="grey lighten-2"
+                      @error="handleImageError($event, menu)"
                     >
-                      {{ menu.available ? '판매중' : '품절' }}
-                    </v-chip>
+                      <template v-slot:placeholder>
+                        <div class="d-flex align-center justify-center fill-height">
+                          <v-progress-circular
+                            color="grey-lighten-4"
+                            indeterminate
+                          />
+                        </div>
+                      </template>
+                      <!-- 이미지 로딩 실패 시 플레이스홀더 표시 -->
+                      <template v-slot:error>
+                        <div class="d-flex align-center justify-center fill-height">
+                          <v-icon size="64" color="grey-lighten-2">mdi-image-off</v-icon>
+                        </div>
+                      </template>
+                    </v-img>
+                    
+                    <!-- 상태 뱃지 -->
+                    <div class="position-absolute top-0 right-0 pa-2">
+                      <v-chip
+                        v-if="!menu.available"
+                        color="red"
+                        size="small"
+                        class="mb-1"
+                      >
+                        품절
+                      </v-chip>
+                      <v-chip
+                        v-if="menu.recommended"
+                        color="orange"
+                        size="small"
+                      >
+                        추천
+                      </v-chip>
+                    </div>
+                    
+                    <!-- 액션 버튼 -->
+                    <div class="position-absolute top-0 left-0 pa-2">
+                      <v-btn
+                        icon="mdi-pencil"
+                        size="small"
+                        color="white"
+                        variant="elevated"
+                        @click.stop="editMenu(menu)"
+                        class="me-1"
+                      />
+                      <v-btn
+                        icon="mdi-delete"
+                        size="small"
+                        color="red"
+                        variant="elevated"
+                        @click.stop="confirmDeleteMenu(menu)"
+                      />
+                    </div>
                   </div>
                   
-                  <!-- 추천 메뉴 배지 -->
-                  <div
-                    v-if="menu.recommended"
-                    class="position-absolute top-0 left-0 pa-2"
-                    style="z-index: 1;"
-                  >
-                    <v-chip
-                      color="warning"
-                      size="small"
-                      variant="elevated"
-                    >
-                      <v-icon size="small" class="mr-1">mdi-star</v-icon>
-                      추천
-                    </v-chip>
-                  </div>
-
-                  <v-img
-                    :src="menu.imageUrl || menu.image || '/images/menu-placeholder.png'"
-                    :alt="menu.menuName"
-                    height="200"
-                    cover
-                  />
-
-                  <v-card-title class="pa-3">
-                    <div class="w-100">
-                      <div class="d-flex align-center justify-space-between mb-2">
-                        <h4 class="text-subtitle-1 font-weight-bold text-truncate">
-                          {{ menu.menuName }}
-                        </h4>
-                        <div class="d-flex align-center">
-                          <!-- 삭제 버튼 -->
-                          <v-btn
-                            icon
-                            size="small"
-                            variant="text"
-                            color="error"
-                            @click="deleteMenuDirect(menu, $event)"
-                          >
-                            <v-icon size="small">mdi-delete</v-icon>
-                          </v-btn>
-                          <!-- 수정 버튼 -->
-                          <v-btn
-                            icon
-                            size="small"
-                            variant="text"
-                            @click="editMenuDirect(menu, $event)"
-                          >
-                            <v-icon size="small">mdi-pencil</v-icon>
-                          </v-btn>
-                        </div>
-                      </div>
-                      
-                      <div class="d-flex align-center justify-space-between">
-                        <v-chip
-                          :color="getCategoryColor(menu.category)"
-                          size="small"
-                          variant="tonal"
-                        >
-                          {{ menu.category }}
-                        </v-chip>
-                        <span class="text-h6 font-weight-bold text-primary">
-                          {{ formatCurrency(menu.price) }}
-                        </span>
-                      </div>
-                      
-                      <p class="text-body-2 text-grey mt-2 text-truncate-2">
-                        {{ menu.description }}
-                      </p>
+                  <v-card-text class="pa-3">
+                    <div class="d-flex justify-space-between align-start mb-2">
+                      <h4 class="text-subtitle-1 font-weight-bold">
+                        {{ menu.menuName || menu.name }}
+                      </h4>
+                      <v-chip
+                        :color="menu.available ? 'green' : 'red'"
+                        size="small"
+                        variant="tonal"
+                      >
+                        {{ menu.available ? '판매중' : '품절' }}
+                      </v-chip>
                     </div>
-                  </v-card-title>
+                    
+                    <p class="text-body-2 text-grey text-truncate-2 mb-2">
+                      {{ menu.description || '설명이 없습니다' }}
+                    </p>
+                    
+                    <div class="d-flex justify-space-between align-center">
+                      <span class="text-h6 font-weight-bold text-primary">
+                        {{ menu.price ? menu.price.toLocaleString() : '0' }}원
+                      </span>
+                      <v-chip
+                        size="small"
+                        variant="outlined"
+                        color="primary"
+                      >
+                        {{ menu.category }}
+                      </v-chip>
+                    </div>
+                  </v-card-text>
                 </v-card>
               </v-col>
             </v-row>
           </div>
 
           <!-- 메뉴가 없는 경우 -->
-          <div v-else-if="menus.length === 0" class="empty-state pa-8">
-            <v-img
-              src="/images/menu-placeholder.png"
-              max-width="200"
-              class="mx-auto mb-4"
-            />
-            <h3 class="text-h6 font-weight-bold mb-3 text-center">등록된 메뉴가 없습니다</h3>
-            <p class="text-grey text-center mb-4">
-              첫 메뉴를 등록하여 AI 마케팅 콘텐츠를 생성해보세요
-            </p>
-            <div class="text-center">
-              <v-btn
-                color="primary"
-                prepend-icon="mdi-plus"
-                @click="openCreateMenuDialog"
-              >
-                메뉴 등록하기
-              </v-btn>
-            </div>
-          </div>
-
-          <!-- 필터 결과가 없는 경우 -->
-          <div v-else class="text-center pa-8">
-            <v-icon size="64" color="grey-lighten-2" class="mb-4">mdi-magnify</v-icon>
-            <h3 class="text-h6 font-weight-bold mb-3">검색 결과가 없습니다</h3>
-            <p class="text-grey mb-4">다른 검색 조건을 시도해보세요</p>
+          <v-card v-else class="text-center pa-8" elevation="2">
+            <v-icon size="64" color="grey-lighten-1" class="mb-4">mdi-food-off</v-icon>
+            <h3 class="text-h6 mb-2">등록된 메뉴가 없습니다</h3>
+            <p class="text-grey mb-4">첫 번째 메뉴를 등록해보세요</p>
             <v-btn
-              variant="outlined"
-              @click="clearFilters"
+              color="primary"
+              prepend-icon="mdi-plus"
+              @click="openCreateMenuDialog"
             >
-              필터 초기화
+              메뉴 등록하기
             </v-btn>
-          </div>
+          </v-card>
         </v-tabs-window-item>
       </v-tabs-window>
     </div>
 
     <!-- 로딩 상태 -->
-    <div v-else-if="storeStore.loading" class="text-center pa-8">
-      <v-progress-circular
-        size="64"
-        color="primary"
-        indeterminate
-        class="mb-4"
-      />
-      <p class="text-body-1">매장 정보를 불러오는 중...</p>
+    <div v-else class="text-center pa-8">
+      <v-progress-circular indeterminate color="primary" size="64" />
+      <p class="text-grey mt-4">매장 정보를 불러오는 중...</p>
     </div>
 
     <!-- 매장 등록/수정 다이얼로그 -->
-    <!-- 기존 매장 등록/수정 다이얼로그를 다음 내용으로 교체해주세요 -->
-
-    <!-- 매장 등록/수정 다이얼로그 -->
-    <v-dialog
-      v-model="showCreateDialog"
-      max-width="600"
-      persistent
-    >
+    <v-dialog v-model="showCreateDialog" max-width="600" persistent>
       <v-card>
         <v-card-title class="pa-4">
           <div class="d-flex align-center">
-            <v-icon class="mr-2" color="primary">mdi-store-plus</v-icon>
-            {{ editMode ? '매장 정보 수정' : '매장 정보 등록' }}
+            <v-icon class="mr-2" color="primary">mdi-store</v-icon>
+            {{ editMode ? '매장 정보 수정' : '새 매장 등록' }}
           </div>
         </v-card-title>
         
@@ -382,138 +370,135 @@
         <v-card-text class="pa-4">
           <v-form ref="storeFormRef" v-model="formValid">
             <v-row>
-              <!-- 매장명 -->
               <v-col cols="12">
                 <v-text-field
                   v-model="formData.storeName"
                   label="매장명 *"
                   :rules="[v => !!v || '매장명을 입력해주세요']"
-                  prepend-inner-icon="mdi-store"
                   variant="outlined"
+                  density="compact"
+                  required
                 />
               </v-col>
-
-              <!-- 업종 -->
+              
               <v-col cols="12" sm="6">
                 <v-select
                   v-model="formData.businessType"
-                  label="업종 *"
                   :items="businessTypes"
+                  label="업종 *"
                   :rules="[v => !!v || '업종을 선택해주세요']"
-                  prepend-inner-icon="mdi-domain"
                   variant="outlined"
+                  density="compact"
+                  required
                 />
               </v-col>
-
-              <!-- 좌석수 -->
+              
               <v-col cols="12" sm="6">
                 <v-text-field
                   v-model.number="formData.seatCount"
-                  label="좌석수"
+                  label="좌석 수"
                   type="number"
-                  prepend-inner-icon="mdi-chair-school"
                   variant="outlined"
-                  :min="0"
-                  :max="500"
+                  density="compact"
                 />
               </v-col>
-
-              <!-- 주소 -->
+              
               <v-col cols="12">
                 <v-text-field
                   v-model="formData.address"
                   label="주소 *"
                   :rules="[v => !!v || '주소를 입력해주세요']"
-                  prepend-inner-icon="mdi-map-marker"
                   variant="outlined"
+                  density="compact"
+                  required
                 />
               </v-col>
-
-              <!-- 전화번호 -->
-              <v-col cols="12">
+              
+              <v-col cols="12" sm="6">
                 <v-text-field
                   v-model="formData.phoneNumber"
                   label="전화번호"
-                  prepend-inner-icon="mdi-phone"
                   variant="outlined"
-                  placeholder="예) 02-1234-5678"
+                  density="compact"
                 />
               </v-col>
-
-              <!-- 영업시간 -->
+              
+              <v-col cols="12" sm="6">
+                <v-text-field
+                  v-model="formData.instagramUrl"
+                  label="인스타그램 URL"
+                  variant="outlined"
+                  density="compact"
+                />
+              </v-col>
+              
               <v-col cols="12" sm="6">
                 <v-text-field
                   v-model="formData.openTime"
                   label="오픈 시간"
                   type="time"
-                  prepend-inner-icon="mdi-clock-start"
                   variant="outlined"
+                  density="compact"
                 />
               </v-col>
-
+              
               <v-col cols="12" sm="6">
                 <v-text-field
                   v-model="formData.closeTime"
                   label="마감 시간"
                   type="time"
-                  prepend-inner-icon="mdi-clock-end"
                   variant="outlined"
+                  density="compact"
                 />
               </v-col>
-
-              <!-- 휴무일 -->
+              
               <v-col cols="12">
                 <v-select
                   v-model="formData.holidays"
-                  label="휴무일"
                   :items="weekDays"
-                  prepend-inner-icon="mdi-calendar-remove"
-                  variant="outlined"
+                  item-title="title"
+                  item-value="value"
+                  label="휴무일"
                   multiple
                   chips
-                  closable-chips
-                />
-              </v-col>
-
-              <!-- SNS 계정 -->
-              <v-col cols="12">
-                <v-text-field
-                  v-model="formData.instagramUrl"
-                  label="인스타그램 계정"
-                  prepend-inner-icon="mdi-instagram"
                   variant="outlined"
-                  placeholder="예) @your_instagram"
+                  density="compact"
                 />
               </v-col>
-
+              
               <v-col cols="12">
                 <v-text-field
                   v-model="formData.blogUrl"
-                  label="네이버 블로그"
-                  prepend-inner-icon="mdi-post"
+                  label="블로그 URL"
                   variant="outlined"
-                  placeholder="예) blog.naver.com/your_blog"
+                  density="compact"
+                />
+              </v-col>
+              
+              <v-col cols="12">
+                <v-textarea
+                  v-model="formData.description"
+                  label="매장 소개"
+                  variant="outlined"
+                  density="compact"
+                  rows="3"
                 />
               </v-col>
             </v-row>
           </v-form>
         </v-card-text>
         
-        <v-divider />
-        
         <v-card-actions class="pa-4">
           <v-spacer />
           <v-btn
-            color="grey"
-            variant="outlined"
-            @click="cancelForm"
-            :disabled="saving"
+            variant="text"
+            @click="showCreateDialog = false"
           >
             취소
           </v-btn>
           <v-btn
             color="primary"
-            @click="saveStoreInfo"
+            @click="saveStore"
             :loading="saving"
             :disabled="!formValid"
           >
@@ -522,226 +507,104 @@
         </v-card-actions>
       </v-card>
     </v-dialog>
-    <!-- 누락된 다이얼로그들을 매장 등록 다이얼로그 뒤에 추가해주세요 -->
 
-    <!-- 메뉴 상세 다이얼로그 -->
-    <v-dialog
-      v-model="showMenuDetailDialog"
-      max-width="600"
+    <!-- 메뉴 등록/수정 다이얼로그 -->
+    <v-dialog 
+      v-model="showMenuDialog" 
+      max-width="600" 
       persistent
+      :style="{ zIndex: 2000 }"
+      class="menu-dialog"
     >
-      <v-card v-if="selectedMenu">
-        <v-card-title class="pa-4">
-          <div class="d-flex align-center justify-space-between w-100">
-            <div class="d-flex align-center">
-              <v-icon class="mr-2" color="primary">mdi-food</v-icon>
-              메뉴 상세 정보
-            </div>
-            <div class="d-flex align-center">
-              <!-- 상태 배지 -->
-              <v-chip
-                :color="selectedMenu.available ? 'success' : 'error'"
-                size="small"
-                variant="elevated"
-                class="mr-2"
-              >
-                {{ selectedMenu.available ? '판매중' : '품절' }}
-              </v-chip>
-              
-              <!-- 추천 메뉴 배지 -->
-              <v-chip
-                v-if="selectedMenu.recommended"
-                color="warning"
-                size="small"
-                variant="elevated"
-              >
-                <v-icon size="small" class="mr-1">mdi-star</v-icon>
-                추천
-              </v-chip>
-            </div>
-          </div>
-        </v-card-title>
-        
-        <v-divider />
-        
-        <v-card-text class="pa-0">
-          <!-- 메뉴 이미지 -->
-          <v-img
-            :src="selectedMenu.imageUrl || selectedMenu.image || '/images/menu-placeholder.png'"
-            :alt="selectedMenu.menuName"
-            height="300"
-            cover
-            class="mb-4"
-          >
-            <template v-slot:placeholder>
-              <div class="d-flex align-center justify-center fill-height">
-                <v-icon size="64" color="grey-lighten-2">mdi-food</v-icon>
-              </div>
-            </template>
-          </v-img>
-          
-          <div class="pa-4">
-            <!-- 메뉴 기본 정보 -->
-            <div class="mb-4">
-              <div class="d-flex align-center justify-space-between mb-2">
-                <h2 class="text-h5 font-weight-bold">{{ selectedMenu.menuName }}</h2>
-                <span class="text-h4 font-weight-bold text-primary">
-                  {{ formatCurrency(selectedMenu.price) }}
-                </span>
-              </div>
-              
-              <v-chip
-                :color="getCategoryColor(selectedMenu.category)"
-                size="small"
-                variant="tonal"
-                class="mb-3"
-              >
-                {{ selectedMenu.category }}
-              </v-chip>
-              
-              <p class="text-body-1 text-grey-darken-1 mb-0">
-                {{ selectedMenu.description || '메뉴 설명이 없습니다.' }}
-              </p>
-            </div>
-            
-            <!-- 메뉴 상세 정보 -->
-            <v-divider class="my-4" />
-            
-            <div class="mb-4">
-              <h4 class="text-h6 font-weight-bold mb-3 d-flex align-center">
-                <v-icon class="mr-2" color="primary">mdi-information</v-icon>
-                상세 정보
-              </h4>
-              
-              <v-row>
-                <v-col cols="6">
-                  <div class="info-item">
-                    <v-icon class="mr-2" color="grey">mdi-tag</v-icon>
-                    <div>
-                      <div class="text-caption text-grey">카테고리</div>
-                      <div class="text-body-1">{{ selectedMenu.category }}</div>
-                    </div>
-                  </div>
-                </v-col>
-                
-                <v-col cols="6">
-                  <div class="info-item">
-                    <v-icon class="mr-2" color="grey">mdi-currency-krw</v-icon>
-                    <div>
-                      <div class="text-caption text-grey">가격</div>
-                      <div class="text-body-1">{{ formatCurrency(selectedMenu.price) }}</div>
-                    </div>
-                  </div>
-                </v-col>
-              </v-row>
-            </div>
-          </div>
-        </v-card-text>
-        
-        <v-divider />
-        
-        <v-card-actions class="pa-4">
-          <v-spacer />
-          <v-btn
-            color="grey"
-            variant="outlined"
-            @click="closeMenuDetail"
-          >
-            닫기
-          </v-btn>
-          <v-btn
-            color="primary"
-            variant="outlined"
-            prepend-icon="mdi-pencil"
-            @click="editMenuFromDetail"
-            :disabled="!selectedMenu"
-          >
-            수정
-          </v-btn>
-          <v-btn
-            color="error"
-            variant="outlined"
-            prepend-icon="mdi-delete"
-            @click="deleteMenuFromDetail"
-            :disabled="!selectedMenu"
-          >
-            삭제
-          </v-btn>
-        </v-card-actions>
-      </v-card>
-    </v-dialog>
-
-    <!-- 메뉴 등록/수정 다이얼로그 (✅ 이미지 업로드 기능 추가) -->
-    <v-dialog
-      v-model="showMenuDialog"
-      max-width="700"
-      persistent
-    >
-      <v-card>
+      <v-card class="menu-dialog-card">
         <v-card-title class="pa-4">
           <div class="d-flex align-center">
-            <v-icon class="mr-2" color="primary">mdi-food-plus</v-icon>
-            {{ menuEditMode ? '메뉴 수정' : '메뉴 등록' }}
+            <v-icon class="mr-2" color="primary">mdi-food</v-icon>
+            {{ menuEditMode ? '메뉴 수정' : '새 메뉴 등록' }}
           </div>
         </v-card-title>
         
         <v-divider />
         
-        <v-card-text class="pa-4">
-          <v-form ref="menuFormRef" v-model="formValid">
+        <!-- ✅ 스크롤 가능한 컨텐츠 영역 -->
+        <v-card-text class="pa-4 dialog-content">
+          <v-form ref="menuFormRef" v-model="menuFormValid">
             <v-row>
-              <!-- ✅ 메뉴 이미지 업로드 섹션 추가 -->
+              <!-- 메뉴 이미지 업로드 -->
               <v-col cols="12">
-                <div class="image-upload-section">
+                <div class="mb-4">
                   <h4 class="text-subtitle-1 font-weight-bold mb-3 d-flex align-center">
                     <v-icon class="mr-2" color="primary">mdi-image</v-icon>
-                    메뉴 이미지
+                    메뉴 이미지 {{ !menuEditMode ? '*' : '' }}
                   </h4>
                   
                   <!-- 이미지 미리보기 -->
-                  <div v-if="menuFormData.imagePreview" class="mb-3">
+                  <div v-if="shouldShowImagePreview" class="mb-3">
                     <v-img
-                      :src="menuFormData.imagePreview"
-                      max-height="200"
-                      max-width="300"
+                      :src="shouldShowImagePreview"
+                      max-height="180"
+                      max-width="280"
                       class="rounded mx-auto"
+                      style="border: 2px solid #e0e0e0;"
                     />
                     <div class="text-center mt-2">
+                      <v-chip 
+                        v-if="previewImageUrl" 
+                        color="success" 
+                        size="small" 
+                        class="mr-2"
+                      >
+                        새 이미지 선택됨
+                      </v-chip>
+                      <v-chip 
+                        v-else-if="menuEditMode" 
+                        color="info" 
+                        size="small" 
+                        class="mr-2"
+                      >
+                        현재 이미지
+                      </v-chip>
                       <v-btn
                         size="small"
-                        color="error"
+                        color="primary"
                         variant="outlined"
-                        prepend-icon="mdi-delete"
-                        @click="removeImage"
+                        prepend-icon="mdi-image-edit"
+                        @click="resetImageSelection"
                       >
-                        이미지 제거
+                        다른 이미지 선택
                       </v-btn>
                     </div>
                   </div>
                   
-                  <!-- 이미지 업로드 영역 -->
+                  <!-- 이미지 선택 섹션 -->
                   <div v-else>
                     <v-file-input
-                      v-model="menuFormData.imageFile"
-                      label="메뉴 이미지 선택"
-                      variant="outlined"
-                      prepend-icon="mdi-camera"
+                      v-model="selectedImageFile"
+                      label="메뉴 이미지 선택 *"
                       accept="image/*"
+                      prepend-icon="mdi-camera"
+                      variant="outlined"
+                      density="compact"
+                      :rules="[
+                        v => menuEditMode || !!v || '메뉴 이미지는 필수입니다',
+                        v => !v || v.size < 10485760 || '파일 크기는 10MB 이하여야 합니다',
+                        v => !v || v.type.startsWith('image/') || '이미지 파일만 업로드 가능합니다'
+                      ]"
+                      @update:modelValue="onFileInputChange"
                       show-size
-                      @change="onImageSelected"
-                      :rules="imageRules"
-                      class="mb-3"
+                      required
                     />
                     
-                    <!-- 드래그앤드롭 영역 -->
+                    <!-- 드래그앤드롭 영역 - 높이 축소 -->
                     <div
-                      class="drop-zone"
-                      @drop="onDrop"
+                      class="drop-zone pa-3 text-center"
+                      style="border: 2px dashed #ccc; border-radius: 8px; background: #fafafa; min-height: 80px;"
+                      @drop="onDropImage"
                       @dragover.prevent
                       @dragenter.prevent
                     >
-                      <v-icon size="48" color="grey-lighten-2">mdi-cloud-upload</v-icon>
-                      <p class="text-grey text-center mt-2 mb-1">
+                      <v-icon size="32" color="grey-lighten-2">mdi-cloud-upload</v-icon>
+                      <p class="text-grey text-center mt-1 mb-1 text-caption">
                         이미지를 드래그하여 업로드하거나 위의 버튼을 클릭하세요
                       </p>
                       <p class="text-caption text-grey text-center">
@@ -751,100 +614,156 @@
                   </div>
                 </div>
               </v-col>
-
-              <!-- 기존 메뉴 정보 필드들 -->
+              
               <v-col cols="12">
                 <v-text-field
                   v-model="menuFormData.menuName"
                   label="메뉴명 *"
                   :rules="[v => !!v || '메뉴명을 입력해주세요']"
-                  prepend-inner-icon="mdi-food"
                   variant="outlined"
+                  density="compact"
+                  required
                 />
               </v-col>
-
+              
               <v-col cols="12" sm="6">
                 <v-select
                   v-model="menuFormData.category"
-                  label="카테고리 *"
                   :items="menuCategories"
+                  label="카테고리 *"
                   :rules="[v => !!v || '카테고리를 선택해주세요']"
-                  prepend-inner-icon="mdi-tag"
                   variant="outlined"
+                  density="compact"
+                  required
                 />
               </v-col>
-
+              
               <v-col cols="12" sm="6">
                 <v-text-field
                   v-model.number="menuFormData.price"
-                  label="가격 *"
+                  label="가격 (원) *"
                   type="number"
-                  :rules="[v => !!v || '가격을 입력해주세요', v => v > 0 || '가격은 0원보다 커야 합니다']"
-                  prepend-inner-icon="mdi-currency-krw"
+                  :rules="[
+                    v => !!v || '가격을 입력해주세요',
+                    v => v > 0 || '가격은 0보다 커야 합니다'
+                  ]"
                   variant="outlined"
-                  :min="0"
+                  density="compact"
+                  required
                 />
               </v-col>
-
+              
               <v-col cols="12">
                 <v-textarea
                   v-model="menuFormData.description"
                   label="메뉴 설명"
-                  prepend-inner-icon="mdi-text"
                   variant="outlined"
-                  rows="3"
-                  :rules="[v => !v || v.length <= 500 || '설명은 500자 이하로 입력해주세요']"
+                  density="compact"
+                  rows="2"
                 />
               </v-col>
-
-              <!-- 메뉴 옵션 -->
-              <v-col cols="12">
-                <v-row>
-                  <v-col cols="6">
-                    <v-switch
-                      v-model="menuFormData.available"
-                      label="판매 중"
-                      color="success"
-                      hide-details
-                    />
-                  </v-col>
-                  <v-col cols="6">
-                    <v-switch
-                      v-model="menuFormData.recommended"
-                      label="추천 메뉴"
-                      color="warning"
-                      hide-details
-                    />
-                  </v-col>
-                </v-row>
+              
+              <v-col cols="12" sm="6">
+                <v-switch
+                  v-model="menuFormData.available"
+                  label="판매 가능"
+                  color="primary"
+                  density="compact"
+                />
+              </v-col>
+              
+              <v-col cols="12" sm="6">
+                <v-switch
+                  v-model="menuFormData.recommended"
+                  label="추천 메뉴"
+                  color="orange"
+                  density="compact"
+                />
               </v-col>
             </v-row>
           </v-form>
         </v-card-text>
         
-        <v-divider />
-        
         <v-card-actions class="pa-4">
           <v-spacer />
           <v-btn
-            color="grey"
-            variant="outlined"
+            variant="text"
             @click="cancelMenuForm"
-            :disabled="saving"
           >
             취소
           </v-btn>
           <v-btn
             color="primary"
-            @click="saveMenuWithImage"
+            @click="saveMenu"
             :loading="saving"
-            :disabled="!formValid"
+            :disabled="!menuFormValid"
           >
             {{ menuEditMode ? '수정' : '등록' }}
           </v-btn>
         </v-card-actions>
       </v-card>
     </v-dialog>
+    <!-- 메뉴 상세 다이얼로그 -->
+    <v-dialog v-model="showMenuDetailDialog" max-width="500">
+      <v-card v-if="selectedMenu">
+        <v-img
+          :src="getMenuImageUrl(selectedMenu)"
+          height="250"
+          cover
+          @error="handleImageError($event, selectedMenu)"
+        />
+        
+        <v-card-title class="pa-4 d-flex justify-space-between align-center">
+          <span>{{ selectedMenu.menuName || selectedMenu.name }}</span>
+          <v-chip
+            :color="selectedMenu.available ? 'green' : 'red'"
+            size="small"
+          >
+            {{ selectedMenu.available ? '판매중' : '품절' }}
+          </v-chip>
+        </v-card-title>
+        
+        <v-card-text class="pa-4">
+          <div class="mb-3">
+            <div class="text-caption text-grey">카테고리</div>
+            <div class="text-body-1">{{ selectedMenu.category }}</div>
+          </div>
+          
+          <div class="mb-3">
+            <div class="text-caption text-grey">가격</div>
+            <div class="text-h6 text-primary font-weight-bold">
+              {{ selectedMenu.price ? selectedMenu.price.toLocaleString() : '0' }}원
+            </div>
+          </div>
+          
+          <div class="mb-3">
+            <div class="text-caption text-grey">설명</div>
+            <div class="text-body-1">{{ selectedMenu.description || '설명이 없습니다' }}</div>
+          </div>
+          
+          <div v-if="selectedMenu.recommended" class="mb-3">
+            <v-chip color="orange" size="small">추천 메뉴</v-chip>
+          </div>
+        </v-card-text>
+        
+        <v-card-actions class="pa-4">
+          <v-spacer />
+          <v-btn
+            variant="text"
+            @click="closeMenuDetail"
+          >
+            닫기
+          </v-btn>
+          <v-btn
+            color="primary"
+            variant="text"
+            @click="editMenu(selectedMenu); closeMenuDetail()"
+          >
+            수정
+          </v-btn>
+        </v-card-actions>
+      </v-card>
+    </v-dialog>
 
     <!-- 스낵바 -->
     <v-snackbar
@@ -859,7 +778,7 @@
 </template>
 
 <script setup>
-import { ref, computed, onMounted } from 'vue'
+import { ref, computed, onMounted, watch } from 'vue'
 import { useStoreStore } from '@/store/index'
 
 const storeStore = useStoreStore()
@@ -880,26 +799,28 @@ const menuCategories = ref(['커피', '음료', '디저트', '베이커리', '
 const showMenuDialog = ref(false)
 const menuEditMode = ref(false)
 const menuFormRef = ref(null)
+const menuFormValid = ref(false)
 
-// ✅ 이미지 업로드 기능이 포함된 메뉴 폼 데이터
+// 이미지 관련 상태
+const selectedImageFile = ref(null)
+const previewImageUrl = ref('')
+
+// 메뉴 폼 데이터
 const menuFormData = ref({
-  menuId: null,
-  id: null,
   menuName: '',
   category: '',
   price: 0,
   description: '',
   available: true,
   recommended: false,
-  imageUrl: '',
-  imageFile: null, // ✅ 새 이미지 파일
-  imagePreview: null // ✅ 이미지 미리보기 URL
+  imageUrl: ''
 })
 
 // 메뉴 상세 관련 상태
 const showMenuDetailDialog = ref(false)
 const selectedMenu = ref(null)
 
+// 스낵바 상태
 const snackbar = ref({
   show: false,
   message: '',
@@ -936,21 +857,6 @@ const weekDays = [
   { title: '일요일', value: 'sunday' }
 ]
 
-// ✅ 이미지 업로드 관련 검증 규칙
-const imageRules = ref([
-  value => {
-    if (!value || !value.length) return true // 이미지는 선택사항
-    const file = Array.isArray(value) ? value[0] : value
-    if (file.size > 10 * 1024 * 1024) {
-      return '이미지 크기는 10MB 이하여야 합니다'
-    }
-    if (!file.type.startsWith('image/')) {
-      return '이미지 파일만 업로드 가능합니다'
-    }
-    return true
-  }
-])
-
 // 컴퓨티드 속성
 const storeInfo = computed(() => storeStore.storeInfo || {})
 
@@ -962,8 +868,8 @@ const filteredMenus = computed(() => {
   if (menuSearch.value) {
     const search = menuSearch.value.toLowerCase()
     filtered = filtered.filter(menu => 
-      menu.menuName.toLowerCase().includes(search) ||
-      menu.description.toLowerCase().includes(search)
+      (menu.menuName || '').toLowerCase().includes(search) ||
+      (menu.description || '').toLowerCase().includes(search)
     )
   }
 
@@ -975,7 +881,99 @@ const filteredMenus = computed(() => {
   return filtered
 })
 
-// 유틸리티 함수들
+// 이미지 미리보기 표시 조건 (computed)
+const shouldShowImagePreview = computed(() => {
+  // 1순위: 새로 선택한 이미지 미리보기
+  if (previewImageUrl.value) {
+    return previewImageUrl.value
+  }
+  
+  // 2순위: 수정 모드일 때 기존 이미지
+  if (menuEditMode.value && menuFormData.value.imageUrl) {
+    return menuFormData.value.imageUrl
+  }
+  
+  return null
+})
+
+// ===== 유틸리티 함수들 =====
+
+/**
+ * 메뉴 이미지 URL 처리 함수
+ * Azure Blob Storage URL과 플레이스홀더 구분
+ */
+const getMenuImageUrl = (menu) => {
+  if (!menu) return '/images/menu-placeholder.png'
+  
+  console.log('=== 메뉴 이미지 URL 처리 ===')
+  console.log('메뉴 데이터:', menu)
+  console.log('이미지 필드들:', {
+    image: menu.image,
+    imageUrl: menu.imageUrl,
+    menuImageUrl: menu.menuImageUrl
+  })
+  
+  // 1순위: Azure Blob Storage URL (https로 시작하는 실제 URL)
+  const imageUrl = menu.image || menu.imageUrl || menu.menuImageUrl
+  
+  if (imageUrl && imageUrl.startsWith('https://')) {
+    console.log('✅ Azure Blob Storage URL 사용:', imageUrl)
+    return imageUrl
+  }
+  
+  // 2순위: 상대 경로 이미지가 있다면 절대 경로로 변환
+  if (imageUrl && imageUrl.startsWith('/images/')) {
+    console.log('⚠️ 상대 경로 이미지, 절대 경로로 변환:', imageUrl)
+    return imageUrl
+  }
+  
+  // 3순위: 기본 플레이스홀더
+  console.log('❌ 이미지 URL 없음, 플레이스홀더 사용')
+  return '/images/menu-placeholder.png'
+}
+
+/**
+ * 이미지 로딩 오류 처리
+ */
+const handleImageError = (event, menu) => {
+  console.log('이미지 로딩 실패:', menu?.menuName || 'Unknown', event)
+  // 이미지 로딩 실패 시 플레이스홀더로 변경
+  if (event.target) {
+    event.target.src = '/images/menu-placeholder.png'
+  }
+}
+
+/**
+ * 플레이스홀더 이미지 존재 여부 확인
+ */
+const checkPlaceholderImage = async () => {
+  try {
+    const response = await fetch('/images/menu-placeholder.png')
+    if (!response.ok) {
+      console.warn('⚠️ 플레이스홀더 이미지가 없습니다:', '/images/menu-placeholder.png')
+      showSnackbar('기본 이미지 파일이 없습니다. public/images 폴더를 확인해주세요', 'warning')
+    } else {
+      console.log('✅ 플레이스홀더 이미지 확인됨')
+    }
+  } catch (error) {
+    console.warn('플레이스홀더 이미지 확인 실패:', error)
+  }
+}
+
+/**
+ * 개발용 이미지 확인 함수
+ */
+const checkMenuImages = () => {
+  console.log('=== 현재 메뉴 이미지 상태 확인 ===')
+  menus.value.forEach((menu, index) => {
+    console.log(`메뉴 ${index + 1}: ${menu.menuName}`)
+    console.log('  - image:', menu.image)
+    console.log('  - imageUrl:', menu.imageUrl)
+    console.log('  - 최종 URL:', getMenuImageUrl(menu))
+    console.log('  - Azure URL 여부:', getMenuImageUrl(menu).startsWith('https://'))
+  })
+}
+
 const formatClosedDays = (closedDays) => {
   if (!closedDays) return '미설정'
   
@@ -1006,78 +1004,237 @@ const showSnackbar = (message, color = 'success') => {
   snackbar.value.show = true
 }
 
-const formatCurrency = (amount) => {
-  return new Intl.NumberFormat('ko-KR', {
-    style: 'currency',
-    currency: 'KRW'
-  }).format(amount)
-}
+// ===== 이미지 관련 함수들 =====
 
-const getCategoryColor = (category) => {
-  const colors = {
-    '커피': 'brown',
-    '음료': 'blue',
-    '디저트': 'pink',
-    '베이커리': 'orange',
-    '샐러드': 'green',
-    '샌드위치': 'purple'
-  }
-  return colors[category] || 'grey'
-}
-
-// ===== 이미지 관련 메서드들 =====
-
-// ✅ 이미지 파일 선택 시 처리
-const onImageSelected = (files) => {
-  console.log('이미지 파일 선택:', files)
+// watch 추가 - selectedImageFile 변경 감지
+watch(selectedImageFile, (newFile, oldFile) => {
+  console.log('selectedImageFile 변경 감지:', newFile)
   
-  if (!files || !files.length) {
-    menuFormData.value.imageFile = null
-    menuFormData.value.imagePreview = null
+  // 실제로 다른 파일로 변경되었을 때만 로그 출력
+  if (newFile && newFile !== oldFile) {
+    console.log('새 파일 설정됨:', newFile.name)
+  }
+}, { immediate: false })
+
+// v-file-input의 modelValue 변경 감지 함수
+const onFileInputChange = (file) => {
+  console.log('=== v-file-input v-model 변경 감지 ===')
+  console.log('전달받은 file:', file)
+  
+  if (file) {
+    // selectedImageFile에 할당
+    selectedImageFile.value = file
+    onImageFileSelected(file)
+  } else {
+    selectedImageFile.value = null
+    previewImageUrl.value = ''
+  }
+}
+
+// 이미지 파일 선택 처리 함수
+const onImageFileSelected = (file) => {
+  console.log('=== 이미지 파일 선택 처리 ===')
+  console.log('선택된 파일:', file)
+  
+  if (!file) {
+    console.log('파일이 선택되지 않음')
+    selectedImageFile.value = null
+    previewImageUrl.value = ''
     return
   }
   
-  const file = Array.isArray(files) ? files[0] : files
+  console.log('파일 크기:', file.size, '바이트')
+  console.log('파일 타입:', file.type)
   
-  // 파일 크기 및 타입 검증
-  if (file.size > 10 * 1024 * 1024) {
-    showSnackbar('이미지 크기는 10MB 이하여야 합니다', 'error')
+  // 파일 크기 체크 (10MB)
+  if (file.size > 10485760) {
+    showSnackbar('파일 크기는 10MB 이하여야 합니다', 'error')
+    selectedImageFile.value = null
+    previewImageUrl.value = ''
     return
   }
   
+  // 이미지 파일 형식 체크
   if (!file.type.startsWith('image/')) {
     showSnackbar('이미지 파일만 업로드 가능합니다', 'error')
+    selectedImageFile.value = null
+    previewImageUrl.value = ''
     return
   }
   
-  menuFormData.value.imageFile = file
-  
-  // 이미지 미리보기 생성
+  // 미리보기 URL 생성
   const reader = new FileReader()
   reader.onload = (e) => {
-    menuFormData.value.imagePreview = e.target.result
+    previewImageUrl.value = e.target.result
+    console.log('✅ 이미지 미리보기 생성 완료')
   }
   reader.readAsDataURL(file)
 }
 
-// ✅ 드래그앤드롭 처리
-const onDrop = (event) => {
-  event.preventDefault()
+// ✅ StoreManagementView.vue의 uploadMenuImage 함수 직접 수정
+
+// 이미지 업로드 함수 - 직접 axios 인스턴스 생성
+const uploadMenuImage = async (menuId) => {
+  if (!selectedImageFile.value) {
+    console.log('업로드할 이미지 파일이 없음')
+    return null
+  }
   
-  const files = event.dataTransfer.files
-  if (files.length > 0) {
-    onImageSelected([files[0]])
+  try {
+    console.log('=== 메뉴 이미지 업로드 시작 ===')
+    console.log('메뉴 ID:', menuId)
+    console.log('이미지 파일:', selectedImageFile.value)
+    
+    const formData = new FormData()
+    formData.append('file', selectedImageFile.value)
+    
+    // ✅ 직접 axios 인스턴스 생성 (import 문제 회피)
+    const axios = (await import('axios')).default
+    
+    // ✅ 이미지 전용 API 인스턴스 생성
+    const imageApiInstance = axios.create({
+      baseURL: 'http://localhost:8082', // 포트만 지정
+      timeout: 30000,
+      headers: {
+        'Content-Type': 'multipart/form-data'
+      }
+    })
+    
+    // JWT 토큰 추가
+    const token = localStorage.getItem('accessToken')
+    if (token) {
+      imageApiInstance.defaults.headers.Authorization = `Bearer ${token}`
+    }
+    
+    console.log('🎯 ImageController로 업로드: /api/images/menu/' + menuId)
+    
+    // ✅ 올바른 전체 경로 지정
+    const response = await imageApiInstance.post(`/api/images/menu/${menuId}`, formData)
+    
+    console.log('이미지 업로드 응답:', response.data)
+    
+    // ✅ 응답 데이터 구조 확인 및 URL 추출
+    let imageUrl = null
+    
+    if (response.data) {
+      // MenuResponse 구조에서 이미지 URL 추출
+      if (response.data.image) {
+        imageUrl = response.data.image
+      } else if (response.data.imageUrl) {
+        imageUrl = response.data.imageUrl  
+      } else if (response.data.data && response.data.data.image) {
+        imageUrl = response.data.data.image
+      }
+    }
+    
+    if (imageUrl && imageUrl.startsWith('https://')) {
+      console.log('✅ 이미지 업로드 성공!')
+      console.log('🔗 Azure Blob Storage URL:', imageUrl)
+      return imageUrl
+    } else {
+      console.warn('⚠️ 응답에서 유효한 이미지 URL을 찾을 수 없음:', response.data)
+      return null
+    }
+    
+  } catch (error) {
+    console.error('❌ 이미지 업로드 실패:', error)
+    console.error('에러 상세:', error.response?.data)
+    
+    // 구체적인 에러 메시지 제공
+    if (error.response?.status === 500) {
+      console.error('서버 내부 오류 - ImageController 처리 로직 확인 필요')
+      showSnackbar('서버에서 이미지 처리 중 오류가 발생했습니다', 'error')
+    } else if (error.response?.status === 404) {
+      console.error('ImageController API 경로를 찾을 수 없음')
+      showSnackbar('이미지 업로드 API를 찾을 수 없습니다', 'error')
+    } else if (error.response?.status === 413) {
+      console.error('파일 크기 초과')
+      showSnackbar('파일 크기가 너무 큽니다', 'error')
+    } else {
+      showSnackbar('이미지 업로드에 실패했습니다', 'error')
+    }
+    
+    return null
   }
 }
 
-// ✅ 이미지 제거
-const removeImage = () => {
-  menuFormData.value.imageFile = null
-  menuFormData.value.imagePreview = null
-  menuFormData.value.imageUrl = ''
+// 이미지 선택 초기화 함수
+const resetImageSelection = () => {
+  console.log('이미지 선택 초기화')
+  selectedImageFile.value = null
+  previewImageUrl.value = ''
+  
+  // v-file-input도 초기화하기 위해 DOM 조작 추가
+  const fileInput = document.querySelector('input[type="file"]')
+  if (fileInput) {
+    fileInput.value = ''
+  }
 }
 
-// ===== 매장 관련 메서드들 =====
+// 드래그앤드롭 처리
+const onDropImage = (event) => {
+  event.preventDefault()
+  console.log('이미지 드롭 이벤트')
+  
+  const files = event.dataTransfer.files
+  if (files.length > 0) {
+    const file = files[0]
+    selectedImageFile.value = file
+    onImageFileSelected(file)
+  }
+}
+
+// ===== 폼 관련 함수들 =====
+
+// 폼 리셋 함수
+const resetForm = () => {
+  formData.value = {
+    storeName: '',
+    businessType: '',
+    address: '',
+    phoneNumber: '',
+    seatCount: 0,
+    instagramUrl: '',
+    blogUrl: '',
+    openTime: '09:00',
+    closeTime: '21:00',
+    holidays: [],
+    description: ''
+  }
+  if (storeFormRef.value) {
+    storeFormRef.value.resetValidation()
+  }
+}
+
+// 메뉴 폼 리셋 함수
+const resetMenuForm = () => {
+  console.log('=== 메뉴 폼 리셋 ===')
+  
+  menuFormData.value = {
+    menuId: null,
+    id: null,
+    menuName: '',
+    category: '',
+    price: 0,
+    description: '',
+    available: true,
+    recommended: false,
+    imageUrl: ''
+  }
+  
+  // 이미지 관련 상태 초기화
+  selectedImageFile.value = null
+  previewImageUrl.value = ''
+  
+  if (menuFormRef.value) {
+    menuFormRef.value.resetValidation()
+  }
+  
+  console.log('✅ 메뉴 폼 리셋 완료')
+}
+
+// ===== 다이얼로그 관련 함수들 =====
+
 const openCreateDialog = () => {
   console.log('새 매장 등록 다이얼로그 열기')
   editMode.value = false
@@ -1108,48 +1265,122 @@ const editBasicInfo = () => {
   showCreateDialog.value = true
 }
 
-const cancelForm = () => {
-  console.log('폼 취소')
-  showCreateDialog.value = false
-  editMode.value = false
-  resetForm()
+// 메뉴 관련 메서드들
+const openCreateMenuDialog = () => {
+  console.log('메뉴 등록 다이얼로그 열기')
+  menuEditMode.value = false
+  resetMenuForm()
+  showMenuDialog.value = true
 }
 
-const resetForm = () => {
-  formData.value = {
-    storeName: '',
-    businessType: '',
-    address: '',
-    phoneNumber: '',
-    seatCount: 0,
-    instagramUrl: '',
-    blogUrl: '',
-    openTime: '09:00',
-    closeTime: '21:00',
-    holidays: [],
-    description: ''
+// 메뉴 수정 함수
+const editMenu = (menu) => {
+  console.log('=== 메뉴 수정 호출 ===')
+  console.log('전달받은 메뉴 객체:', menu)
+  
+  if (!menu || menu === null || menu === undefined) {
+    console.error('❌ 전달받은 메뉴 객체가 null 또는 undefined입니다')
+    showSnackbar('메뉴 정보를 찾을 수 없습니다', 'error')
+    return
   }
   
-  if (storeFormRef.value) {
-    storeFormRef.value.resetValidation()
+  const menuId = menu.menuId || menu.id
+  console.log('추출된 메뉴 ID:', menuId, '타입:', typeof menuId)
+  
+  if (!menuId || menuId === 'undefined' || menuId === null || menuId === '') {
+    console.error('❌ 메뉴 ID를 찾을 수 없음:', menu)
+    showSnackbar('메뉴 ID를 찾을 수 없습니다', 'error')
+    return
+  }
+  
+  console.log('✅ 사용할 메뉴 ID:', menuId)
+  menuEditMode.value = true
+  
+  // 메뉴 폼 데이터 설정
+  menuFormData.value = {
+    menuId: menuId,
+    id: menuId,
+    menuName: menu.menuName || menu.name || '',
+    category: menu.category || '',
+    price: menu.price || 0,
+    description: menu.description || '',
+    available: menu.available !== undefined ? menu.available : true,
+    recommended: menu.recommended !== undefined ? menu.recommended : false,
+    imageUrl: menu.image || menu.imageUrl || ''
+  }
+  
+  // 이미지 상태 초기화
+  selectedImageFile.value = null
+  previewImageUrl.value = ''
+  
+  console.log('✅ 메뉴 수정 폼 데이터 설정 완료:', menuFormData.value)
+  showMenuDialog.value = true
+}
+
+// 메뉴 상세 보기
+const viewMenuDetail = (menu) => {
+  console.log('=== 메뉴 상세 보기 호출 ===')
+  console.log('전달받은 메뉴 객체:', menu)
+  
+  const menuId = menu.menuId || menu.id
+  
+  if (!menuId) {
+    console.error('❌ 메뉴 ID를 찾을 수 없음:', menu)
+    showSnackbar('메뉴 정보가 올바르지 않습니다', 'error')
+    return
+  }
+  
+  console.log('✅ 사용할 메뉴 ID:', menuId)
+  
+  selectedMenu.value = {
+    ...menu,
+    id: menuId,
+    menuId: menuId,
+    name: menu.menuName || menu.name,
+    menuName: menu.menuName || menu.name,
+    imageUrl: menu.image || menu.imageUrl || '/images/menu-placeholder.png'
+  }
+  
+  console.log('✅ 메뉴 상세 정보 설정 완료:', selectedMenu.value)
+  showMenuDetailDialog.value = true
+}
+
+const closeMenuDetail = () => {
+  showMenuDetailDialog.value = false
+  selectedMenu.value = null
+}
+
+const confirmDeleteMenu = (menu) => {
+  console.log('메뉴 삭제 확인:', menu)
+  if (confirm(`'${menu.menuName}' 메뉴를 삭제하시겠습니까?`)) {
+    deleteMenu(menu.id || menu.menuId)
   }
 }
 
+const clearFilters = () => {
+  menuSearch.value = ''
+  menuCategoryFilter.value = '전체'
+}
+
+// 메뉴 폼 취소
+const cancelMenuForm = () => {
+  console.log('메뉴 폼 취소')
+  showMenuDialog.value = false
+  menuEditMode.value = false
+  resetMenuForm()
+}
+
+// ===== 저장 관련 함수들 =====
+
 // 매장 정보 저장 함수
-const saveStoreInfo = async () => {
-  console.log('=== 매장 정보 저장 시작 ===')
-  console.log('편집 모드:', editMode.value)
-  console.log('폼 데이터:', formData.value)
-  
+const saveStore = async () => {
   if (!storeFormRef.value) {
-    console.error('폼 참조를 찾을 수 없습니다')
     showSnackbar('폼 오류가 발생했습니다', 'error')
     return
   }
   
   const { valid } = await storeFormRef.value.validate()
   if (!valid) {
-    console.log('폼 유효성 검사 실패')
     showSnackbar('필수 정보를 모두 입력해주세요', 'error')
     return
   }
@@ -1157,13 +1388,18 @@ const saveStoreInfo = async () => {
   saving.value = true
   
   try {
+    console.log('매장 정보 저장 시작')
+    
+    // 백엔드 형식에 맞는 데이터 구조로 변환
     const storeData = {
       storeName: formData.value.storeName,
       businessType: formData.value.businessType,
       address: formData.value.address,
-      phoneNumber: formData.value.phoneNumber,
-      businessHours: `${formData.value.openTime}-${formData.value.closeTime}`,
-      closedDays: Array.isArray(formData.value.holidays) ? formData.value.holidays.join(',') : '',
+      phoneNumber: formData.value.phoneNumber || '',
+      openTime: formData.value.openTime || '09:00',
+      closeTime: formData.value.closeTime || '21:00',
+      holidays: Array.isArray(formData.value.holidays) ? 
+        formData.value.holidays.join(',') : '',
       seatCount: parseInt(formData.value.seatCount) || 0,
       instaAccounts: formData.value.instagramUrl || '',
       blogAccounts: formData.value.blogUrl || '',
@@ -1201,283 +1437,31 @@ const saveStoreInfo = async () => {
   }
 }
 
-// ===== 메뉴 관련 메서드들 =====
-
-const editMenu = (menu) => {
-  console.log('=== 메뉴 수정 호출 ===')
-  console.log('전달받은 메뉴 객체:', menu)
-  
-  if (!menu || menu === null || menu === undefined) {
-    console.error('❌ 전달받은 메뉴 객체가 null 또는 undefined입니다')
-    showSnackbar('메뉴 정보를 찾을 수 없습니다', 'error')
-    return
-  }
-  
-  const menuId = menu.menuId || menu.id
-  console.log('추출된 메뉴 ID:', menuId, '타입:', typeof menuId)
-  
-  if (!menuId || menuId === 'undefined' || menuId === null || menuId === '') {
-    console.error('❌ 메뉴 ID를 찾을 수 없음:', menu)
-    showSnackbar('메뉴 ID를 찾을 수 없습니다', 'error')
-    return
-  }
-  
-  console.log('✅ 사용할 메뉴 ID:', menuId)
-  menuEditMode.value = true
-  
-  menuFormData.value = {
-    menuId: menuId,
-    id: menuId,
-    menuName: menu.menuName || menu.name || '',
-    category: menu.category || '',
-    price: menu.price || 0,
-    description: menu.description || '',
-    available: menu.available !== undefined ? menu.available : true,
-    recommended: menu.recommended !== undefined ? menu.recommended : false,
-    imageUrl: menu.imageUrl || menu.image || '',
-    imageFile: null, // ✅ 수정 시에는 새 이미지 파일 없음
-    imagePreview: menu.imageUrl || menu.image || null // ✅ 기존 이미지 미리보기
-  }
-  
-  console.log('✅ 수정 폼 데이터 설정 완료:', menuFormData.value)
-  showMenuDialog.value = true
-}
-
-const viewMenuDetail = async (menu) => {
-  console.log('=== 메뉴 상세 보기 호출 ===')
-  console.log('전달받은 메뉴 객체:', menu)
-  
-  if (!menu || menu === null || menu === undefined) {
-    console.error('❌ 전달받은 메뉴 객체가 null 또는 undefined입니다')
-    showSnackbar('메뉴 정보를 찾을 수 없습니다', 'error')
-    return
-  }
-  
-  const menuId = menu.menuId || menu.id
-  
-  if (!menuId || menuId === 'undefined' || menuId === null) {
-    console.error('❌ 메뉴 ID를 찾을 수 없음:', menu)
-    showSnackbar('메뉴 ID를 찾을 수 없습니다', 'error')
-    return
-  }
-  
-  console.log('✅ 사용할 메뉴 ID:', menuId)
-  
-  try {
-    const { menuService } = await import('@/services/menu')
-    
-    console.log('메뉴 상세 API 호출 시작, ID:', menuId)
-    const result = await menuService.getMenuDetail(menuId)
-    
-    if (result.success && result.data) {
-      selectedMenu.value = {
-        ...result.data,
-        id: result.data.menuId || result.data.id,
-        menuId: result.data.menuId || result.data.id
-      }
-      showMenuDetailDialog.value = true
-      console.log('✅ 메뉴 상세 정보 로드 성공:', selectedMenu.value)
-    } else {
-      console.warn('⚠️ 상세 정보 로드 실패, 기본 정보 사용:', result.message)
-      selectedMenu.value = {
-        ...menu,
-        id: menuId,
-        menuId: menuId
-      }
-      showMenuDetailDialog.value = true
-      console.log('기본 메뉴 정보로 설정:', selectedMenu.value)
-    }
-  } catch (error) {
-    console.error('메뉴 상세 정보 로드 실패:', error)
-    selectedMenu.value = {
-      ...menu,
-      id: menuId,
-      menuId: menuId
-    }
-    showMenuDetailDialog.value = true
-    console.log('오류 발생으로 기본 메뉴 정보 사용:', selectedMenu.value)
-  }
-}
-
-const closeMenuDetail = () => {
-  console.log('=== 메뉴 상세 다이얼로그 닫기 ===')
-  showMenuDetailDialog.value = false
-  
-  setTimeout(() => {
-    selectedMenu.value = null
-    console.log('selectedMenu.value가 null로 설정됨')
-  }, 100)
-}
-
-const editMenuFromDetail = () => {
-  console.log('=== 메뉴 상세에서 수정 버튼 클릭 ===')
-  console.log('selectedMenu.value:', selectedMenu.value)
-  
-  if (!selectedMenu.value || selectedMenu.value === null || selectedMenu.value === undefined) {
-    console.error('❌ 선택된 메뉴가 null 또는 undefined입니다')
-    showSnackbar('선택된 메뉴 정보가 없습니다. 다시 시도해주세요.', 'error')
-    showMenuDetailDialog.value = false
-    return
-  }
-  
-  const menuId = selectedMenu.value.menuId || selectedMenu.value.id
-  if (!menuId) {
-    console.error('❌ 선택된 메뉴에 ID가 없습니다:', selectedMenu.value)
-    showSnackbar('메뉴 ID를 찾을 수 없습니다', 'error')
-    return
-  }
-  
-  console.log('✅ 수정할 메뉴 정보:', {
-    id: menuId,
-    name: selectedMenu.value.menuName || selectedMenu.value.name,
-    category: selectedMenu.value.category
-  })
-  
-  closeMenuDetail()
-  editMenu(selectedMenu.value)
-}
-
-const deleteMenuFromDetail = () => {
-  console.log('=== 메뉴 상세에서 삭제 버튼 클릭 ===')
-  console.log('selectedMenu.value:', selectedMenu.value)
-  
-  if (!selectedMenu.value || selectedMenu.value === null || selectedMenu.value === undefined) {
-    console.error('❌ 선택된 메뉴가 null 또는 undefined입니다')
-    showSnackbar('선택된 메뉴 정보가 없습니다. 다시 시도해주세요.', 'error')
-    showMenuDetailDialog.value = false
-    return
-  }
-  
-  const menuId = selectedMenu.value.menuId || selectedMenu.value.id
-  if (!menuId) {
-    console.error('❌ 선택된 메뉴에 ID가 없습니다:', selectedMenu.value)
-    showSnackbar('메뉴 ID를 찾을 수 없습니다', 'error')
-    return
-  }
-  
-  console.log('✅ 삭제할 메뉴 정보:', {
-    id: menuId,
-    name: selectedMenu.value.menuName || selectedMenu.value.name
-  })
-  
-  closeMenuDetail()
-  confirmDeleteMenu(selectedMenu.value)
-}
-
-const editMenuDirect = (menu, event) => {
-  console.log('=== 메뉴 카드에서 직접 수정 ===')
-  
-  if (event) {
-    event.preventDefault()
-    event.stopPropagation()
-  }
-  
-  console.log('직접 수정할 메뉴:', menu)
-  
-  if (!menu || menu === null || menu === undefined) {
-    console.error('❌ 메뉴 객체가 null 또는 undefined입니다')
-    showSnackbar('메뉴 정보를 찾을 수 없습니다', 'error')
-    return
-  }
-  
-  editMenu(menu)
-}
-
-const deleteMenuDirect = (menu, event) => {
-  console.log('=== 메뉴 카드에서 직접 삭제 ===')
-  
-  if (event) {
-    event.preventDefault()
-    event.stopPropagation()
-  }
-  
-  console.log('직접 삭제할 메뉴:', menu)
-  
-  if (!menu || menu === null || menu === undefined) {
-    console.error('❌ 메뉴 객체가 null 또는 undefined입니다')
-    showSnackbar('메뉴 정보를 찾을 수 없습니다', 'error')
-    return
-  }
-  
-  confirmDeleteMenu(menu)
-}
-
-const openCreateMenuDialog = () => {
-  console.log('메뉴 등록 다이얼로그 열기')
-  menuEditMode.value = false
-  resetMenuForm()
-  showMenuDialog.value = true
-}
-
-const confirmDeleteMenu = (menu) => {
-  console.log('=== 메뉴 삭제 확인 ===')
-  console.log('전달받은 메뉴 객체:', menu)
-  
-  const menuId = menu.menuId || menu.id
-  
-  if (!menuId || menuId === 'undefined' || menuId === null) {
-    console.error('❌ 메뉴 ID를 찾을 수 없음:', menu)
-    showSnackbar('메뉴 ID를 찾을 수 없습니다', 'error')
-    return
-  }
-  
-  console.log('✅ 삭제할 메뉴 ID:', menuId)
-  
-  if (confirm(`'${menu.menuName || menu.name}' 메뉴를 삭제하시겠습니까?`)) {
-    deleteMenu(menuId)
-  }
-}
-
-const clearFilters = () => {
-  menuSearch.value = ''
-  menuCategoryFilter.value = '전체'
-}
-
-const cancelMenuForm = () => {
-  console.log('메뉴 폼 취소')
-  showMenuDialog.value = false
-  menuEditMode.value = false
-  resetMenuForm()
-}
-
-// ✅ 메뉴 폼 초기화 (이미지 관련 필드 포함)
-const resetMenuForm = () => {
-  menuFormData.value = {
-    menuId: null,
-    id: null,
-    menuName: '',
-    category: '',
-    price: 0,
-    description: '',
-    available: true,
-    recommended: false,
-    imageUrl: '',
-    imageFile: null, // ✅ 이미지 파일 초기화
-    imagePreview: null // ✅ 미리보기 초기화
-  }
-  
-  if (menuFormRef.value) {
-    menuFormRef.value.resetValidation()
-  }
-}
-
-// ✅ 메뉴 저장 + 이미지 업로드 (2단계 처리)
-const saveMenuWithImage = async () => {
-  console.log('=== 메뉴 저장 + 이미지 업로드 시작 ===')
+// 메뉴 저장 함수
+const saveMenu = async () => {
+  console.log('=== 메뉴 저장 시작 ===')
+  console.log('메뉴 수정 모드:', menuEditMode.value)
+  console.log('폼 데이터:', menuFormData.value)
+  console.log('선택된 이미지 파일:', selectedImageFile.value)
+  console.log('이미지 미리보기:', previewImageUrl.value)
   
   if (!menuFormRef.value) {
-    console.error('❌ 폼 참조를 찾을 수 없음')
     showSnackbar('폼 오류가 발생했습니다', 'error')
     return
   }
   
   const { valid } = await menuFormRef.value.validate()
   if (!valid) {
-    console.log('❌ 폼 유효성 검사 실패')
     showSnackbar('필수 정보를 모두 입력해주세요', 'error')
     return
   }
   
+  // 신규 등록 시 이미지 필수 체크
+  if (!menuEditMode.value && !selectedImageFile.value) {
+    showSnackbar('메뉴 이미지는 필수입니다', 'error')
+    return
+  }
+  
   saving.value = true
   
   try {
@@ -1487,47 +1471,27 @@ const saveMenuWithImage = async () => {
     let savedMenuId
     
     if (menuEditMode.value) {
-  // 메뉴 수정 - PUT /api/menu/{menuId}
-  const menuId = menuFormData.value.id || menuFormData.value.menuId
-  if (!menuId) {
-    showSnackbar('메뉴 ID가 없습니다', 'error')
-    return
-  }
-  
-  console.log('=== 메뉴 수정 데이터 준비 ===')
-  console.log('폼 데이터:', menuFormData.value)
-  console.log('메뉴 ID:', menuId)
-  
-  // 메뉴 데이터 검증 및 준비
-  const menuName = menuFormData.value.menuName || menuFormData.value.name
-  const category = menuFormData.value.category
-  const price = menuFormData.value.price
-  const description = menuFormData.value.description
-  
-  // 프론트엔드에서 기본 검증
-  if (!menuName || !category || price === undefined || price === null) {
-    console.error('❌ 필수 필드 누락:', { menuName, category, price, description })
-    showSnackbar('메뉴명, 카테고리, 가격을 모두 입력해주세요', 'error')
-    return
-  }
-  
-  if (isNaN(parseInt(price)) || parseInt(price) < 0) {
-    showSnackbar('올바른 가격을 입력해주세요', 'error')
-    return
-  }
-  
-  const menuData = {
-    menuName: menuName,
-    category: category,
-    price: parseInt(price),
-    description: description || ''
-  }
-  
-  console.log('✅ 최종 메뉴 수정 데이터:', menuData)
-  
-  menuResult = await menuService.updateMenu(menuId, menuData)
-}else {
-      // ✅ 메뉴 등록
+      // 메뉴 수정
+      const menuId = menuFormData.value.id || menuFormData.value.menuId
+      
+      if (!menuId || menuId === 'undefined' || menuId === null) {
+        showSnackbar('메뉴 ID가 없습니다', 'error')
+        return
+      }
+      
+      const menuData = {
+        menuName: menuFormData.value.menuName,
+        category: menuFormData.value.category,
+        price: parseInt(menuFormData.value.price) || 0,
+        description: menuFormData.value.description || ''
+      }
+      
+      console.log('✅ 메뉴 수정 데이터:', menuData)
+      
+      menuResult = await menuService.updateMenu(menuId, menuData)
+      savedMenuId = menuId
+    } else {
+      // 메뉴 등록
       const storeId = storeInfo.value?.storeId
       
       if (!storeId) {
@@ -1543,7 +1507,9 @@ const saveMenuWithImage = async () => {
         description: menuFormData.value.description?.trim() || ''
       }
       
-      menuResult = await menuService.registerMenu(menuData)
+      console.log('✅ 메뉴 등록 데이터:', menuData)
+      
+      menuResult = await menuService.createMenu(menuData)
       savedMenuId = menuResult.data?.menuId
     }
     
@@ -1554,22 +1520,23 @@ const saveMenuWithImage = async () => {
       return
     }
     
-    // ✅ 2단계: 이미지 업로드 (이미지가 있는 경우만)
-    if (menuFormData.value.imageFile && savedMenuId) {
+    // 이미지 업로드 처리 (새 이미지가 선택된 경우만)
+    if (selectedImageFile.value && savedMenuId) {
       console.log('=== 이미지 업로드 시작 ===')
       console.log('메뉴 ID:', savedMenuId)
-      console.log('이미지 파일:', menuFormData.value.imageFile)
+      console.log('이미지 파일:', selectedImageFile.value)
       
-      const imageResult = await menuService.uploadMenuImage(savedMenuId, menuFormData.value.imageFile)
+      const imageUrl = await uploadMenuImage(savedMenuId)
       
-      if (imageResult.success) {
-        console.log('✅ 이미지 업로드 완료:', imageResult)
+      if (imageUrl) {
+        console.log('✅ 이미지 업로드 완료:', imageUrl)
         showSnackbar(`메뉴가 ${menuEditMode.value ? '수정' : '등록'}되었고 이미지도 업로드되었습니다`, 'success')
       } else {
-        console.warn('⚠️ 이미지 업로드 실패:', imageResult.message)
+        console.warn('⚠️ 이미지 업로드 실패')
         showSnackbar(`메뉴는 ${menuEditMode.value ? '수정' : '등록'}되었지만 이미지 업로드에 실패했습니다`, 'warning')
       }
     } else {
+      console.log('새 이미지가 선택되지 않아 이미지 업로드 건너뜀')
       showSnackbar(`메뉴가 ${menuEditMode.value ? '수정' : '등록'}되었습니다`, 'success')
     }
     
@@ -1587,6 +1554,7 @@ const saveMenuWithImage = async () => {
   }
 }
 
+// 메뉴 삭제 함수
 const deleteMenu = async (menuId) => {
   console.log('=== 메뉴 삭제 시작 ===')
   console.log('삭제할 메뉴 ID:', menuId, '타입:', typeof menuId)
@@ -1615,6 +1583,8 @@ const deleteMenu = async (menuId) => {
   }
 }
 
+// ===== 데이터 로드 함수들 =====
+
 // 메뉴 데이터 로드 함수 - 실제 API 연동
 const loadMenus = async () => {
   try {
@@ -1634,12 +1604,21 @@ const loadMenus = async () => {
   }
 }
 
+// 개발 환경에서 전역으로 노출
+if (process.env.NODE_ENV === 'development') {
+  window.checkMenuImages = checkMenuImages
+  window.getMenuImageUrl = getMenuImageUrl
+}
+
 /**
  * 컴포넌트 마운트 시 실행
  */
 onMounted(async () => {
   console.log('=== StoreManagementView 마운트됨 ===')
   
+  // 플레이스홀더 이미지 확인
+  await checkPlaceholderImage()
+  
   try {
     const result = await storeStore.fetchStoreInfo()
     
@@ -1648,6 +1627,11 @@ onMounted(async () => {
     if (result.success) {
       console.log('✅ 매장 정보 로드 완료:', result.data)
       await loadMenus()
+      
+      // 개발 환경에서 이미지 상태 확인
+      if (process.env.NODE_ENV === 'development') {
+        setTimeout(checkMenuImages, 2000)
+      }
     } else {
       if (result.message === '등록된 매장이 없습니다') {
         console.log('⚠️ 등록된 매장이 없음 - 등록 화면 표시')
@@ -1726,30 +1710,201 @@ onMounted(async () => {
   height: 100%;
 }
 
-/* ✅ 이미지 업로드 관련 스타일 */
-.image-upload-section {
-  border: 1px dashed #e0e0e0;
-  border-radius: 8px;
-  padding: 16px;
-  background-color: #fafafa;
-}
-
+/* 드래그앤드롭 영역 스타일 */
 .drop-zone {
-  border: 2px dashed #e0e0e0;
-  border-radius: 8px;
-  padding: 24px;
-  text-align: center;
-  margin-top: 12px;
-  transition: border-color 0.3s ease, background-color 0.3s ease;
-  cursor: pointer;
+  transition: all 0.3s ease;
 }
 
 .drop-zone:hover {
+  border-color: #1976d2 !important;
+  background: #f3f8ff !important;
+}
+
+/* 이미지 미리보기 스타일 */
+.image-preview {
+  border: 2px solid #e0e0e0;
+  border-radius: 8px;
+  overflow: hidden;
+}
+
+.image-preview:hover {
   border-color: #1976d2;
+}
+
+/* 카드 그림자 효과 */
+.v-card {
+  transition: box-shadow 0.3s ease;
+}
+
+.v-card:hover {
+  box-shadow: 0 4px 20px rgba(0, 0, 0, 0.1) !important;
+}
+
+/* 버튼 호버 효과 */
+.v-btn {
+  transition: all 0.2s ease;
+}
+
+.v-btn:hover {
+  transform: translateY(-1px);
+}
+
+/* 탭 스타일 */
+.v-tabs {
+  border-radius: 8px;
+  overflow: hidden;
+}
+
+.v-tab {
+  font-weight: 500;
+  text-transform: none;
+}
+
+.v-tab--selected {
+  background-color: rgba(25, 118, 210, 0.08);
+}
+
+/* 폼 입력 필드 스타일 */
+.v-text-field, .v-select, .v-textarea {
+  margin-bottom: 4px;
+}
+
+.v-text-field .v-field, 
+.v-select .v-field, 
+.v-textarea .v-field {
+  border-radius: 8px;
+}
+
+/* 다이얼로그 스타일 */
+.v-dialog .v-card {
+  border-radius: 12px;
+  overflow: hidden;
+}
+
+.v-dialog .v-card-title {
+  background-color: rgba(25, 118, 210, 0.02);
+  border-bottom: 1px solid #e0e0e0;
+}
+
+/* 메뉴 카드 내 액션 버튼 */
+.menu-card .v-btn {
+  backdrop-filter: blur(4px);
+  background-color: rgba(255, 255, 255, 0.9);
+}
+
+.menu-card .v-btn:hover {
+  background-color: rgba(255, 255, 255, 1);
+  transform: scale(1.05);
+}
+
+/* 스낵바 스타일 */
+.v-snackbar {
+  border-radius: 12px;
+  margin: 16px;
+}
+
+/* 칩 스타일 */
+.v-chip {
+  font-weight: 500;
+  border-radius: 16px;
+}
+
+/* 아바타 스타일 */
+.v-avatar {
+  border: 3px solid #fff;
+  box-shadow: 0 2px 8px rgba(0, 0, 0, 0.1);
+}
+
+/* 프로그레스 원형 스타일 */
+.v-progress-circular {
+  margin: auto;
+}
+
+/* 메뉴 정보 레이아웃 */
+.info-section {
+  padding: 16px;
+  border-radius: 8px;
+  background-color: #fafafa;
+  margin-bottom: 16px;
+}
+
+/* 이미지 업로드 관련 스타일 */
+.rounded {
+  border-radius: 8px;
+}
+
+.mx-auto {
+  margin-left: auto;
+  margin-right: auto;
+}
+
+/* 파일 입력 스타일 */
+.v-file-input {
+  margin-bottom: 16px;
+}
+
+.v-file-input .v-field {
+  border-radius: 8px;
+}
+
+/* 로딩 상태 */
+.loading-overlay {
+  position: absolute;
+  top: 0;
+  left: 0;
+  right: 0;
+  bottom: 0;
+  background: rgba(255, 255, 255, 0.8);
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  z-index: 10;
+}
+
+/* 이미지 로딩 실패 시 스타일 */
+.v-img--error {
   background-color: #f5f5f5;
 }
 
-@media (max-width: 600px) {
+.v-img--error .v-icon {
+  opacity: 0.3;
+}
+
+/* 이미지 로딩 중 스타일 */
+.v-img--loading {
+  background-color: #f5f5f5;
+}
+
+/* Azure Blob Storage 이미지 최적화 */
+.menu-image {
+  object-fit: cover;
+  width: 100%;
+  height: 200px;
+}
+
+/* 플레이스홀더 이미지 스타일 */
+.placeholder-image {
+  background-color: #f0f0f0;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+}
+
+.placeholder-image .v-icon {
+  color: #bdbdbd;
+}
+
+/* 이미지 호버 효과 */
+.menu-card .v-img {
+  transition: transform 0.2s ease;
+}
+
+.menu-card:hover .v-img {
+  transform: scale(1.02);
+}
+
+/* 반응형 디자인 */
+@media (max-width: 960px) {
   .info-item {
     margin-bottom: 12px;
   }
@@ -1758,16 +1913,227 @@ onMounted(async () => {
     margin-bottom: 16px;
   }
   
+  .gap-3 {
+    gap: 8px;
+  }
+  
+  .v-dialog {
+    margin: 16px;
+  }
+  
+  .v-dialog .v-card {
+    max-width: calc(100vw - 32px) !important;
+  }
+}
+
+@media (max-width: 600px) {
+  .info-item {
+    flex-direction: column;
+    gap: 4px;
+  }
+  
+  .info-item .v-icon {
+    margin-top: 0;
+  }
+  
   .empty-state {
     padding: 2rem 1rem;
   }
   
-  .image-upload-section {
-    padding: 12px;
+  .v-container {
+    padding: 8px !important;
   }
   
-  .drop-zone {
-    padding: 16px;
+  .menu-card .position-absolute {
+    opacity: 0;
+    transition: opacity 0.2s ease;
+  }
+  
+  .menu-card:hover .position-absolute,
+  .menu-card:active .position-absolute {
+    opacity: 1;
+  }
+  
+  /* 모바일에서 버튼 크기 조정 */
+  .menu-card .v-btn {
+    min-width: 32px;
+    width: 32px;
+    height: 32px;
+  }
+  
+  /* 모바일에서 탭 크기 조정 */
+  .v-tab {
+    min-width: 120px;
+    font-size: 0.875rem;
   }
 }
+
+/* 스크롤바 스타일 (웹킷 브라우저) */
+::-webkit-scrollbar {
+  width: 6px;
+}
+
+::-webkit-scrollbar-track {
+  background: #f1f1f1;
+  border-radius: 3px;
+}
+
+::-webkit-scrollbar-thumb {
+  background: #c1c1c1;
+  border-radius: 3px;
+}
+
+::-webkit-scrollbar-thumb:hover {
+  background: #a8a8a8;
+}
+
+/* 로딩 애니메이션 */
+@keyframes fadeIn {
+  from {
+    opacity: 0;
+    transform: translateY(20px);
+  }
+  to {
+    opacity: 1;
+    transform: translateY(0);
+  }
+}
+
+.fade-in {
+  animation: fadeIn 0.5s ease-out;
+}
+
+/* 메뉴 카드 진입 애니메이션 */
+.menu-card {
+  animation: fadeIn 0.3s ease-out;
+}
+
+.menu-card:nth-child(1) { animation-delay: 0s; }
+.menu-card:nth-child(2) { animation-delay: 0.05s; }
+.menu-card:nth-child(3) { animation-delay: 0.1s; }
+.menu-card:nth-child(4) { animation-delay: 0.15s; }
+.menu-card:nth-child(n+5) { animation-delay: 0.2s; }
+
+/* 이미지 로딩 플레이스홀더 */
+.v-img__img {
+  transition: opacity 0.3s ease;
+}
+
+.v-img--loading .v-img__img {
+  opacity: 0;
+}
+
+/* 포커스 스타일 개선 */
+.v-btn:focus-visible {
+  outline: 2px solid #1976d2;
+  outline-offset: 2px;
+}
+
+.v-text-field:focus-within .v-field,
+.v-select:focus-within .v-field,
+.v-textarea:focus-within .v-field {
+  border: 2px solid #1976d2;
+  box-shadow: 0 0 0 1px rgba(25, 118, 210, 0.2);
+}
+
+/* 드롭존 드래그 오버 효과 */
+.drop-zone.drag-over {
+  border-color: #1976d2 !important;
+  background: #e3f2fd !important;
+  transform: scale(1.02);
+}
+
+/* 상태별 스타일 */
+.error-state {
+  color: #d32f2f;
+}
+
+.error-state .v-icon {
+  color: #d32f2f;
+}
+
+.success-state {
+  color: #2e7d32;
+}
+
+.success-state .v-icon {
+  color: #2e7d32;
+}
+
+.warning-state {
+  color: #ed6c02;
+}
+
+.warning-state .v-icon {
+  color: #ed6c02;
+}
+
+/* ✅ 메뉴 다이얼로그 스타일 추가 - Style 부분에 추가 */
+
+/* 메뉴 다이얼로그 전용 스타일 */
+.menu-dialog .v-overlay__content {
+  max-height: 90vh !important;
+  margin: 24px;
+}
+
+.menu-dialog-card {
+  max-height: 90vh !important;
+  display: flex;
+  flex-direction: column;
+}
+
+.menu-dialog-card .dialog-content {
+  flex: 1;
+  overflow-y: auto;
+  max-height: calc(90vh - 120px); /* 헤더와 푸터 공간 제외 */
+}
+
+/* 드래그앤드롭 영역 크기 조정 */
+.menu-dialog .drop-zone {
+  min-height: 80px !important;
+  max-height: 80px !important;
+}
+
+/* 이미지 미리보기 크기 조정 */
+.menu-dialog .v-img {
+  max-height: 180px !important;
+  max-width: 280px !important;
+}
+
+/* 모바일에서 다이얼로그 최적화 */
+@media (max-width: 600px) {
+  .menu-dialog .v-overlay__content {
+    margin: 16px;
+    max-height: 95vh !important;
+  }
+  
+  .menu-dialog-card .dialog-content {
+    max-height: calc(95vh - 100px);
+    padding: 16px !important;
+  }
+  
+  .menu-dialog .v-img {
+    max-height: 150px !important;
+    max-width: 200px !important;
+  }
+}
+
+/* 스크롤바 스타일 개선 */
+.dialog-content::-webkit-scrollbar {
+  width: 6px;
+}
+
+.dialog-content::-webkit-scrollbar-track {
+  background: #f1f1f1;
+  border-radius: 3px;
+}
+
+.dialog-content::-webkit-scrollbar-thumb {
+  background: #c1c1c1;
+  border-radius: 3px;
+}
+
+.dialog-content::-webkit-scrollbar-thumb:hover {
+  background: #a8a8a8;
+}
 </style>
\ No newline at end of file

From 4be4ba790f24813745d4037cf7f0e084cb7ee1d0 Mon Sep 17 00:00:00 2001
From: unknown <yyoooona@gmail.com>
Date: Wed, 18 Jun 2025 10:52:01 +0900
Subject: [PATCH 07/11] store source release

---
 src/services/store.js             |  12 ++-
 src/views/StoreManagementView.vue | 159 ++++++++++++++++++++++++------
 2 files changed, 136 insertions(+), 35 deletions(-)

diff --git a/src/services/store.js b/src/services/store.js
index ef880b8..94abee9 100644
--- a/src/services/store.js
+++ b/src/services/store.js
@@ -140,8 +140,10 @@ class StoreService {
         businessType: storeData.businessType,
         address: storeData.address,
         phoneNumber: storeData.phoneNumber,
-        businessHours: storeData.businessHours,
-        closedDays: storeData.closedDays,
+        // ✅ 수정: businessHours 필드 처리
+        businessHours: storeData.businessHours || `${storeData.openTime || '09:00'}-${storeData.closeTime || '21:00'}`,
+        // ✅ 수정: closedDays 필드 처리  
+        closedDays: storeData.closedDays || storeData.holidays || '',
         seatCount: parseInt(storeData.seatCount) || 0,
         instaAccounts: storeData.instaAccounts || '',
         blogAccounts: storeData.blogAccounts || '',
@@ -150,9 +152,9 @@ class StoreService {
       
       console.log('백엔드 전송 데이터:', requestData)
       
-      // PUT 요청 (storeId는 JWT에서 추출하므로 URL에 포함하지 않음)
-      const response = await storeApi.put('/', requestData)
-      
+      // ✅ 핵심 수정: 슬래시 제거하고 빈 문자열 사용
+      console.log('API 호출 경로: PUT /api/store (baseURL + 빈 문자열)')
+      const response = await storeApi.put('', requestData)
       console.log('매장 정보 수정 API 응답:', response.data)
       
       if (response.data && (response.data.status === 200 || response.data.success !== false)) {
diff --git a/src/views/StoreManagementView.vue b/src/views/StoreManagementView.vue
index 7584086..07c27af 100644
--- a/src/views/StoreManagementView.vue
+++ b/src/views/StoreManagementView.vue
@@ -356,8 +356,14 @@
     </div>
 
     <!-- 매장 등록/수정 다이얼로그 -->
-    <v-dialog v-model="showCreateDialog" max-width="600" persistent>
-      <v-card>
+    <v-dialog 
+      v-model="showCreateDialog" 
+      max-width="600" 
+      persistent
+      :style="{ zIndex: 2000 }"
+      class="store-dialog"
+    >
+      <v-card class="store-dialog-card">
         <v-card-title class="pa-4">
           <div class="d-flex align-center">
             <v-icon class="mr-2" color="primary">mdi-store</v-icon>
@@ -367,7 +373,8 @@
         
         <v-divider />
         
-        <v-card-text class="pa-4">
+        <!-- ✅ 스크롤 가능한 컨텐츠 영역 -->
+        <v-card-text class="pa-4 store-dialog-content">
           <v-form ref="storeFormRef" v-model="formValid">
             <v-row>
               <v-col cols="12">
@@ -481,7 +488,7 @@
                   label="매장 소개"
                   variant="outlined"
                   density="compact"
-                  rows="3"
+                  rows="2"
                 />
               </v-col>
             </v-row>
@@ -506,7 +513,7 @@
           </v-btn>
         </v-card-actions>
       </v-card>
-    </v-dialog>
+</v-dialog>
 
     <!-- 메뉴 등록/수정 다이얼로그 -->
     <v-dialog 
@@ -778,7 +785,7 @@
 </template>
 
 <script setup>
-import { ref, computed, onMounted, watch } from 'vue'
+import { ref, computed, onMounted, watch, nextTick } from 'vue'
 import { useStoreStore } from '@/store/index'
 
 const storeStore = useStoreStore()
@@ -804,6 +811,7 @@ const menuFormValid = ref(false)
 // 이미지 관련 상태
 const selectedImageFile = ref(null)
 const previewImageUrl = ref('')
+const forceShowFileInput = ref(false) // ✅ 추가: 파일 입력 강제 표시용
 
 // 메뉴 폼 데이터
 const menuFormData = ref({
@@ -881,8 +889,13 @@ const filteredMenus = computed(() => {
   return filtered
 })
 
-// 이미지 미리보기 표시 조건 (computed)
+// 이미지 미리보기 표시 조건 수정
 const shouldShowImagePreview = computed(() => {
+  // ✅ 강제로 파일 입력을 보여줘야 하는 경우
+  if (forceShowFileInput.value) {
+    return null
+  }
+  
   // 1순위: 새로 선택한 이미지 미리보기
   if (previewImageUrl.value) {
     return previewImageUrl.value
@@ -895,7 +908,6 @@ const shouldShowImagePreview = computed(() => {
   
   return null
 })
-
 // ===== 유틸리티 함수들 =====
 
 /**
@@ -1016,13 +1028,14 @@ watch(selectedImageFile, (newFile, oldFile) => {
   }
 }, { immediate: false })
 
-// v-file-input의 modelValue 변경 감지 함수
+// ✅ 파일 입력 변경 감지 함수 개선
 const onFileInputChange = (file) => {
   console.log('=== v-file-input v-model 변경 감지 ===')
   console.log('전달받은 file:', file)
   
   if (file) {
-    // selectedImageFile에 할당
+    // 파일이 선택되면 강제 표시 모드 해제
+    forceShowFileInput.value = false
     selectedImageFile.value = file
     onImageFileSelected(file)
   } else {
@@ -1158,17 +1171,21 @@ const uploadMenuImage = async (menuId) => {
   }
 }
 
-// 이미지 선택 초기화 함수
+// ✅ 개선된 이미지 선택 초기화 함수
 const resetImageSelection = () => {
-  console.log('이미지 선택 초기화')
+  console.log('=== 이미지 선택 초기화 시작 ===')
+  
+  // 1. 모든 이미지 관련 상태 초기화
   selectedImageFile.value = null
   previewImageUrl.value = ''
   
-  // v-file-input도 초기화하기 위해 DOM 조작 추가
-  const fileInput = document.querySelector('input[type="file"]')
-  if (fileInput) {
-    fileInput.value = ''
-  }
+  // 2. 강제로 파일 입력 표시
+  forceShowFileInput.value = true
+  
+  // 3. Vue의 반응성을 위해 nextTick 사용
+  nextTick(() => {
+    console.log('✅ 이미지 선택 초기화 완료 - 파일 입력 표시됨')
+  })
 }
 
 // 드래그앤드롭 처리
@@ -1206,7 +1223,7 @@ const resetForm = () => {
   }
 }
 
-// 메뉴 폼 리셋 함수
+// ✅ 메뉴 폼 리셋 함수 개선
 const resetMenuForm = () => {
   console.log('=== 메뉴 폼 리셋 ===')
   
@@ -1225,6 +1242,7 @@ const resetMenuForm = () => {
   // 이미지 관련 상태 초기화
   selectedImageFile.value = null
   previewImageUrl.value = ''
+  forceShowFileInput.value = false // ✅ 추가
   
   if (menuFormRef.value) {
     menuFormRef.value.resetValidation()
@@ -1273,7 +1291,7 @@ const openCreateMenuDialog = () => {
   showMenuDialog.value = true
 }
 
-// 메뉴 수정 함수
+// ✅ 메뉴 수정 함수에서 이미지 상태 올바르게 설정
 const editMenu = (menu) => {
   console.log('=== 메뉴 수정 호출 ===')
   console.log('전달받은 메뉴 객체:', menu)
@@ -1309,11 +1327,13 @@ const editMenu = (menu) => {
     imageUrl: menu.image || menu.imageUrl || ''
   }
   
-  // 이미지 상태 초기화
+  // ✅ 이미지 상태 올바르게 초기화
   selectedImageFile.value = null
   previewImageUrl.value = ''
+  forceShowFileInput.value = false // 기존 이미지를 먼저 보여줌
   
   console.log('✅ 메뉴 수정 폼 데이터 설정 완료:', menuFormData.value)
+  console.log('✅ 기존 이미지 URL:', menuFormData.value.imageUrl)
   showMenuDialog.value = true
 }
 
@@ -1372,6 +1392,8 @@ const cancelMenuForm = () => {
 
 // ===== 저장 관련 함수들 =====
 
+// ✅ StoreManagementView.vue의 saveStore 함수 수정
+
 // 매장 정보 저장 함수
 const saveStore = async () => {
   if (!storeFormRef.value) {
@@ -1389,17 +1411,19 @@ const saveStore = async () => {
   
   try {
     console.log('매장 정보 저장 시작')
+    console.log('폼 데이터:', formData.value)
     
-    // 백엔드 형식에 맞는 데이터 구조로 변환
+    // ✅ 백엔드 형식에 맞는 데이터 구조로 변환
     const storeData = {
       storeName: formData.value.storeName,
       businessType: formData.value.businessType,
       address: formData.value.address,
       phoneNumber: formData.value.phoneNumber || '',
-      openTime: formData.value.openTime || '09:00',
-      closeTime: formData.value.closeTime || '21:00',
-      holidays: Array.isArray(formData.value.holidays) ? 
-        formData.value.holidays.join(',') : '',
+      // ✅ 수정: 시간 범위 문자열로 생성
+      businessHours: `${formData.value.openTime || '09:00'}-${formData.value.closeTime || '21:00'}`,
+      // ✅ 수정: 휴무일 배열을 문자열로 변환
+      closedDays: Array.isArray(formData.value.holidays) ? 
+        formData.value.holidays.join(',') : (formData.value.holidays || ''),
       seatCount: parseInt(formData.value.seatCount) || 0,
       instaAccounts: formData.value.instagramUrl || '',
       blogAccounts: formData.value.blogUrl || '',
@@ -1407,11 +1431,19 @@ const saveStore = async () => {
     }
     
     console.log('백엔드로 전송할 데이터:', storeData)
+    console.log('=== 필드별 상세 정보 ===')
+    console.log('storeName:', storeData.storeName, '(타입:', typeof storeData.storeName, ')')
+    console.log('businessType:', storeData.businessType, '(타입:', typeof storeData.businessType, ')')
+    console.log('businessHours:', storeData.businessHours, '(타입:', typeof storeData.businessHours, ')')
+    console.log('closedDays:', storeData.closedDays, '(타입:', typeof storeData.closedDays, ')')
+    console.log('seatCount:', storeData.seatCount, '(타입:', typeof storeData.seatCount, ')')
     
     let result
     if (editMode.value) {
+      console.log('🔄 매장 정보 수정 API 호출')
       result = await storeStore.updateStore(storeInfo.value.storeId, storeData)
     } else {
+      console.log('➕ 매장 정보 등록 API 호출')
       result = await storeStore.registerStore(storeData)
     }
     
@@ -1437,6 +1469,8 @@ const saveStore = async () => {
   }
 }
 
+// ✅ 메뉴 수정 후 위치 유지를 위한 saveMenu 함수 개선
+
 // 메뉴 저장 함수
 const saveMenu = async () => {
   console.log('=== 메뉴 저장 시작 ===')
@@ -1469,6 +1503,7 @@ const saveMenu = async () => {
     
     let menuResult
     let savedMenuId
+    let isEdit = menuEditMode.value // ✅ 수정 모드 여부 저장
     
     if (menuEditMode.value) {
       // 메뉴 수정
@@ -1530,21 +1565,33 @@ const saveMenu = async () => {
       
       if (imageUrl) {
         console.log('✅ 이미지 업로드 완료:', imageUrl)
-        showSnackbar(`메뉴가 ${menuEditMode.value ? '수정' : '등록'}되었고 이미지도 업로드되었습니다`, 'success')
+        showSnackbar(`메뉴가 ${isEdit ? '수정' : '등록'}되었고 이미지도 업로드되었습니다`, 'success')
       } else {
         console.warn('⚠️ 이미지 업로드 실패')
-        showSnackbar(`메뉴는 ${menuEditMode.value ? '수정' : '등록'}되었지만 이미지 업로드에 실패했습니다`, 'warning')
+        showSnackbar(`메뉴는 ${isEdit ? '수정' : '등록'}되었지만 이미지 업로드에 실패했습니다`, 'warning')
       }
     } else {
       console.log('새 이미지가 선택되지 않아 이미지 업로드 건너뜀')
-      showSnackbar(`메뉴가 ${menuEditMode.value ? '수정' : '등록'}되었습니다`, 'success')
+      showSnackbar(`메뉴가 ${isEdit ? '수정' : '등록'}되었습니다`, 'success')
     }
     
-    // 다이얼로그 닫기 및 목록 새로고침
+    // ✅ 다이얼로그 닫기 및 상태 초기화
     showMenuDialog.value = false
     menuEditMode.value = false
     resetMenuForm()
-    await loadMenus()
+    
+    // ✅ 메뉴 목록 새로고침 (수정 모드일 때는 지연 없이 즉시)
+    if (isEdit) {
+      // 수정인 경우: 즉시 새로고침하여 위치 유지
+      await loadMenus()
+      console.log('✅ 메뉴 수정 완료 - 목록 새로고침됨 (위치 유지)')
+    } else {
+      // 신규 등록인 경우: 약간의 지연 후 새로고침 (새 메뉴가 맨 앞에 추가됨)
+      setTimeout(async () => {
+        await loadMenus()
+        console.log('✅ 메뉴 등록 완료 - 목록 새로고침됨')
+      }, 500)
+    }
     
   } catch (error) {
     console.error('❌ 메뉴 저장 중 예외 발생:', error)
@@ -2136,4 +2183,56 @@ onMounted(async () => {
 .dialog-content::-webkit-scrollbar-thumb:hover {
   background: #a8a8a8;
 }
+
+/* ✅ 매장 다이얼로그 스타일 추가 - Style 부분에 추가 */
+
+/* 매장 다이얼로그 전용 스타일 */
+.store-dialog .v-overlay__content {
+  max-height: 90vh !important;
+  margin: 24px;
+}
+
+.store-dialog-card {
+  max-height: 90vh !important;
+  display: flex;
+  flex-direction: column;
+}
+
+.store-dialog-card .store-dialog-content {
+  flex: 1;
+  overflow-y: auto;
+  max-height: calc(90vh - 120px); /* 헤더와 푸터 공간 제외 */
+}
+
+/* 모바일에서 매장 다이얼로그 최적화 */
+@media (max-width: 600px) {
+  .store-dialog .v-overlay__content {
+    margin: 16px;
+    max-height: 95vh !important;
+  }
+  
+  .store-dialog-card .store-dialog-content {
+    max-height: calc(95vh - 100px);
+    padding: 16px !important;
+  }
+}
+
+/* 매장 다이얼로그 스크롤바 스타일 */
+.store-dialog-content::-webkit-scrollbar {
+  width: 6px;
+}
+
+.store-dialog-content::-webkit-scrollbar-track {
+  background: #f1f1f1;
+  border-radius: 3px;
+}
+
+.store-dialog-content::-webkit-scrollbar-thumb {
+  background: #c1c1c1;
+  border-radius: 3px;
+}
+
+.store-dialog-content::-webkit-scrollbar-thumb:hover {
+  background: #a8a8a8;
+}
 </style>
\ No newline at end of file

From cdacaa197075825c3e238b7104b0b9d1f273af5f Mon Sep 17 00:00:00 2001
From: unknown <yyoooona@gmail.com>
Date: Wed, 18 Jun 2025 15:17:52 +0900
Subject: [PATCH 08/11] content management & store management release

---
 src/services/content.js             |  925 ++++++++++++++++---
 src/store/content.js                | 1325 +++++++++++++++++++++------
 src/views/ContentManagementView.vue |   27 +-
 src/views/StoreManagementView.vue   | 1263 +++++++++++--------------
 4 files changed, 2370 insertions(+), 1170 deletions(-)

diff --git a/src/services/content.js b/src/services/content.js
index 99ee797..d700972 100644
--- a/src/services/content.js
+++ b/src/services/content.js
@@ -1,172 +1,670 @@
-//* src/services/content.js
-import { contentApi, handleApiError, formatSuccessResponse } from './api.js'
+//* src/services/content.js - 두 파일 완전 통합 버전
+import axios from 'axios'
+
+// runtime-env.js에서 API URL 가져오기 (대체 방식 포함)
+const getApiUrl = (serviceName) => {
+  if (typeof window !== 'undefined' && window.__runtime_config__) {
+    const urlKey = `${serviceName.toUpperCase()}_URL`
+    const apiUrl = window.__runtime_config__[urlKey]
+    if (apiUrl) {
+      console.log(`✅ ${serviceName} API URL 로드됨:`, apiUrl)
+      return apiUrl
+    }
+  }
+  
+  // 대체 URL 반환 - /api/content 사용 (백엔드 경로에 맞춤)
+  const fallbackUrl = `http://localhost:8083/api/content`
+  console.log(`⚠️ ${serviceName} API URL 대체값 사용:`, fallbackUrl)
+  return fallbackUrl
+}
+
+// Content API 인스턴스 생성 - baseURL 수정 (마지막 슬래시 제거)
+const contentApi = axios.create({
+  baseURL: getApiUrl('CONTENT').replace(/\/$/, ''), // 마지막 슬래시 제거
+  timeout: 30000,
+  headers: {
+    'Content-Type': 'application/json'
+  }
+})
+
+// 요청 인터셉터 - JWT 토큰 자동 추가
+contentApi.interceptors.request.use(
+  (config) => {
+    console.log('🔄 Content API 요청:', config.method?.toUpperCase(), config.url)
+    
+    const token = localStorage.getItem('accessToken') || localStorage.getItem('auth_token') || localStorage.getItem('token')
+    if (token) {
+      config.headers.Authorization = `Bearer ${token}`
+    } else {
+      console.warn('⚠️ JWT 토큰이 없습니다!')
+    }
+    
+    console.log('요청 데이터:', config.data || config.params)
+    return config
+  },
+  (error) => {
+    console.error('❌ Content API 요청 오류:', error)
+    return Promise.reject(error)
+  }
+)
+
+// 응답 인터셉터
+contentApi.interceptors.response.use(
+  (response) => {
+    console.log('✅ Content API 응답:', response.status, response.data)
+    return response
+  },
+  (error) => {
+    console.error('❌ Content API 응답 오류:', error.response?.status, error.response?.data)
+    
+    if (error.response?.status === 401) {
+      // 토큰 만료 처리
+      localStorage.removeItem('auth_token')
+      window.location.href = '/login'
+    }
+    
+    return Promise.reject(error)
+  }
+)
+
+// 공통 응답 처리 함수
+const formatSuccessResponse = (data, message = '요청이 성공했습니다.') => ({
+  success: true,
+  data,
+  message
+})
+
+const handleApiError = (error) => {
+  console.error('API 오류 처리:', error)
+  
+  if (error.response) {
+    return {
+      success: false,
+      error: error.response.data?.message || `서버 오류 (${error.response.status})`,
+      status: error.response.status
+    }
+  } else if (error.request) {
+    return {
+      success: false,
+      error: '네트워크 연결을 확인해주세요.',
+      status: 0
+    }
+  } else {
+    return {
+      success: false,
+      error: error.message || '알 수 없는 오류가 발생했습니다.',
+      status: 0
+    }
+  }
+}
 
 /**
- * 마케팅 콘텐츠 관련 API 서비스
- * 백엔드 SnsContentCreateRequest DTO에 맞게 수정
+ * 콘텐츠 서비스 클래스 - 완전 통합 버전
+ * 백엔드 API 설계서와 일치하도록 구현
  */
 class ContentService {
   /**
-   * SNS 게시물 생성
-   * @param {Object} contentData - SNS 콘텐츠 생성 정보
-   * @returns {Promise<Object>} 생성된 SNS 콘텐츠
+   * 콘텐츠 목록 조회 (CON-021: 콘텐츠 조회)
+   * @param {Object} filters - 필터 조건
+   * @param {string} filters.platform - 플랫폼 (instagram, blog, poster)
+   * @param {number} filters.storeId - 매장 ID
+   * @param {string} filters.contentType - 콘텐츠 타입
+   * @param {string} filters.period - 조회 기간
+   * @param {string} filters.sortBy - 정렬 기준
+   * @returns {Promise<Object>} 콘텐츠 목록
    */
-  async generateSnsContent(contentData) {
+  async getContents(filters = {}) {
     try {
-      console.log('🚀 SNS 콘텐츠 생성 요청:', contentData)
+      console.log('🔄 콘텐츠 목록 조회 요청:', filters)
       
-      // 백엔드 SnsContentCreateRequest DTO에 맞는 데이터 구조
-      const requestData = {
-        // === 기본 정보 ===
-        storeId: contentData.storeId || 1,
-        storeName: contentData.storeName || '테스트 매장',
-        storeType: contentData.storeType || '음식점',
-        platform: this.mapPlatform(contentData.platform),
-        title: contentData.title,
-        
-        // === 콘텐츠 생성 조건 ===
-        category: contentData.category || this.mapTargetToCategory(contentData.targetType),
-        requirement: contentData.requirements || contentData.content || '',
-        target: contentData.targetType || '일반 고객',
-        contentType: 'SNS 게시물',
-        
-        // === 이벤트 정보 ===
-        eventName: contentData.eventName || null,
-        startDate: contentData.startDate ? this.formatDate(contentData.startDate) : null,
-        endDate: contentData.endDate ? this.formatDate(contentData.endDate) : null,
-        
-        // === 미디어 정보 ===
-        images: contentData.images || [],
-        photoStyle: this.mapPhotoStyle(contentData.aiOptions?.photoStyle),
-        
-        // === 추가 옵션 ===
-        includeHashtags: true,
-        includeEmojis: true,
-        includeCallToAction: true,
-        includeLocationInfo: false
+      // 쿼리 파라미터 구성 - 빈 값 제거
+      const params = new URLSearchParams()
+      
+      // 필수 파라미터만 추가 (값이 있을 때만)
+      if (filters.storeId) {
+        params.append('storeId', filters.storeId.toString())
       }
+      if (filters.sortBy) {
+        params.append('sortBy', filters.sortBy)
+      }
+      
+      // 선택적 파라미터 (값이 있고 'all'이 아닐 때만)
+      if (filters.platform && filters.platform !== 'all') {
+        params.append('platform', filters.platform)
+      }
+      if (filters.contentType && filters.contentType !== 'all') {
+        params.append('contentType', filters.contentType)
+      }
+      if (filters.period && filters.period !== 'all') {
+        params.append('period', filters.period)
+      }
+      
+      const queryString = params.toString()
+      const fullUrl = `${getApiUrl('CONTENT').replace(/\/$/, '')}${queryString ? `?${queryString}` : ''}`
+      
+      console.log('📡 완전한 API URL:', fullUrl)
+      
+      // axios 대신 fetch 사용 (브라우저 콘솔 테스트와 동일하게)
+      const response = await fetch(fullUrl, {
+        method: 'GET',
+        headers: {
+          'Authorization': `Bearer ${localStorage.getItem('accessToken') || localStorage.getItem('auth_token') || localStorage.getItem('token')}`,
+          'Content-Type': 'application/json'
+        }
+      })
+      
+      if (!response.ok) {
+        throw new Error(`HTTP ${response.status}: ${response.statusText}`)
+      }
+      
+      const responseData = await response.json()
 
-      console.log('📤 백엔드 DTO 맞춤 데이터:', requestData)
+      // 백엔드 응답 구조에 따른 데이터 추출
+      let contentData = []
       
-      const response = await contentApi.post('/sns/generate', requestData)
+      if (responseData.success) {
+        contentData = responseData.data || []
+      } else if (Array.isArray(responseData)) {
+        contentData = responseData
+      } else if (responseData.contents) {
+        contentData = responseData.contents
+      } else if (responseData.data) {
+        contentData = responseData.data || []
+      }
       
-      console.log('📥 API 응답:', response.data)
+      console.log('✅ 콘텐츠 조회 성공:', contentData.length, '개')
       
-      // 응답 데이터 구조에 맞게 처리
-      const responseData = response.data.data || response.data
-      
-      return formatSuccessResponse({
-        content: responseData.content || responseData,
-        hashtags: responseData.hashtags || [],
-        ...responseData
-      }, 'SNS 게시물이 생성되었습니다.')
+      return formatSuccessResponse(contentData, '콘텐츠 목록을 조회했습니다.')
     } catch (error) {
-      console.error('❌ SNS 콘텐츠 생성 실패:', error)
+      console.error('❌ 콘텐츠 조회 실패:', error)
       return handleApiError(error)
     }
   }
 
   /**
-   * 플랫폼 매핑 (프론트엔드 -> 백엔드)
+   * SNS 콘텐츠 생성 (CON-019: AI 콘텐츠 생성)
+   * @param {Object} contentData - 콘텐츠 생성 데이터
+   * @returns {Promise<Object>} 생성된 콘텐츠
    */
-  mapPlatform(platform) {
-    const mapping = {
-      'instagram': 'INSTAGRAM',
-      'naver_blog': 'NAVER_BLOG', 
-      'facebook': 'FACEBOOK',
-      'kakao_story': 'KAKAO_STORY'
+  async generateSnsContent(contentData) {
+    try {
+      console.log('🤖 SNS 콘텐츠 생성 요청:', contentData)
+      
+      // ✅ 이미지 처리 (SNS는 선택사항)
+      let processedImages = []
+      if (contentData.images && Array.isArray(contentData.images) && contentData.images.length > 0) {
+        console.log('📁 [API] SNS 이미지 처리:', contentData.images.length, '개')
+        
+        processedImages = contentData.images.filter(img => {
+          const isValid = img && typeof img === 'string' && img.length > 0
+          console.log('📁 [API] SNS 이미지 유효성:', { isValid, type: typeof img, length: img?.length })
+          return isValid
+        })
+        
+        console.log('📁 [API] SNS 유효 이미지:', processedImages.length, '개')
+      }
+      
+      // ✅ 실제 전달받은 데이터만 사용 (백엔드 API 스펙에 맞춤)
+      const requestData = {}
+      
+      if (contentData.storeId !== undefined) requestData.storeId = contentData.storeId
+      if (contentData.storeName) requestData.storeName = contentData.storeName
+      if (contentData.storeType) requestData.storeType = contentData.storeType
+      if (contentData.platform) requestData.platform = contentData.platform
+      if (contentData.title) requestData.title = contentData.title
+      if (contentData.category) requestData.category = contentData.category
+      if (contentData.requirement || contentData.requirements) {
+        requestData.requirement = contentData.requirement || contentData.requirements
+      }
+      if (contentData.target || contentData.targetAudience) {
+        requestData.target = contentData.target || contentData.targetAudience
+      }
+      if (contentData.contentType) requestData.contentType = contentData.contentType
+      if (contentData.eventName) requestData.eventName = contentData.eventName
+      if (contentData.startDate) requestData.startDate = contentData.startDate
+      if (contentData.endDate) requestData.endDate = contentData.endDate
+      if (contentData.photoStyle) requestData.photoStyle = contentData.photoStyle
+      if (contentData.targetAge) requestData.targetAge = contentData.targetAge
+      if (contentData.toneAndManner) requestData.toneAndManner = contentData.toneAndManner
+      if (contentData.emotionalIntensity || contentData.emotionIntensity) {
+        requestData.emotionalIntensity = contentData.emotionalIntensity || contentData.emotionIntensity
+      }
+      if (contentData.promotionalType || contentData.promotionType) {
+        requestData.promotionalType = contentData.promotionalType || contentData.promotionType
+      }
+      if (contentData.eventDate) requestData.eventDate = contentData.eventDate
+      if (contentData.hashtagStyle) requestData.hashtagStyle = contentData.hashtagStyle
+      if (contentData.hashtagCount) requestData.hashtagCount = contentData.hashtagCount
+      if (contentData.contentLength) requestData.contentLength = contentData.contentLength
+      
+      // 이미지는 처리된 것으로 설정
+      requestData.images = processedImages
+      
+      // Boolean 필드들 (기본값 처리)
+      if (contentData.includeHashtags !== undefined) requestData.includeHashtags = contentData.includeHashtags
+      if (contentData.includeEmojis !== undefined) requestData.includeEmojis = contentData.includeEmojis
+      if (contentData.includeEmoji !== undefined) requestData.includeEmoji = contentData.includeEmoji
+      if (contentData.includeCallToAction !== undefined) requestData.includeCallToAction = contentData.includeCallToAction
+      if (contentData.includeLocation !== undefined) requestData.includeLocation = contentData.includeLocation
+      if (contentData.forInstagramStory !== undefined) requestData.forInstagramStory = contentData.forInstagramStory
+      if (contentData.forNaverBlogPost !== undefined) requestData.forNaverBlogPost = contentData.forNaverBlogPost
+      
+      if (contentData.alternativeTitleCount !== undefined) requestData.alternativeTitleCount = contentData.alternativeTitleCount
+      if (contentData.alternativeHashtagSetCount !== undefined) requestData.alternativeHashtagSetCount = contentData.alternativeHashtagSetCount
+      if (contentData.preferredAiModel) requestData.preferredAiModel = contentData.preferredAiModel
+      
+      console.log('📝 [API] SNS 요청 데이터:', {
+        ...requestData,
+        images: `${requestData.images.length}개 이미지`
+      })
+      
+      // 기본 유효성 검사
+      if (!requestData.platform) {
+        throw new Error('플랫폼은 필수입니다.')
+      }
+      
+      if (!requestData.title) {
+        throw new Error('제목은 필수입니다.')
+      }
+      
+      const response = await contentApi.post('/sns/generate', requestData, {
+        timeout: 30000 // 30초
+      })
+
+      console.log('✅ [API] SNS 콘텐츠 생성 응답:', response.data)
+      return formatSuccessResponse(response.data, 'SNS 게시물이 생성되었습니다.')
+    } catch (error) {
+      console.error('❌ [API] SNS 콘텐츠 생성 실패:', error)
+      return handleApiError(error)
     }
-    return mapping[platform] || 'INSTAGRAM'
   }
 
   /**
-   * 타겟 타입을 카테고리로 매핑
+   * 포스터 생성 (CON-020: AI 포스터 생성) - 이미지 처리 강화 및 상세 검증
+   * @param {Object} posterData - 포스터 생성 데이터
+   * @returns {Promise<Object>} 생성된 포스터
    */
-  mapTargetToCategory(targetType) {
-    const mapping = {
-      'new_menu': '메뉴소개',
-      'discount': '이벤트',
-      'store': '인테리어', 
-      'event': '이벤트'
+  async generatePoster(posterData) {
+    try {
+      console.log('🎯 [API] 포스터 생성 요청 받음:', posterData)
+      
+      // ✅ 1. 이미지 상세 분석 및 검증
+      console.log('📁 [API] 이미지 상세 분석 시작...')
+      console.log('📁 [API] posterData.images 타입:', typeof posterData.images)
+      console.log('📁 [API] posterData.images 배열 여부:', Array.isArray(posterData.images))
+      console.log('📁 [API] posterData.images 길이:', posterData.images?.length)
+      
+      let processedImages = []
+      
+      if (posterData.images && Array.isArray(posterData.images) && posterData.images.length > 0) {
+        console.log('📁 [API] 원본 이미지 배열 처리 시작...')
+        
+        // 각 이미지를 개별적으로 검증
+        posterData.images.forEach((img, index) => {
+          console.log(`📁 [API] 이미지 ${index + 1} 분석:`, {
+            type: typeof img,
+            isString: typeof img === 'string',
+            length: img?.length,
+            isNull: img === null,
+            isUndefined: img === undefined,
+            isEmpty: img === '',
+            isBase64: typeof img === 'string' && img.startsWith('data:image/'),
+            preview: typeof img === 'string' ? img.substring(0, 50) + '...' : 'Not string'
+          })
+        })
+        
+        // 유효한 이미지만 필터링 (더 엄격한 검증)
+        processedImages = posterData.images.filter((img, index) => {
+          const isValid = img && 
+                         typeof img === 'string' && 
+                         img.length > 100 && // 최소 길이 체크 (Base64는 보통 매우 길다)
+                         (img.startsWith('data:image/') || img.startsWith('http'))
+          
+          console.log(`📁 [API] 이미지 ${index + 1} 유효성:`, {
+            isValid,
+            reason: !img ? 'null/undefined' :
+                   typeof img !== 'string' ? 'not string' :
+                   img.length <= 100 ? 'too short' :
+                   !img.startsWith('data:image/') && !img.startsWith('http') ? 'invalid format' :
+                   'valid'
+          })
+          
+          return isValid
+        })
+        
+        console.log('📁 [API] 필터링 결과:', {
+          원본개수: posterData.images.length,
+          유효개수: processedImages.length,
+          제거된개수: posterData.images.length - processedImages.length
+        })
+        
+        if (processedImages.length === 0) {
+          console.error('❌ [API] 유효한 이미지가 없습니다!')
+          console.error('❌ [API] 원본 이미지 상태:', posterData.images.map((img, i) => ({
+            index: i,
+            type: typeof img,
+            length: img?.length,
+            preview: typeof img === 'string' ? img.substring(0, 30) : 'not string'
+          })))
+          
+          throw new Error('유효한 이미지가 없습니다. 이미지를 다시 선택해 주세요.')
+        }
+      } else {
+        console.warn('⚠️ [API] 이미지가 없거나 유효하지 않음!')
+        console.warn('⚠️ [API] posterData.images:', posterData.images)
+        processedImages = []
+      }
+      
+      // ✅ 2. 필수 필드 검증 강화
+      const validationErrors = []
+      
+      if (!posterData.title || posterData.title.trim() === '') {
+        validationErrors.push('제목은 필수입니다.')
+      }
+      
+      if (!posterData.targetAudience) {
+        validationErrors.push('홍보 대상은 필수입니다.')
+      }
+      
+      if (processedImages.length === 0) {
+        validationErrors.push('포스터 생성을 위해서는 최소 1개의 유효한 이미지가 필요합니다.')
+      }
+      
+      if (validationErrors.length > 0) {
+        console.error('❌ [API] 유효성 검사 실패:', validationErrors)
+        throw new Error(validationErrors.join(' '))
+      }
+      
+      // ✅ 3. 실제 전달받은 데이터만 사용 (백엔드 API 스펙에 맞춤)
+      const requestData = {}
+      
+      // 필수 필드들 (값이 있을 때만 추가)
+      if (posterData.storeId !== undefined && posterData.storeId !== null) {
+        requestData.storeId = posterData.storeId
+      }
+      
+      if (posterData.title) {
+        requestData.title = posterData.title.trim()
+      }
+      
+      if (posterData.targetAudience || posterData.targetType) {
+        requestData.targetAudience = posterData.targetAudience || posterData.targetType
+      }
+      
+      if (posterData.promotionStartDate) {
+        requestData.promotionStartDate = posterData.promotionStartDate
+      }
+      
+      if (posterData.promotionEndDate) {
+        requestData.promotionEndDate = posterData.promotionEndDate
+      }
+      
+      // 선택적 필드들 (값이 있을 때만 추가)
+      if (posterData.eventName) {
+        requestData.eventName = posterData.eventName
+      }
+      
+      if (posterData.imageStyle) {
+        requestData.imageStyle = posterData.imageStyle
+      }
+      
+      if (posterData.promotionType || posterData.targetType) {
+        requestData.promotionType = posterData.promotionType || posterData.targetType
+      }
+      
+      if (posterData.emotionIntensity) {
+        requestData.emotionIntensity = posterData.emotionIntensity
+      }
+      
+      // 이미지는 검증된 것만 포함
+      requestData.images = processedImages
+      
+      if (posterData.category) {
+        requestData.category = posterData.category
+      }
+      
+      if (posterData.requirement || posterData.requirements) {
+        requestData.requirement = posterData.requirement || posterData.requirements
+      }
+      
+      if (posterData.toneAndManner) {
+        requestData.toneAndManner = posterData.toneAndManner
+      }
+      
+      if (posterData.startDate) {
+        requestData.startDate = posterData.startDate
+      }
+      
+      if (posterData.endDate) {
+        requestData.endDate = posterData.endDate
+      }
+      
+      if (posterData.photoStyle) {
+        requestData.photoStyle = posterData.photoStyle
+      }
+      
+      if (posterData.targetAge) {
+        requestData.targetAge = posterData.targetAge
+      }
+      
+      console.log('📝 [API] 최종 요청 데이터 구성 완료:')
+      console.log('📝 [API] 제목:', requestData.title)
+      console.log('📝 [API] 홍보대상:', requestData.targetAudience)
+      console.log('📝 [API] 이미지개수:', requestData.images.length)
+      console.log('📝 [API] 첫번째이미지크기:', requestData.images[0]?.length, 'chars')
+      console.log('📝 [API] 매장ID:', requestData.storeId)
+      console.log('📝 [API] 타겟연령:', requestData.targetAge)
+      
+      // ✅ 4. 최종 요청 데이터 검증
+      if (!requestData.images || requestData.images.length === 0) {
+        throw new Error('처리된 이미지가 없습니다. 이미지 업로드를 다시 시도해 주세요.')
+      }
+      
+      // JSON 직렬화 테스트
+      try {
+        const testJson = JSON.stringify(requestData)
+        console.log('📝 [API] JSON 직렬화 테스트 성공, 크기:', Math.round(testJson.length / 1024), 'KB')
+      } catch (jsonError) {
+        console.error('❌ [API] JSON 직렬화 실패:', jsonError)
+        throw new Error('요청 데이터 직렬화에 실패했습니다.')
+      }
+      
+      console.log('🚀 [API] 백엔드 API 호출 시작:', '/poster/generate')
+      
+      // ✅ 5. 실제 백엔드 API 호출 (타임아웃 증가)
+      const response = await contentApi.post('/poster/generate', requestData, {
+        timeout: 60000, // 60초로 증가 (포스터 생성은 시간이 걸림)
+        headers: {
+          'Content-Type': 'application/json'
+        }
+      })
+
+      console.log('✅ [API] 포스터 생성 응답 수신:', {
+        status: response.status,
+        hasData: !!response.data,
+        dataType: typeof response.data
+      })
+      console.log('✅ [API] 응답 데이터:', response.data)
+      
+      // ✅ 6. 백엔드 응답 구조에 맞춰 처리
+      if (response.data && response.data.success !== false) {
+        return formatSuccessResponse(response.data, '홍보 포스터가 생성되었습니다.')
+      } else {
+        throw new Error(response.data?.message || '포스터 생성에 실패했습니다.')
+      }
+      
+    } catch (error) {
+      console.error('❌ [API] 포스터 생성 실패:', error)
+      
+      // ✅ 7. 백엔드 오류 상세 정보 추출 및 분석
+      if (error.response) {
+        console.error('❌ [API] HTTP 응답 오류:')
+        console.error('  - Status:', error.response.status)
+        console.error('  - Status Text:', error.response.statusText)
+        console.error('  - Headers:', error.response.headers)
+        console.error('  - Data:', JSON.stringify(error.response.data, null, 2))
+        
+        // 백엔드에서 반환하는 구체적인 오류 메시지 추출
+        let backendMessage = '서버 오류가 발생했습니다.'
+        
+        if (error.response.data) {
+          if (typeof error.response.data === 'string') {
+            backendMessage = error.response.data
+          } else if (error.response.data.message) {
+            backendMessage = error.response.data.message
+          } else if (error.response.data.error) {
+            backendMessage = error.response.data.error
+          } else if (error.response.data.detail) {
+            backendMessage = error.response.data.detail
+          }
+        }
+        
+        console.error('❌ [API] 백엔드 오류 메시지:', backendMessage)
+        
+        // 특정 오류 코드별 처리
+        if (error.response.status === 400) {
+          if (backendMessage.includes('이미지') || backendMessage.includes('image')) {
+            backendMessage = '이미지 처리 중 오류가 발생했습니다. 이미지를 다시 선택해 주세요.'
+          }
+        } else if (error.response.status === 413) {
+          backendMessage = '이미지 파일이 너무 큽니다. 더 작은 이미지를 선택해 주세요.'
+        } else if (error.response.status === 500) {
+          backendMessage = '서버에서 포스터 생성 중 오류가 발생했습니다. 잠시 후 다시 시도해 주세요.'
+        }
+        
+        // 유효성 검사 오류가 있다면 추출
+        if (error.response.data && error.response.data.errors) {
+          console.error('❌ [API] 유효성 검사 오류:', error.response.data.errors)
+          const validationMessages = Object.values(error.response.data.errors).flat()
+          if (validationMessages.length > 0) {
+            backendMessage = validationMessages.join(', ')
+          }
+        }
+        
+        return {
+          success: false,
+          message: backendMessage,
+          error: error.response.data,
+          statusCode: error.response.status
+        }
+      } else if (error.request) {
+        console.error('❌ [API] 네트워크 요청 오류:', error.request)
+        return {
+          success: false,
+          message: '서버에 연결할 수 없습니다. 네트워크 연결을 확인해 주세요.',
+          error: 'NETWORK_ERROR'
+        }
+      } else {
+        console.error('❌ [API] 일반 오류:', error.message)
+        return {
+          success: false,
+          message: error.message || '포스터 생성 중 예상치 못한 오류가 발생했습니다.',
+          error: 'UNKNOWN_ERROR'
+        }
+      }
     }
-    return mapping[targetType] || '메뉴소개'
   }
 
   /**
-   * 날짜 형식 변환 (YYYY-MM-DD -> LocalDate)
-   */
-  formatDate(dateString) {
-    if (!dateString) return null
-    // YYYY-MM-DD 형식이 LocalDate와 호환됨
-    return dateString
-  }
-
-  /**
-   * 사진 스타일 매핑
-   */
-  mapPhotoStyle(style) {
-    const mapping = {
-      'bright': '밝고 화사한',
-      'calm': '차분하고 세련된',
-      'vintage': '빈티지한',
-      'modern': '모던한',
-      'natural': '자연스러운'
-    }
-    return mapping[style] || '밝고 화사한'
-  }
-
-  /**
-   * SNS 게시물 저장
-   * @param {Object} saveData - 저장할 SNS 콘텐츠 정보
+   * SNS 콘텐츠 저장 (CON-010: SNS 게시물 저장)
+   * @param {Object} saveData - 저장할 콘텐츠 데이터
    * @returns {Promise<Object>} 저장 결과
    */
   async saveSnsContent(saveData) {
     try {
-      console.log('💾 SNS 콘텐츠 저장 요청:', saveData)
+      const requestData = {}
       
-      // 백엔드 SnsContentSaveRequest DTO에 맞는 구조로 변환
-      const requestData = {
-        title: saveData.title,
-        content: saveData.content,
-        hashtags: saveData.hashtags || [],
-        platform: this.mapPlatform(saveData.platform),
-        category: saveData.category || '메뉴소개',
-        // 백엔드 DTO에서 지원하는 필드들만 포함
-        eventName: saveData.eventName,
-        eventDate: saveData.eventDate,
-        status: saveData.status || 'DRAFT'
+      if (saveData.contentId) requestData.contentId = saveData.contentId
+      if (saveData.storeId !== undefined) requestData.storeId = saveData.storeId
+      if (saveData.platform) requestData.platform = saveData.platform
+      if (saveData.title) requestData.title = saveData.title
+      if (saveData.content) requestData.content = saveData.content
+      if (saveData.hashtags) requestData.hashtags = saveData.hashtags
+      if (saveData.images) requestData.images = saveData.images
+      if (saveData.finalTitle) requestData.finalTitle = saveData.finalTitle
+      if (saveData.finalContent) requestData.finalContent = saveData.finalContent
+      if (saveData.status) requestData.status = saveData.status
+      if (saveData.category) requestData.category = saveData.category
+      if (saveData.requirement) requestData.requirement = saveData.requirement
+      if (saveData.toneAndManner) requestData.toneAndManner = saveData.toneAndManner
+      if (saveData.emotionIntensity || saveData.emotionalIntensity) {
+        requestData.emotionIntensity = saveData.emotionIntensity || saveData.emotionalIntensity
       }
-
-      console.log('📤 저장 요청 데이터:', requestData)
-
+      if (saveData.eventName) requestData.eventName = saveData.eventName
+      if (saveData.startDate) requestData.startDate = saveData.startDate
+      if (saveData.endDate) requestData.endDate = saveData.endDate
+      if (saveData.promotionalType) requestData.promotionalType = saveData.promotionalType
+      if (saveData.eventDate) requestData.eventDate = saveData.eventDate
+      
       const response = await contentApi.post('/sns/save', requestData)
-
       return formatSuccessResponse(response.data.data, 'SNS 게시물이 저장되었습니다.')
     } catch (error) {
-      console.error('❌ SNS 콘텐츠 저장 실패:', error)
       return handleApiError(error)
     }
   }
 
   /**
-   * 콘텐츠 목록 조회
-   * @param {Object} filters - 필터 조건
-   * @returns {Promise<Object>} 콘텐츠 목록
+   * 포스터 저장 (CON-015: 포스터 저장)
+   * @param {Object} saveData - 저장할 포스터 데이터
+   * @returns {Promise<Object>} 저장 결과
    */
-  async getContentList(filters = {}) {
+  async savePoster(saveData) {
     try {
-      const params = new URLSearchParams()
+      const requestData = {}
       
-      if (filters.contentType) params.append('contentType', filters.contentType)
-      if (filters.platform) params.append('platform', filters.platform)
-      if (filters.period) params.append('period', filters.period)
-      if (filters.sortBy) params.append('sortBy', filters.sortBy)
+      if (saveData.contentId) requestData.contentId = saveData.contentId
+      if (saveData.storeId !== undefined) requestData.storeId = saveData.storeId
+      if (saveData.title) requestData.title = saveData.title
+      if (saveData.content) requestData.content = saveData.content
+      if (saveData.images) requestData.images = saveData.images
+      if (saveData.status) requestData.status = saveData.status
+      if (saveData.category) requestData.category = saveData.category
+      if (saveData.requirement) requestData.requirement = saveData.requirement
+      if (saveData.toneAndManner) requestData.toneAndManner = saveData.toneAndManner
+      if (saveData.emotionIntensity) requestData.emotionIntensity = saveData.emotionIntensity
+      if (saveData.eventName) requestData.eventName = saveData.eventName
+      if (saveData.startDate) requestData.startDate = saveData.startDate
+      if (saveData.endDate) requestData.endDate = saveData.endDate
+      if (saveData.photoStyle) requestData.photoStyle = saveData.photoStyle
+      if (saveData.targetAudience) requestData.targetAudience = saveData.targetAudience
+      if (saveData.promotionType) requestData.promotionType = saveData.promotionType
+      if (saveData.imageStyle) requestData.imageStyle = saveData.imageStyle
+      if (saveData.promotionStartDate) requestData.promotionStartDate = saveData.promotionStartDate
+      if (saveData.promotionEndDate) requestData.promotionEndDate = saveData.promotionEndDate
       
-      const response = await contentApi.get(`/list?${params.toString()}`)
-      
-      return formatSuccessResponse(response.data.data, '콘텐츠 목록을 조회했습니다.')
+      const response = await contentApi.post('/poster/save', requestData)
+      return formatSuccessResponse(response.data.data, '포스터가 저장되었습니다.')
+    } catch (error) {
+      return handleApiError(error)
+    }
+  }
+
+  /**
+   * 통합 콘텐츠 생성 (타입에 따라 SNS 또는 포스터 생성)
+   * @param {Object} contentData - 콘텐츠 생성 데이터
+   * @returns {Promise<Object>} 생성 결과
+   */
+  async generateContent(contentData) {
+    console.log('🎯 [API] 통합 콘텐츠 생성:', contentData)
+    
+    if (contentData.contentType === 'poster' || contentData.type === 'poster') {
+      return await this.generatePoster(contentData)
+    } else {
+      return await this.generateSnsContent(contentData)
+    }
+  }
+
+  /**
+   * 진행 중인 콘텐츠 조회
+   * @param {string} period - 조회 기간
+   * @returns {Promise<Object>} 진행 중인 콘텐츠 목록
+   */
+  async getOngoingContents(period = 'month') {
+    try {
+      const response = await contentApi.get(`/ongoing?period=${period}`)
+
+      return formatSuccessResponse(response.data.data, '진행 중인 콘텐츠를 조회했습니다.')
     } catch (error) {
-      console.error('❌ 콘텐츠 목록 조회 실패:', error)
       return handleApiError(error)
     }
   }
@@ -179,29 +677,200 @@ class ContentService {
   async getContentDetail(contentId) {
     try {
       const response = await contentApi.get(`/${contentId}`)
-      
+
       return formatSuccessResponse(response.data.data, '콘텐츠 상세 정보를 조회했습니다.')
     } catch (error) {
-      console.error('❌ 콘텐츠 상세 조회 실패:', error)
       return handleApiError(error)
     }
   }
 
   /**
-   * 콘텐츠 삭제
+   * 콘텐츠 수정 (CON-024: 콘텐츠 수정)
+   * @param {number} contentId - 콘텐츠 ID
+   * @param {Object} updateData - 수정할 콘텐츠 정보
+   * @returns {Promise<Object>} 수정 결과
+   */
+  async updateContent(contentId, updateData) {
+    try {
+      const requestData = {}
+      
+      if (updateData.title) requestData.title = updateData.title
+      if (updateData.content) requestData.content = updateData.content
+      if (updateData.hashtags) requestData.hashtags = updateData.hashtags
+      if (updateData.startDate) requestData.startDate = updateData.startDate
+      if (updateData.endDate) requestData.endDate = updateData.endDate
+      if (updateData.status) requestData.status = updateData.status
+      if (updateData.category) requestData.category = updateData.category
+      if (updateData.requirement) requestData.requirement = updateData.requirement
+      if (updateData.toneAndManner) requestData.toneAndManner = updateData.toneAndManner
+      if (updateData.emotionIntensity) requestData.emotionIntensity = updateData.emotionIntensity
+      if (updateData.eventName) requestData.eventName = updateData.eventName
+      if (updateData.images) requestData.images = updateData.images
+      
+      const response = await contentApi.put(`/${contentId}`, requestData)
+
+      return formatSuccessResponse(response.data.data, '콘텐츠가 수정되었습니다.')
+    } catch (error) {
+      return handleApiError(error)
+    }
+  }
+
+  /**
+   * 콘텐츠 삭제 (CON-025: 콘텐츠 삭제)
    * @param {number} contentId - 콘텐츠 ID
    * @returns {Promise<Object>} 삭제 결과
    */
   async deleteContent(contentId) {
     try {
-      const response = await contentApi.delete(`/${contentId}`)
-      
+      await contentApi.delete(`/${contentId}`)
+
       return formatSuccessResponse(null, '콘텐츠가 삭제되었습니다.')
     } catch (error) {
-      console.error('❌ 콘텐츠 삭제 실패:', error)
+      return handleApiError(error)
+    }
+  }
+
+  /**
+   * 타겟 타입을 카테고리로 매핑
+   * @param {string} targetType - 타겟 타입
+   * @returns {string} 매핑된 카테고리
+   */
+  mapTargetToCategory(targetType) {
+    const mapping = {
+      'new_menu': '메뉴소개',
+      'discount': '이벤트',
+      'store': '인테리어', 
+      'event': '이벤트',
+      'menu': '메뉴소개',
+      'service': '서비스'
+    }
+    return mapping[targetType] || '이벤트'
+  }
+
+  /**
+   * 콘텐츠 검색 (추가 기능)
+   * @param {string} query - 검색어
+   * @param {Object} filters - 필터 조건
+   * @returns {Promise<Object>} 검색 결과
+   */
+  async searchContents(query, filters = {}) {
+    try {
+      const queryParams = new URLSearchParams()
+      if (query) queryParams.append('search', query)
+      if (filters.contentType) queryParams.append('contentType', filters.contentType)
+      if (filters.platform) queryParams.append('platform', filters.platform)
+      if (filters.period) queryParams.append('period', filters.period)
+      if (filters.sortBy) queryParams.append('sortBy', filters.sortBy)
+      if (filters.page) queryParams.append('page', filters.page)
+      if (filters.size) queryParams.append('size', filters.size)
+
+      const queryString = queryParams.toString()
+      const url = queryString ? `/search?${queryString}` : '/search'
+      
+      const response = await contentApi.get(url)
+      return formatSuccessResponse(response.data.data, '콘텐츠 검색을 완료했습니다.')
+    } catch (error) {
+      return handleApiError(error)
+    }
+  }
+
+  /**
+   * 콘텐츠 통계 조회 (추가 기능)
+   * @param {Object} filters - 필터 조건
+   * @returns {Promise<Object>} 통계 데이터
+   */
+  async getContentStats(filters = {}) {
+    try {
+      const queryParams = new URLSearchParams()
+      if (filters.period) queryParams.append('period', filters.period)
+      if (filters.storeId) queryParams.append('storeId', filters.storeId)
+
+      const queryString = queryParams.toString()
+      const url = queryString ? `/stats?${queryString}` : '/stats'
+      
+      const response = await contentApi.get(url)
+      return formatSuccessResponse(response.data.data, '콘텐츠 통계를 조회했습니다.')
+    } catch (error) {
+      return handleApiError(error)
+    }
+  }
+
+  /**
+   * 콘텐츠 복제 (추가 기능)
+   * @param {number} contentId - 복제할 콘텐츠 ID
+   * @returns {Promise<Object>} 복제 결과
+   */
+  async duplicateContent(contentId) {
+    try {
+      const response = await contentApi.post(`/${contentId}/duplicate`)
+      return formatSuccessResponse(response.data.data, '콘텐츠가 복제되었습니다.')
+    } catch (error) {
+      return handleApiError(error)
+    }
+  }
+
+  /**
+   * 콘텐츠 상태 변경 (추가 기능)
+   * @param {number} contentId - 콘텐츠 ID
+   * @param {string} status - 변경할 상태
+   * @returns {Promise<Object>} 상태 변경 결과
+   */
+  async updateContentStatus(contentId, status) {
+    try {
+      const response = await contentApi.patch(`/${contentId}/status`, { status })
+      return formatSuccessResponse(response.data.data, `콘텐츠 상태가 ${status}로 변경되었습니다.`)
+    } catch (error) {
+      return handleApiError(error)
+    }
+  }
+
+  /**
+   * 콘텐츠 즐겨찾기 토글 (추가 기능)
+   * @param {number} contentId - 콘텐츠 ID
+   * @returns {Promise<Object>} 즐겨찾기 토글 결과
+   */
+  async toggleContentFavorite(contentId) {
+    try {
+      const response = await contentApi.post(`/${contentId}/favorite`)
+      return formatSuccessResponse(response.data.data, '즐겨찾기가 변경되었습니다.')
+    } catch (error) {
+      return handleApiError(error)
+    }
+  }
+
+  /**
+   * 콘텐츠 템플릿 목록 조회 (추가 기능)
+   * @param {string} type - 템플릿 타입
+   * @returns {Promise<Object>} 템플릿 목록
+   */
+  async getContentTemplates(type = 'all') {
+    try {
+      const response = await contentApi.get(`/templates?type=${type}`)
+      return formatSuccessResponse(response.data.data, '콘텐츠 템플릿을 조회했습니다.')
+    } catch (error) {
+      return handleApiError(error)
+    }
+  }
+
+  /**
+   * 템플릿으로 콘텐츠 생성 (추가 기능)
+   * @param {number} templateId - 템플릿 ID
+   * @param {Object} customData - 커스터마이징 데이터
+   * @returns {Promise<Object>} 생성 결과
+   */
+  async generateFromTemplate(templateId, customData = {}) {
+    try {
+      const response = await contentApi.post(`/templates/${templateId}/generate`, customData)
+      return formatSuccessResponse(response.data.data, '템플릿으로 콘텐츠가 생성되었습니다.')
+    } catch (error) {
       return handleApiError(error)
     }
   }
 }
 
-export default new ContentService()
\ No newline at end of file
+// 서비스 인스턴스 생성 및 내보내기
+const contentService = new ContentService()
+
+// API 인스턴스와 유틸리티 함수도 함께 내보내기
+export { contentApi, handleApiError, formatSuccessResponse }
+export default contentService
\ No newline at end of file
diff --git a/src/store/content.js b/src/store/content.js
index 176e852..0694d74 100644
--- a/src/store/content.js
+++ b/src/store/content.js
@@ -1,56 +1,73 @@
-//* src/store/content.js
+//* src/store/content.js - 두 파일 완전 통합 버전 (Part 1)
 import { defineStore } from 'pinia'
-import ContentService from '@/services/content.js'
-import { PLATFORM_SPECS, PLATFORM_LABELS } from '@/utils/constants'
+import { ref, computed, readonly } from 'vue'
+import contentService from '@/services/content'
+import { useAuthStore } from '@/store/auth'
 
-/**
- * 콘텐츠 관련 상태 관리
- */
-export const useContentStore = defineStore('content', {
-  state: () => ({
-    // 콘텐츠 목록
-    contentList: [],
-    totalCount: 0,
+// constants가 없는 경우를 위한 기본값
+const PLATFORM_SPECS = {
+  INSTAGRAM: { name: '인스타그램', maxLength: 2200 },
+  NAVER_BLOG: { name: '네이버 블로그', maxLength: 10000 },
+  POSTER: { name: '포스터', maxLength: 500 }
+}
+
+const PLATFORM_LABELS = {
+  INSTAGRAM: '인스타그램',
+  NAVER_BLOG: '네이버 블로그',
+  POSTER: '포스터'
+}
+
+export const useContentStore = defineStore('content', () => {
+  // ===== 상태 관리 =====
+  // 기본 상태
+  const contentList = ref([])
+  const contents = ref([]) // ContentManagementView에서 사용하는 속성
+  const ongoingContents = ref([])
+  const selectedContent = ref(null)
+  const generatedContent = ref(null)
+  const totalCount = ref(0)
+  
+  // 로딩 상태
+  const isLoading = ref(false)
+  const loading = ref(false)
+  const generating = ref(false)
+  
+  // 필터 상태
+  const filters = ref({
+    contentType: '',
+    platform: '',
+    period: '',
+    sortBy: 'latest'
+  })
+  
+  // 페이지네이션
+  const pagination = ref({
+    page: 1,
+    itemsPerPage: 10
+  })
+
+  // ===== Computed 속성들 =====
+  const contentCount = computed(() => contentList.value.length)
+  const ongoingContentCount = computed(() => ongoingContents.value.length)
+  
+  /**
+   * 필터링된 콘텐츠 목록
+   */
+  const filteredContents = computed(() => {
+    let filtered = [...contentList.value]
     
-    // 선택된 콘텐츠
-    selectedContent: null,
-    
-    // 로딩 상태
-    loading: false,
-    generating: false,
-    
-    // 필터 상태
-    filters: {
-      contentType: '',
-      platform: '',
-      period: '',
-      sortBy: 'createdAt_desc'
-    },
-    
-    // 페이지네이션
-    pagination: {
-      page: 1,
-      itemsPerPage: 10
+    if (filters.value.contentType) {
+      filtered = filtered.filter(content => content.type === filters.value.contentType)
     }
-  }),
-
-  getters: {
-    /**
-     * 필터링된 콘텐츠 목록
-     */
-    filteredContents: (state) => {
-      let filtered = [...state.contentList]
-      
-      if (state.filters.contentType) {
-        filtered = filtered.filter(content => content.type === state.filters.contentType)
-      }
-      
-      if (state.filters.platform) {
-        filtered = filtered.filter(content => content.platform === state.filters.platform)
-      }
-      
-      // 정렬
-      const [field, order] = state.filters.sortBy.split('_')
+    
+    if (filters.value.platform) {
+      filtered = filtered.filter(content => content.platform === filters.value.platform)
+    }
+    
+    // 정렬
+    const sortBy = filters.value.sortBy || 'latest'
+    if (sortBy.includes('_')) {
+      const [field, order] = sortBy.split('_')
       filtered.sort((a, b) => {
         let aValue = a[field]
         let bValue = b[field]
@@ -66,242 +83,996 @@ export const useContentStore = defineStore('content', {
           return aValue > bValue ? 1 : -1
         }
       })
-      
-      return filtered
-    },
-
-    /**
-     * 페이지네이션된 콘텐츠 목록
-     */
-    paginatedContents: (state) => {
-      const start = (state.pagination.page - 1) * state.pagination.itemsPerPage
-      const end = start + state.pagination.itemsPerPage
-      return state.filteredContents.slice(start, end)
-    },
-
-    /**
-     * 총 페이지 수
-     */
-    totalPages: (state) => {
-      return Math.ceil(state.filteredContents.length / state.pagination.itemsPerPage)
+    } else if (sortBy === 'latest') {
+      filtered.sort((a, b) => new Date(b.createdAt) - new Date(a.createdAt))
     }
-  },
+    
+    return filtered
+  })
 
-  actions: {
-    /**
-     * 콘텐츠 생성 (AI 기반)
-     */
-    async generateContent(contentData) {
-      this.generating = true
+  /**
+   * 페이지네이션된 콘텐츠 목록
+   */
+  const paginatedContents = computed(() => {
+    const start = (pagination.value.page - 1) * pagination.value.itemsPerPage
+    const end = start + pagination.value.itemsPerPage
+    return filteredContents.value.slice(start, end)
+  })
+
+  /**
+   * 총 페이지 수
+   */
+  const totalPages = computed(() => {
+    return Math.ceil(filteredContents.value.length / pagination.value.itemsPerPage)
+  })
+
+  // ===== 매장 정보 조회 함수 (공통 유틸리티) =====
+  const getStoreId = async () => {
+    try {
+      const userInfo = useAuthStore().user
+      console.log('사용자 정보:', userInfo)
       
-      try {
-        console.log('🎯 콘텐츠 생성 시작:', contentData)
-        
-        // 백엔드 DTO에 맞는 데이터 구조로 변환
-        const requestData = {
-          storeId: 1, // 현재는 하드코딩, 추후 로그인한 사용자의 매장 ID 사용
-          storeName: '테스트 매장', // 추후 실제 매장 정보 사용
-          storeType: '음식점', // 추후 실제 매장 업종 사용
-          platform: contentData.platform,
-          title: contentData.title,
-          category: contentData.category || this.mapTargetToCategory(contentData.targetType),
-          requirement: contentData.requirements || '',
-          target: contentData.targetType || '일반 고객',
-          contentType: 'SNS 게시물',
-          eventName: contentData.eventName,
-          startDate: contentData.startDate,
-          endDate: contentData.endDate,
-          images: contentData.images || [],
-          photoStyle: '밝고 화사한',
-          includeHashtags: true,
-          includeEmojis: true,
-          includeCallToAction: true,
-          includeLocationInfo: false
-        }
-        
-        const result = await ContentService.generateSnsContent(requestData)
-        
-        if (result.success) {
-          console.log('✅ 콘텐츠 생성 성공:', result.data)
-          return result.data
-        } else {
-          throw new Error(result.message || '콘텐츠 생성에 실패했습니다.')
-        }
-      } catch (error) {
-        console.error('❌ 콘텐츠 생성 실패:', error)
-        throw error
-      } finally {
-        this.generating = false
-      }
-    },
-
-    /**
-     * 타겟 타입을 카테고리로 매핑
-     */
-    mapTargetToCategory(targetType) {
-      const mapping = {
-        'new_menu': '메뉴소개',
-        'discount': '이벤트',
-        'store': '인테리어', 
-        'event': '이벤트'
-      }
-      return mapping[targetType] || '메뉴소개'
-    },
-
-    /**
-     * 플랫폼별 특성 조회
-     */
-    getPlatformSpec(platform) {
-      return PLATFORM_SPECS[platform] || null
-    },
-
-    /**
-     * 플랫폼 유효성 검사
-     */
-    validatePlatform(platform) {
-      return Object.keys(PLATFORM_SPECS).includes(platform)
-    },
-
-    /**
-     * 콘텐츠 저장
-     */
-    async saveContent(contentData) {
-      this.loading = true
+      // 매장 정보 API 호출
+      const storeApiUrl = (window.__runtime_config__ && window.__runtime_config__.STORE_URL) 
+        ? window.__runtime_config__.STORE_URL 
+        : 'http://localhost:8082/api/store'
       
-      try {
-        // 백엔드 DTO에 맞는 형식으로 데이터 정제
-        const saveData = {
-          title: contentData.title,
-          content: contentData.content,
-          hashtags: contentData.hashtags || [],
-          platform: contentData.platform, // 이미 백엔드 형식 (INSTAGRAM, NAVER_BLOG 등)
-          category: contentData.category || '메뉴소개',
-          eventName: contentData.eventName,
-          eventDate: contentData.eventDate,
-          status: contentData.status || 'DRAFT'
-        }
-        
-        const result = await ContentService.saveSnsContent(saveData)
-        
-        if (result.success) {
-          // 목록 새로고침
-          await this.fetchContentList()
-          return result.data
-        } else {
-          throw new Error(result.message || '콘텐츠 저장에 실패했습니다.')
-        }
-      } catch (error) {
-        console.error('❌ 콘텐츠 저장 실패:', error)
-        throw error
-      } finally {
-        this.loading = false
-      }
-    },
-
-    /**
-     * 콘텐츠 목록 조회
-     */
-    async fetchContentList() {
-      this.loading = true
+      console.log('매장 API URL:', storeApiUrl)
       
-      try {
-        const result = await ContentService.getContentList(this.filters)
-        
-        if (result.success) {
-          this.contentList = result.data || []
-          this.totalCount = this.contentList.length
-        } else {
-          throw new Error(result.message || '콘텐츠 목록 조회에 실패했습니다.')
+      const token = localStorage.getItem('accessToken') || localStorage.getItem('auth_token') || localStorage.getItem('token')
+      const storeResponse = await fetch(`${storeApiUrl}`, {
+        headers: {
+          'Authorization': `Bearer ${token}`,
+          'Content-Type': 'application/json'
         }
-      } catch (error) {
-        console.error('❌ 콘텐츠 목록 조회 실패:', error)
-        this.contentList = []
-        this.totalCount = 0
-      } finally {
-        this.loading = false
-      }
-    },
-
-    /**
-     * 콘텐츠 상세 조회
-     */
-    async fetchContentDetail(contentId) {
-      this.loading = true
+      })
       
-      try {
-        const result = await ContentService.getContentDetail(contentId)
-        
-        if (result.success) {
-          this.selectedContent = result.data
-          return result.data
-        } else {
-          throw new Error(result.message || '콘텐츠 상세 조회에 실패했습니다.')
-        }
-      } catch (error) {
-        console.error('❌ 콘텐츠 상세 조회 실패:', error)
-        throw error
-      } finally {
-        this.loading = false
-      }
-    },
-
-    /**
-     * 콘텐츠 삭제
-     */
-    async deleteContent(contentId) {
-      this.loading = true
-      
-      try {
-        const result = await ContentService.deleteContent(contentId)
-        
-        if (result.success) {
-          // 목록에서 제거
-          this.contentList = this.contentList.filter(content => content.id !== contentId)
-          this.totalCount = this.contentList.length
-          return true
-        } else {
-          throw new Error(result.message || '콘텐츠 삭제에 실패했습니다.')
-        }
-      } catch (error) {
-        console.error('❌ 콘텐츠 삭제 실패:', error)
-        throw error
-      } finally {
-        this.loading = false
-      }
-    },
-
-    /**
-     * 필터 설정
-     */
-    setFilters(newFilters) {
-      this.filters = { ...this.filters, ...newFilters }
-      this.pagination.page = 1 // 필터 변경 시 첫 페이지로
-    },
-
-    /**
-     * 페이지네이션 설정
-     */
-    setPagination(newPagination) {
-      this.pagination = { ...this.pagination, ...newPagination }
-    },
-
-    /**
-     * 상태 초기화
-     */
-    reset() {
-      this.contentList = []
-      this.selectedContent = null
-      this.totalCount = 0
-      this.filters = {
-        contentType: '',
-        platform: '',
-        period: '',
-        sortBy: 'createdAt_desc'
-      }
-      this.pagination = {
-        page: 1,
-        itemsPerPage: 10
+      if (storeResponse.ok) {
+        const storeData = await storeResponse.json()
+        const storeId = storeData.data?.storeId
+        console.log('✅ 매장 정보 조회 성공, storeId:', storeId)
+        return storeId
+      } else {
+        throw new Error(`매장 정보 조회 실패: ${storeResponse.status}`)
       }
+    } catch (error) {
+      console.error('❌ 매장 정보 조회 실패:', error)
+      throw new Error('매장 정보를 조회할 수 없습니다.')
     }
   }
+
+  // ===== 콘텐츠 목록 조회 =====
+  /**
+   * 콘텐츠 목록 로딩 (ContentManagementView에서 사용)
+   */
+  const loadContents = async (requestFilters = {}) => {
+    console.log('=== 콘텐츠 목록 조회 시작 ===')
+    isLoading.value = true
+    loading.value = true
+    
+    try {
+      // 1단계: 매장 정보 조회하여 실제 storeId 가져오기
+      const storeId = await getStoreId()
+      
+      if (!storeId) {
+        throw new Error('매장 ID를 찾을 수 없습니다.')
+      }
+      
+      console.log('조회된 storeId:', storeId)
+
+      // 2단계: 조회된 storeId로 콘텐츠 목록 조회
+      const apiFilters = {
+        platform: requestFilters.platform || filters.value.platform || null,
+        storeId: storeId,
+        sortBy: requestFilters.sortBy || filters.value.sortBy || 'latest'
+      }
+      
+      console.log('API 요청 필터:', apiFilters)
+      
+      const result = await contentService.getContents(apiFilters)
+      
+      console.log('🔍 contentService.getContents 결과:', result)
+      console.log('🔍 result.success:', result.success)
+      console.log('🔍 result.data:', result.data)
+      console.log('🔍 result.data 타입:', typeof result.data)
+      console.log('🔍 result.data 길이:', result.data?.length)
+
+      if (result.success) {
+        const responseData = result.data || []
+        contents.value = responseData
+        contentList.value = responseData
+        totalCount.value = responseData.length
+        console.log('✅ 콘텐츠 로딩 성공:', contents.value.length, '개')
+        return { success: true }
+      } else {
+        console.error('❌ 콘텐츠 로딩 실패:', result.error)
+        contents.value = []
+        contentList.value = []
+        totalCount.value = 0
+        return { success: false, error: result.error }
+      }
+    } catch (error) {
+      console.error('❌ 콘텐츠 로딩 실패:', error)
+      contents.value = []
+      contentList.value = []
+      totalCount.value = 0
+      return { success: false, error: error.message || '네트워크 오류가 발생했습니다.' }
+    } finally {
+      isLoading.value = false
+      loading.value = false
+    }
+  }
+
+  /**
+   * 콘텐츠 목록 조회 (기존 호환성 유지)
+   */
+  const fetchContentList = async (requestFilters = {}) => {
+    console.log('📋 [STORE] fetchContentList 호출:', requestFilters)
+    return await loadContents(requestFilters)
+  }
+
+  // ===== AI 콘텐츠 생성 =====
+  /**
+   * SNS 콘텐츠 생성 (API 설계서 기준) - 이미지 디버깅 강화
+   */
+  const generateSnsContent = async (contentData) => {
+    generating.value = true
+    
+    try {
+      console.log('🎯 [STORE] SNS 콘텐츠 생성 요청:', contentData)
+      console.log('📁 [STORE] SNS 이미지 확인:', {
+        hasImages: !!contentData.images,
+        imageCount: contentData.images?.length || 0,
+        imageTypes: contentData.images?.map(img => typeof img) || [],
+        imageSizes: contentData.images?.map(img => img?.length || 'unknown') || []
+      })
+      
+      // 매장 ID 조회 (필요한 경우)
+      let storeId = contentData.storeId
+      if (!storeId) {
+        try {
+          storeId = await getStoreId()
+        } catch (error) {
+          console.warn('⚠️ 매장 ID 조회 실패, 기본값 사용:', error)
+          storeId = 1
+        }
+      }
+      
+      // SnsContentCreateRequest 구조에 맞게 데이터 변환
+      const requestData = {
+        storeId: storeId,
+        storeName: contentData.storeName || '',
+        storeType: contentData.storeType || '',
+        platform: contentData.platform || 'INSTAGRAM',
+        title: contentData.title || 'SNS 게시물',
+        category: contentData.category || '메뉴소개',
+        requirement: contentData.requirement || contentData.requirements || 'SNS 게시물을 생성해주세요',
+        target: contentData.target || contentData.targetAudience || '',
+        contentType: contentData.contentType || 'SNS 게시물',
+        eventName: contentData.eventName || '',
+        startDate: contentData.startDate,
+        endDate: contentData.endDate,
+        images: contentData.images || [],
+        photoStyle: contentData.photoStyle || '밝고 화사한',
+        targetAge: contentData.targetAge || '20대',
+        toneAndManner: contentData.toneAndManner || '친근함',
+        emotionalIntensity: contentData.emotionalIntensity || contentData.emotionIntensity || '보통',
+        promotionalType: contentData.promotionalType || contentData.promotionType || '',
+        eventDate: contentData.eventDate,
+        hashtagStyle: contentData.hashtagStyle || '',
+        hashtagCount: contentData.hashtagCount || 10,
+        contentLength: contentData.contentLength || '보통',
+        includeHashtags: contentData.includeHashtags !== false,
+        includeEmojis: contentData.includeEmojis !== false,
+        includeEmoji: contentData.includeEmoji !== false,
+        includeCallToAction: contentData.includeCallToAction !== false,
+        includeLocation: contentData.includeLocation || false,
+        forInstagramStory: contentData.forInstagramStory || false,
+        forNaverBlogPost: contentData.forNaverBlogPost || false,
+        alternativeTitleCount: contentData.alternativeTitleCount || 3,
+        alternativeHashtagSetCount: contentData.alternativeHashtagSetCount || 2,
+        preferredAiModel: contentData.preferredAiModel || ''
+      }
+      
+      console.log('📤 [STORE] SNS 변환된 요청 데이터:', {
+        ...requestData,
+        images: `${requestData.images.length}개 이미지`
+      })
+      
+      const result = await contentService.generateSnsContent(requestData)
+      
+      if (result.success) {
+        console.log('✅ [STORE] SNS 콘텐츠 생성 성공:', result.data)
+        generatedContent.value = result.data
+        
+        return {
+          success: true,
+          content: result.data.content || '콘텐츠가 생성되었습니다.',
+          hashtags: result.data.hashtags || [],
+          data: result.data
+        }
+      } else {
+        console.error('❌ [STORE] SNS 콘텐츠 생성 실패:', result.message)
+        return {
+          success: false,
+          message: result.message || 'SNS 콘텐츠 생성에 실패했습니다.',
+          error: result.error
+        }
+      }
+      
+    } catch (error) {
+      console.error('❌ [STORE] SNS 콘텐츠 생성 예외:', error)
+      return {
+        success: false,
+        message: error.message || '네트워크 오류가 발생했습니다.',
+        error: error
+      }
+    } finally {
+      generating.value = false
+    }
+  }
+  //* src/store/content.js - 두 파일 완전 통합 버전 (Part 2)
+  /**
+   * 포스터 생성 (API 설계서 기준) - 이미지 디버깅 대폭 강화
+   */
+  const generatePoster = async (posterData) => {
+    generating.value = true
+    
+    try {
+      console.log('🎯 [STORE] 포스터 생성 요청 받음:', posterData)
+      console.log('📁 [STORE] 포스터 이미지 상세 분석:', {
+        hasImages: !!posterData.images,
+        imageCount: posterData.images?.length || 0,
+        imageArray: Array.isArray(posterData.images),
+        firstImageInfo: posterData.images?.[0] ? {
+          type: typeof posterData.images[0],
+          length: posterData.images[0]?.length || 'unknown',
+          isBase64: posterData.images[0]?.startsWith?.('data:image/') || false,
+          preview: posterData.images[0]?.substring(0, 50) + '...'
+        } : null
+      })
+      
+      // 매장 ID 조회 (필요한 경우)
+      let storeId = posterData.storeId
+      if (storeId === undefined || storeId === null) {
+        try {
+          storeId = await getStoreId()
+        } catch (error) {
+          console.warn('⚠️ 매장 ID 조회 실패, 기본값 사용:', error)
+          storeId = 1
+        }
+      }
+      
+      // ✅ 실제 전달받은 데이터만 사용 (기본값 완전 제거)
+      const requestData = {}
+      
+      // 조건부로 필드 추가 (값이 있을 때만)
+      if (storeId !== undefined) {
+        requestData.storeId = storeId
+        console.log('📝 [STORE] storeId 추가:', requestData.storeId)
+      }
+      
+      if (posterData.title) {
+        requestData.title = posterData.title
+        console.log('📝 [STORE] title 추가:', requestData.title)
+      }
+      
+      if (posterData.targetAudience) {
+        requestData.targetAudience = posterData.targetAudience
+        console.log('📝 [STORE] targetAudience 추가:', requestData.targetAudience)
+      } else if (posterData.targetType) {
+        requestData.targetAudience = posterData.targetType
+        console.log('📝 [STORE] targetAudience 추가 (from targetType):', requestData.targetAudience)
+      }
+      
+      if (posterData.promotionStartDate) {
+        requestData.promotionStartDate = posterData.promotionStartDate
+        console.log('📝 [STORE] promotionStartDate 추가:', requestData.promotionStartDate)
+      }
+      
+      if (posterData.promotionEndDate) {
+        requestData.promotionEndDate = posterData.promotionEndDate
+        console.log('📝 [STORE] promotionEndDate 추가:', requestData.promotionEndDate)
+      }
+      
+      // 선택적 필드들
+      if (posterData.eventName) {
+        requestData.eventName = posterData.eventName
+        console.log('📝 [STORE] eventName 추가:', requestData.eventName)
+      }
+      
+      if (posterData.imageStyle) requestData.imageStyle = posterData.imageStyle
+      if (posterData.promotionType) requestData.promotionType = posterData.promotionType
+      if (posterData.emotionIntensity) requestData.emotionIntensity = posterData.emotionIntensity
+      if (posterData.category) requestData.category = posterData.category
+      if (posterData.requirement || posterData.requirements) {
+        requestData.requirement = posterData.requirement || posterData.requirements
+      }
+      if (posterData.toneAndManner) requestData.toneAndManner = posterData.toneAndManner
+      if (posterData.startDate) requestData.startDate = posterData.startDate
+      if (posterData.endDate) requestData.endDate = posterData.endDate
+      if (posterData.photoStyle) requestData.photoStyle = posterData.photoStyle
+      if (posterData.targetAge) {
+        requestData.targetAge = posterData.targetAge
+        console.log('📝 [STORE] targetAge 추가:', requestData.targetAge)
+      }
+      
+      // ✅ 이미지 처리 - 가장 중요한 부분
+      console.log('📁 [STORE] 이미지 처리 시작...')
+      if (posterData.images && Array.isArray(posterData.images) && posterData.images.length > 0) {
+        console.log('📁 [STORE] 원본 이미지 배열:', posterData.images.length, '개')
+        
+        // 유효한 이미지만 필터링
+        const validImages = posterData.images.filter(img => {
+          const isValid = img && typeof img === 'string' && img.length > 0
+          console.log('📁 [STORE] 이미지 유효성 검사:', { 
+            isValid, 
+            type: typeof img, 
+            length: img?.length,
+            isBase64: img?.startsWith?.('data:image/')
+          })
+          return isValid
+        })
+        
+        requestData.images = validImages
+        console.log('📁 [STORE] 필터링된 이미지:', validImages.length, '개')
+        console.log('📁 [STORE] 첫 번째 이미지 샘플:', validImages[0]?.substring(0, 100) + '...')
+      } else {
+        requestData.images = []
+        console.warn('📁 [STORE] ⚠️  이미지가 없거나 유효하지 않음!')
+        console.warn('📁 [STORE] posterData.images:', posterData.images)
+      }
+      
+      console.log('🔍 [STORE] 최종 요청 데이터 확인:')
+      console.log('  - 제목:', requestData.title)
+      console.log('  - 홍보 대상:', requestData.targetAudience)
+      console.log('  - 타겟 연령층:', requestData.targetAge)
+      console.log('  - 홍보 시작일:', requestData.promotionStartDate)
+      console.log('  - 홍보 종료일:', requestData.promotionEndDate)
+      console.log('  - 이미지 개수:', requestData.images.length)
+      
+      if (requestData.images.length === 0) {
+        console.error('❌ [STORE] 포스터에 이미지가 없습니다!')
+        return {
+          success: false,
+          message: '포스터 생성을 위해서는 최소 1개의 이미지가 필요합니다.'
+        }
+      }
+      
+      const result = await contentService.generatePoster(requestData)
+      
+      if (result.success) {
+        console.log('✅ [STORE] 포스터 생성 성공:', result.data)
+        generatedContent.value = result.data
+        
+        return {
+          success: true,
+          content: result.data.posterImage || result.data.content || '포스터가 생성되었습니다.',
+          posterImage: result.data.posterImage,
+          title: result.data.title,
+          data: result.data
+        }
+      } else {
+        console.error('❌ [STORE] 포스터 생성 실패:', result.message)
+        return {
+          success: false,
+          message: result.message || '포스터 생성에 실패했습니다.',
+          error: result.error
+        }
+      }
+      
+    } catch (error) {
+      console.error('❌ [STORE] 포스터 생성 예외:', error)
+      return {
+        success: false,
+        message: error.message || '네트워크 오류가 발생했습니다.',
+        error: error
+      }
+    } finally {
+      generating.value = false
+    }
+  }
+
+  /**
+   * AI 콘텐츠 생성 통합 메서드 (기존 호환성 유지)
+   */
+  const generateContent = async (type, formData) => {
+    console.log('🎯 [STORE] 콘텐츠 생성 요청 (통합):', { type, formData })
+    console.log('📁 [STORE] 통합 메서드 이미지 확인:', {
+      hasImages: !!formData.images,
+      imageCount: formData.images?.length || 0
+    })
+    
+    isLoading.value = true
+    
+    try {
+      let result
+      
+      // 타입에 따라 적절한 메서드 호출
+      if (type === 'poster' || formData.contentType === 'poster' || formData.type === 'poster') {
+        console.log('🎯 [STORE] 포스터 생성으로 라우팅')
+        result = await generatePoster(formData)
+      } else if (type === 'sns' || type === 'snsContent') {
+        console.log('🎯 [STORE] SNS 생성으로 라우팅')
+        result = await generateSnsContent(formData)
+      } else {
+        console.log('🎯 [STORE] 기본 SNS 생성으로 라우팅')
+        result = await generateSnsContent(formData)
+      }
+      
+      if (result.success) {
+        return { success: true, data: result.data || result }
+      } else {
+        return { success: false, error: result.message || result.error }
+      }
+    } catch (error) {
+      console.error('❌ [STORE] 통합 콘텐츠 생성 실패:', error)
+      return { success: false, error: '네트워크 오류가 발생했습니다.' }
+    } finally {
+      isLoading.value = false
+    }
+  }
+
+  // ===== 콘텐츠 저장 =====
+  /**
+   * SNS 콘텐츠 저장
+   */
+  const saveSnsContent = async (saveData) => {
+    loading.value = true
+    
+    try {
+      console.log('💾 [STORE] SNS 콘텐츠 저장 요청:', saveData)
+      
+      // 매장 ID 조회 (필요한 경우)
+      let storeId = saveData.storeId
+      if (!storeId) {
+        try {
+          storeId = await getStoreId()
+        } catch (error) {
+          console.warn('⚠️ 매장 ID 조회 실패, 기본값 사용:', error)
+          storeId = 1
+        }
+      }
+      
+      // SnsContentSaveRequest 구조에 맞게 데이터 변환
+      const requestData = {
+        contentId: saveData.contentId,
+        storeId: storeId,
+        platform: saveData.platform || 'INSTAGRAM',
+        title: saveData.title || '',
+        content: saveData.content || '',
+        hashtags: saveData.hashtags || [],
+        images: saveData.images || [],
+        finalTitle: saveData.finalTitle || saveData.title || '',
+        finalContent: saveData.finalContent || saveData.content || '',
+        status: saveData.status || 'DRAFT',
+        category: saveData.category || '메뉴소개',
+        requirement: saveData.requirement || '',
+        toneAndManner: saveData.toneAndManner || '친근함',
+        emotionIntensity: saveData.emotionIntensity || saveData.emotionalIntensity || '보통',
+        eventName: saveData.eventName || '',
+        startDate: saveData.startDate,
+        endDate: saveData.endDate,
+        promotionalType: saveData.promotionalType,
+        eventDate: saveData.eventDate
+      }
+      
+      const result = await contentService.saveSnsContent(requestData)
+      
+      if (result.success) {
+        console.log('✅ [STORE] SNS 콘텐츠 저장 성공')
+        
+        // 목록 새로고침
+        await loadContents()
+        
+        return { success: true, message: 'SNS 콘텐츠가 저장되었습니다.' }
+      } else {
+        console.error('❌ [STORE] SNS 콘텐츠 저장 실패:', result.message)
+        return { success: false, error: result.message }
+      }
+    } catch (error) {
+      console.error('❌ [STORE] SNS 콘텐츠 저장 예외:', error)
+      return { success: false, error: '네트워크 오류가 발생했습니다.' }
+    } finally {
+      loading.value = false
+    }
+  }
+
+  /**
+   * 포스터 저장
+   */
+  const savePoster = async (saveData) => {
+    loading.value = true
+    
+    try {
+      console.log('💾 [STORE] 포스터 저장 요청:', saveData)
+      
+      // 매장 ID 조회 (필요한 경우)
+      let storeId = saveData.storeId
+      if (!storeId) {
+        try {
+          storeId = await getStoreId()
+        } catch (error) {
+          console.warn('⚠️ 매장 ID 조회 실패, 기본값 사용:', error)
+          storeId = 1
+        }
+      }
+      
+      // PosterContentSaveRequest 구조에 맞게 데이터 변환
+      const requestData = {
+        contentId: saveData.contentId,
+        storeId: storeId,
+        title: saveData.title || '',
+        content: saveData.content || '',
+        images: saveData.images || [],
+        status: saveData.status || 'DRAFT',
+        category: saveData.category || '이벤트',
+        requirement: saveData.requirement || '',
+        toneAndManner: saveData.toneAndManner || '친근함',
+        emotionIntensity: saveData.emotionIntensity || '보통',
+        eventName: saveData.eventName || '',
+        startDate: saveData.startDate,
+        endDate: saveData.endDate,
+        photoStyle: saveData.photoStyle || '밝고 화사한',
+        targetAudience: saveData.targetAudience,
+        promotionType: saveData.promotionType,
+        imageStyle: saveData.imageStyle,
+        promotionStartDate: saveData.promotionStartDate,
+        promotionEndDate: saveData.promotionEndDate
+      }
+      
+      const result = await contentService.savePoster(requestData)
+      
+      if (result.success) {
+        console.log('✅ [STORE] 포스터 저장 성공')
+        
+        // 목록 새로고침
+        await loadContents()
+        
+        return { success: true, message: '포스터가 저장되었습니다.' }
+      } else {
+        console.error('❌ [STORE] 포스터 저장 실패:', result.message)
+        return { success: false, error: result.message }
+      }
+    } catch (error) {
+      console.error('❌ [STORE] 포스터 저장 예외:', error)
+      return { success: false, error: '네트워크 오류가 발생했습니다.' }
+    } finally {
+      loading.value = false
+    }
+  }
+
+  /**
+   * 콘텐츠 저장 통합 메서드 (기존 호환성 유지)
+   */
+  const saveContent = async (type, contentData) => {
+    console.log('💾 [STORE] 콘텐츠 저장 요청 (통합):', { type, contentData })
+    
+    isLoading.value = true
+    
+    try {
+      let result
+      
+      // 타입에 따라 적절한 메서드 호출
+      if (type === 'poster' || contentData.contentType === 'poster' || contentData.type === 'poster') {
+        result = await savePoster(contentData)
+      } else if (type === 'sns' || type === 'snsContent') {
+        result = await saveSnsContent(contentData)
+      } else {
+        // 기본적으로 SNS 콘텐츠로 간주
+        result = await saveSnsContent(contentData)
+      }
+      
+      if (result.success) {
+        return { success: true, message: result.message || '콘텐츠가 저장되었습니다.' }
+      } else {
+        return { success: false, error: result.error }
+      }
+    } catch (error) {
+      console.error('❌ [STORE] 통합 콘텐츠 저장 실패:', error)
+      return { success: false, error: '네트워크 오류가 발생했습니다.' }
+    } finally {
+      isLoading.value = false
+    }
+  }
+
+  // ===== 기타 콘텐츠 관리 메서드들 =====
+  /**
+   * 진행 중인 콘텐츠 조회
+   */
+  const fetchOngoingContents = async (period = 'month') => {
+    isLoading.value = true
+    loading.value = true
+    
+    try {
+      const result = await contentService.getOngoingContents(period)
+      
+      if (result.success) {
+        ongoingContents.value = result.data || []
+        return { success: true }
+      } else {
+        console.error('❌ 진행 중인 콘텐츠 조회 실패:', result.message)
+        return { success: false, error: result.message }
+      }
+    } catch (error) {
+      console.error('❌ 진행 중인 콘텐츠 조회 예외:', error)
+      return { success: false, error: '네트워크 오류가 발생했습니다.' }
+    } finally {
+      isLoading.value = false
+      loading.value = false
+    }
+  }
+
+  /**
+   * 콘텐츠 상세 조회
+   */
+  const fetchContentDetail = async (contentId) => {
+    loading.value = true
+    
+    try {
+      const result = await contentService.getContentDetail(contentId)
+      
+      if (result.success) {
+        selectedContent.value = result.data
+        return result.data
+      } else {
+        throw new Error(result.message || '콘텐츠 상세 조회에 실패했습니다.')
+      }
+    } catch (error) {
+      console.error('❌ 콘텐츠 상세 조회 실패:', error)
+      throw error
+    } finally {
+      loading.value = false
+    }
+  }
+
+  /**
+   * 콘텐츠 수정
+   */
+  const updateContent = async (contentId, updateData) => {
+    isLoading.value = true
+    loading.value = true
+    
+    try {
+      const result = await contentService.updateContent(contentId, updateData)
+      
+      if (result.success) {
+        await loadContents()
+        return { success: true, message: '콘텐츠가 수정되었습니다.' }
+      } else {
+        return { success: false, error: result.message }
+      }
+    } catch (error) {
+      console.error('❌ 콘텐츠 수정 실패:', error)
+      return { success: false, error: '네트워크 오류가 발생했습니다.' }
+    } finally {
+      isLoading.value = false
+      loading.value = false
+    }
+  }
+
+  /**
+   * 콘텐츠 삭제
+   */
+  const deleteContent = async (contentId) => {
+    isLoading.value = true
+    loading.value = true
+    
+    try {
+      const result = await contentService.deleteContent(contentId)
+      
+      if (result.success) {
+        // 목록에서 제거
+        contentList.value = contentList.value.filter(content => content.id !== contentId)
+        contents.value = contents.value.filter(content => content.id !== contentId)
+        totalCount.value = contentList.value.length
+        
+        await loadContents() // 최신 목록으로 새로고침
+        return { success: true, message: '콘텐츠가 삭제되었습니다.' }
+      } else {
+        return { success: false, error: result.message }
+      }
+    } catch (error) {
+      console.error('❌ 콘텐츠 삭제 실패:', error)
+      return { success: false, error: '네트워크 오류가 발생했습니다.' }
+    } finally {
+      isLoading.value = false
+      loading.value = false
+    }
+  }
+
+  // ===== 유틸리티 메서드들 =====
+  /**
+   * 타겟 타입을 카테고리로 매핑
+   */
+  const mapTargetToCategory = (targetType) => {
+    const mapping = {
+      'new_menu': '메뉴소개',
+      'discount': '이벤트',
+      'store': '인테리어', 
+      'event': '이벤트',
+      'menu': '메뉴소개',
+      'service': '서비스'
+    }
+    return mapping[targetType] || '메뉴소개'
+  }
+
+  /**
+   * 플랫폼별 특성 조회
+   */
+  const getPlatformSpec = (platform) => {
+    return PLATFORM_SPECS?.[platform] || null
+  }
+
+  /**
+   * 플랫폼 유효성 검사
+   */
+  const validatePlatform = (platform) => {
+    return PLATFORM_SPECS ? Object.keys(PLATFORM_SPECS).includes(platform) : true
+  }
+
+  /**
+   * 필터 설정
+   */
+  const setFilters = (newFilters) => {
+    filters.value = { ...filters.value, ...newFilters }
+    pagination.value.page = 1 // 필터 변경 시 첫 페이지로
+  }
+
+  /**
+   * 페이지네이션 설정
+   */
+  const setPagination = (newPagination) => {
+    pagination.value = { ...pagination.value, ...newPagination }
+  }
+
+  /**
+   * 상태 초기화
+   */
+  const reset = () => {
+    contentList.value = []
+    contents.value = []
+    ongoingContents.value = []
+    selectedContent.value = null
+    generatedContent.value = null
+    totalCount.value = 0
+    
+    filters.value = {
+      contentType: '',
+      platform: '',
+      period: '',
+      sortBy: 'latest'
+    }
+    
+    pagination.value = {
+      page: 1,
+      itemsPerPage: 10
+    }
+    
+    isLoading.value = false
+    loading.value = false
+    generating.value = false
+  }
+
+  // ===== 고급 기능들 (추가) =====
+  /**
+   * 콘텐츠 검색
+   */
+  const searchContents = async (query, searchFilters = {}) => {
+    loading.value = true
+    
+    try {
+      const result = await contentService.searchContents(query, searchFilters)
+      
+      if (result.success) {
+        contentList.value = result.data || []
+        contents.value = result.data || []
+        totalCount.value = result.data?.length || 0
+        return { success: true }
+      } else {
+        return { success: false, error: result.message }
+      }
+    } catch (error) {
+      console.error('❌ 콘텐츠 검색 실패:', error)
+      return { success: false, error: '네트워크 오류가 발생했습니다.' }
+    } finally {
+      loading.value = false
+    }
+  }
+
+  /**
+   * 콘텐츠 통계 조회
+   */
+  const getContentStats = async (statsFilters = {}) => {
+    loading.value = true
+    
+    try {
+      const result = await contentService.getContentStats(statsFilters)
+      
+      if (result.success) {
+        return { success: true, data: result.data }
+      } else {
+        return { success: false, error: result.message }
+      }
+    } catch (error) {
+      console.error('❌ 콘텐츠 통계 조회 실패:', error)
+      return { success: false, error: '네트워크 오류가 발생했습니다.' }
+    } finally {
+      loading.value = false
+    }
+  }
+
+  /**
+   * 콘텐츠 복제
+   */
+  const duplicateContent = async (contentId) => {
+    loading.value = true
+    
+    try {
+      const result = await contentService.duplicateContent(contentId)
+      
+      if (result.success) {
+        await loadContents() // 목록 새로고침
+        return { success: true, message: '콘텐츠가 복제되었습니다.' }
+      } else {
+        return { success: false, error: result.message }
+      }
+    } catch (error) {
+      console.error('❌ 콘텐츠 복제 실패:', error)
+      return { success: false, error: '네트워크 오류가 발생했습니다.' }
+    } finally {
+      loading.value = false
+    }
+  }
+
+  /**
+   * 콘텐츠 상태 변경
+   */
+  const updateContentStatus = async (contentId, status) => {
+    loading.value = true
+    
+    try {
+      const result = await contentService.updateContentStatus(contentId, status)
+      
+      if (result.success) {
+        await loadContents() // 목록 새로고침
+        return { success: true, message: `콘텐츠 상태가 ${status}로 변경되었습니다.` }
+      } else {
+        return { success: false, error: result.message }
+      }
+    } catch (error) {
+      console.error('❌ 콘텐츠 상태 변경 실패:', error)
+      return { success: false, error: '네트워크 오류가 발생했습니다.' }
+    } finally {
+      loading.value = false
+    }
+  }
+
+  /**
+   * 콘텐츠 즐겨찾기 토글
+   */
+  const toggleContentFavorite = async (contentId) => {
+    loading.value = true
+    
+    try {
+      const result = await contentService.toggleContentFavorite(contentId)
+      
+      if (result.success) {
+        await loadContents() // 목록 새로고침
+        return { success: true, message: '즐겨찾기가 변경되었습니다.' }
+      } else {
+        return { success: false, error: result.message }
+      }
+    } catch (error) {
+      console.error('❌ 즐겨찾기 토글 실패:', error)
+      return { success: false, error: '네트워크 오류가 발생했습니다.' }
+    } finally {
+      loading.value = false
+    }
+  }
+
+  /**
+   * 콘텐츠 템플릿 목록 조회
+   */
+  const getContentTemplates = async (type = 'all') => {
+    loading.value = true
+    
+    try {
+      const result = await contentService.getContentTemplates(type)
+      
+      if (result.success) {
+        return { success: true, data: result.data }
+      } else {
+        return { success: false, error: result.message }
+      }
+    } catch (error) {
+      console.error('❌ 템플릿 목록 조회 실패:', error)
+      return { success: false, error: '네트워크 오류가 발생했습니다.' }
+    } finally {
+      loading.value = false
+    }
+  }
+
+  /**
+   * 템플릿으로 콘텐츠 생성
+   */
+  const generateFromTemplate = async (templateId, customData = {}) => {
+    generating.value = true
+    
+    try {
+      const result = await contentService.generateFromTemplate(templateId, customData)
+      
+      if (result.success) {
+        generatedContent.value = result.data
+        return { success: true, data: result.data }
+      } else {
+        return { success: false, error: result.message }
+      }
+    } catch (error) {
+      console.error('❌ 템플릿 콘텐츠 생성 실패:', error)
+      return { success: false, error: '네트워크 오류가 발생했습니다.' }
+    } finally {
+      generating.value = false
+    }
+  }
+
+  // ===== 반환할 store 객체 =====
+  return {
+    // 상태
+    contentList: readonly(contentList),
+    contents: readonly(contents), // ContentManagementView에서 사용
+    ongoingContents: readonly(ongoingContents),
+    selectedContent: readonly(selectedContent),
+    generatedContent: readonly(generatedContent),
+    totalCount: readonly(totalCount),
+    isLoading: readonly(isLoading),
+    loading: readonly(loading),
+    generating: readonly(generating),
+    filters: readonly(filters),
+    pagination: readonly(pagination),
+    
+    // 컴퓨티드
+    contentCount,
+    ongoingContentCount,
+    filteredContents,
+    paginatedContents,
+    totalPages,
+    
+    // 콘텐츠 목록 조회
+    loadContents, // 새로 추가된 메서드 (매장 정보 조회 포함)
+    fetchContentList, // 기존 호환성 유지
+    
+    // AI 콘텐츠 생성
+    generateContent, // 통합 메서드 (타입에 따라 라우팅)
+    generateSnsContent, // SNS 전용
+    generatePoster, // 포스터 전용
+    
+    // 콘텐츠 저장
+    saveContent, // 통합 메서드 (타입에 따라 라우팅)
+    saveSnsContent, // SNS 전용
+    savePoster, // 포스터 전용
+    
+    // 기본 CRUD
+    fetchOngoingContents,
+    fetchContentDetail,
+    updateContent,
+    deleteContent,
+    
+    // 유틸리티
+    mapTargetToCategory,
+    getPlatformSpec,
+    validatePlatform,
+    setFilters,
+    setPagination,
+    reset,
+    
+    // 고급 기능
+    searchContents,
+    getContentStats,
+    duplicateContent,
+    updateContentStatus,
+    toggleContentFavorite,
+    getContentTemplates,
+    generateFromTemplate
+  }
 })
\ No newline at end of file
diff --git a/src/views/ContentManagementView.vue b/src/views/ContentManagementView.vue
index c927e13..b6af897 100644
--- a/src/views/ContentManagementView.vue
+++ b/src/views/ContentManagementView.vue
@@ -46,18 +46,6 @@
             @input="applyFilters"
             class="flex-grow-1"
           />
-          
-          <!-- 정렬 -->
-          <v-select
-            v-model="sortBy"
-            :items="sortOptions"
-            item-title="title"
-            item-value="value"
-            variant="outlined"
-            density="compact"
-            hide-details
-            style="min-width: 140px;"
-          />
         </div>
       </v-col>
     </v-row>
@@ -435,17 +423,10 @@ const errorMessage = ref('')
 
 // 옵션 데이터
 const contentTypeOptions = [
-  { title: '📊 전체', value: 'all', color: 'primary', emoji: '📊' },
-  { title: '📷 Instagram', value: 'instagram', color: 'pink', emoji: '📷' },
-  { title: '📝 네이버 블로그', value: 'blog', color: 'green', emoji: '📝' },
-  { title: '🎨 포스터', value: 'poster', color: 'orange', emoji: '🎨' }
-]
-
-const sortOptions = [
-  { title: '최신순', value: 'latest' },
-  { title: '오래된순', value: 'oldest' },
-  { title: '제목순', value: 'title' },
-  { title: '조회수순', value: 'views' }
+  { title: '전체', value: 'all', color: 'primary', emoji: '📊' },
+  { title: 'Instagram', value: 'instagram', color: 'pink', emoji: '📷' },
+  { title: '네이버 블로그', value: 'blog', color: 'green', emoji: '📝' },
+  { title: '포스터', value: 'poster', color: 'orange', emoji: '🎨' }
 ]
 
 const titleRules = [
diff --git a/src/views/StoreManagementView.vue b/src/views/StoreManagementView.vue
index 07c27af..4a1250c 100644
--- a/src/views/StoreManagementView.vue
+++ b/src/views/StoreManagementView.vue
@@ -1,789 +1,404 @@
 <template>
   <v-container fluid class="pa-4">
-    <!-- 뒤로가기 버튼과 제목 -->
-    <div class="d-flex align-center mb-4">
-      <v-btn
-        icon
-        variant="text"
-        @click="$router.go(-1)"
-        class="me-2"
-      >
-        <v-icon>mdi-arrow-left</v-icon>
-      </v-btn>
-      <h1 class="text-h5 font-weight-bold">매장 관리</h1>
-    </div>
-
-    <!-- 매장 정보가 없는 경우 -->
-    <div v-if="!storeStore.hasStoreInfo && !storeStore.loading">
-      <v-row justify="center">
-        <v-col cols="12" md="8">
-          <v-card class="text-center pa-8" elevation="4">
-            <v-img
-              src="/images/store-placeholder.png"
-              max-width="200"
-              class="mx-auto mb-4"
-            />
-            <h2 class="text-h5 font-weight-bold mb-3">첫 매장을 등록해볼까요?</h2>
-            <p class="text-grey mb-4">
-              매장 정보를 등록하면 AI 마케팅 서비스를 이용할 수 있습니다
-            </p>
-            <div class="d-flex flex-column gap-3">
-              <v-btn
-                color="primary"
-                size="large"
-                prepend-icon="mdi-store-plus"
-                @click="openCreateDialog"
+    <!-- 🎨 소이님 UI 개선: 필터 → 검색+버튼 순서로 변경 -->
+    <v-card class="mb-6" elevation="2">
+      <v-card-text class="pa-4">
+        <!-- 1단계: 필터 탭들 (전체 너비로 배치) -->
+        <v-row class="mb-4">
+          <v-col cols="12">
+            <div class="d-flex align-center flex-wrap ga-2">
+              <span class="text-subtitle-2 font-weight-medium mr-3 text-grey-darken-1">콘텐츠 타입:</span>
+              <v-chip
+                v-for="type in contentTypeOptions"
+                :key="type.value"
+                :color="selectedContentType === type.value ? type.color : 'default'"
+                :variant="selectedContentType === type.value ? 'flat' : 'outlined'"
+                size="small"
+                class="mr-2 mb-1 chip-hover"
+                @click="selectContentType(type.value)"
               >
-                매장 정보 등록하기
-              </v-btn>
+                <span class="mr-1">{{ type.emoji }}</span>
+                {{ type.title.replace(type.emoji + ' ', '') }}
+                <span v-if="type.value !== 'all'" class="ml-1">({{ getTypeCount(type.value) }})</span>
+                <span v-else class="ml-1">({{ getTotalCount() }})</span>
+              </v-chip>
             </div>
-          </v-card>
-        </v-col>
-      </v-row>
-    </div>
+          </v-col>
+        </v-row>
 
-    <!-- 매장 정보가 있는 경우 -->
-    <div v-else-if="storeStore.hasStoreInfo">
-      <!-- 탭 메뉴 -->
-      <v-row class="mb-4">
-        <v-col cols="12">
-          <v-tabs v-model="currentTab" color="primary">
-            <v-tab value="basic">기본 정보</v-tab>
-            <v-tab value="menu">메뉴 관리</v-tab>
-          </v-tabs>
-        </v-col>
-      </v-row>
-
-      <v-tabs-window v-model="currentTab">
-        <!-- 기본 정보 탭 -->
-        <v-tabs-window-item value="basic">
-          <v-card elevation="2">
-            <v-card-title class="pa-4 d-flex align-center justify-space-between">
-              <div class="d-flex align-center">
-                <v-icon class="mr-2" color="primary">mdi-store</v-icon>
-                매장 기본 정보
-              </div>
-              <v-btn
-                color="primary"
-                variant="outlined"
-                prepend-icon="mdi-pencil"
-                @click="editBasicInfo"
-              >
-                수정
-              </v-btn>
-            </v-card-title>
-            
-            <v-divider />
-            
-            <v-card-text class="pa-6">
-              <v-row>
-                <!-- 매장 이미지 -->
-                <v-col cols="12" md="4" class="text-center">
-                  <v-avatar size="120" class="mb-3">
-                    <v-img
-                      :src="storeInfo.imageUrl || '/images/store-placeholder.png'"
-                      alt="매장 이미지"
-                    />
-                  </v-avatar>
-                  <h3 class="text-h6 font-weight-bold">{{ storeInfo.storeName }}</h3>
-                  <p class="text-grey">{{ storeInfo.businessType }}</p>
-                </v-col>
-
-                <!-- 기본 정보 -->
-                <v-col cols="12" md="8">
-                  <v-row>
-                    <v-col cols="12" sm="6">
-                      <div class="info-item">
-                        <v-icon class="mr-2" color="grey">mdi-map-marker</v-icon>
-                        <div>
-                          <div class="text-caption text-grey">주소</div>
-                          <div class="text-body-1">{{ storeInfo.address || '미입력' }}</div>
-                        </div>
-                      </div>
-                    </v-col>
-                    
-                    <v-col cols="12" sm="6">
-                      <div class="info-item">
-                        <v-icon class="mr-2" color="grey">mdi-phone</v-icon>
-                        <div>
-                          <div class="text-caption text-grey">전화번호</div>
-                          <div class="text-body-1">{{ storeInfo.phoneNumber || '미입력' }}</div>
-                        </div>
-                      </div>
-                    </v-col>
-                    
-                    <v-col cols="12" sm="6">
-                      <div class="info-item">
-                        <v-icon class="mr-2" color="grey">mdi-clock</v-icon>
-                        <div>
-                          <div class="text-caption text-grey">영업시간</div>
-                          <div class="text-body-1">{{ storeInfo.businessHours || '미입력' }}</div>
-                        </div>
-                      </div>
-                    </v-col>
-                
-                    <v-col cols="12" sm="6">
-                      <div class="info-item">
-                        <v-icon class="mr-2" color="grey">mdi-account-group</v-icon>
-                        <div>
-                          <div class="text-caption text-grey">좌석 수</div>
-                          <div class="text-body-1">{{ storeInfo.seatCount || 0 }}석</div>
-                        </div>
-                      </div>
-                    </v-col>
-                    
-                    <v-col cols="12" sm="6">
-                      <div class="info-item">
-                        <v-icon class="mr-2" color="grey">mdi-calendar-off</v-icon>
-                        <div>
-                          <div class="text-caption text-grey">휴무일</div>
-                          <div class="text-body-1">{{ formatClosedDays(storeInfo.holidays) }}</div>
-                        </div>
-                      </div>
-                    </v-col>
-                    
-                    <v-col cols="12" sm="6">
-                      <div class="info-item">
-                        <v-icon class="mr-2" color="grey">mdi-instagram</v-icon>
-                        <div>
-                          <div class="text-caption text-grey">인스타그램</div>
-                          <div class="text-body-1">{{ storeInfo.instaAccounts || '미입력' }}</div>
-                        </div>
-                      </div>
-                    </v-col>
-                  </v-row>
-                  
-                  <!-- 매장 소개 -->
-                  <v-divider class="my-4" />
-                  <div class="info-item">
-                    <v-icon class="mr-2" color="grey">mdi-text</v-icon>
-                    <div>
-                      <div class="text-caption text-grey">매장 소개</div>
-                      <div class="text-body-1">{{ storeInfo.description || '매장 소개가 없습니다' }}</div>
-                    </div>
-                  </div>
-                </v-col>
-              </v-row>
-            </v-card-text>
-          </v-card>
-        </v-tabs-window-item>
-
-        <!-- 메뉴 관리 탭 -->
-        <v-tabs-window-item value="menu">
-          <!-- 검색 및 필터 섹션 -->
-          <v-card class="mb-4" elevation="2">
-            <v-card-text>
-              <v-row>
-                <v-col cols="12" md="6">
-                  <v-text-field
-                    v-model="menuSearch"
-                    prepend-inner-icon="mdi-magnify"
-                    label="메뉴 검색"
-                    variant="outlined"
-                    density="compact"
-                    clearable
-                  />
-                </v-col>
-                <v-col cols="12" md="3">
-                  <v-select
-                    v-model="menuCategoryFilter"
-                    :items="['전체', ...menuCategories]"
-                    label="카테고리"
-                    variant="outlined"
-                    density="compact"
-                  />
-                </v-col>
-                <v-col cols="12" md="3" class="d-flex align-center gap-2">
-                  <v-btn
-                    color="primary"
-                    variant="outlined"
-                    prepend-icon="mdi-filter-off"
-                    @click="clearFilters"
-                    size="small"
-                  >
-                    필터 초기화
-                  </v-btn>
-                  <v-btn
-                    color="primary"
-                    prepend-icon="mdi-plus"
-                    @click="openCreateMenuDialog"
-                    size="small"
-                  >
-                    메뉴 추가
-                  </v-btn>
-                </v-col>
-              </v-row>
-            </v-card-text>
-          </v-card>
-
-          <!-- 메뉴 목록 -->
-          <div v-if="filteredMenus.length > 0">
-            <v-row>
-              <v-col
-                v-for="menu in filteredMenus"
-                :key="menu.id || menu.menuId"
-                cols="12"
-                sm="6"
-                md="4"
-                lg="3"
-              >
-                <v-card
-                  class="menu-card h-100"
-                  elevation="2"
-                  @click="viewMenuDetail(menu)"
-                >
-                  <div class="position-relative">
-                    <!-- 메뉴 카드에서 이미지 표시 수정 -->
-                    <v-img
-                      :src="getMenuImageUrl(menu)"
-                      height="200"
-                      cover
-                      class="grey lighten-2"
-                      @error="handleImageError($event, menu)"
-                    >
-                      <template v-slot:placeholder>
-                        <div class="d-flex align-center justify-center fill-height">
-                          <v-progress-circular
-                            color="grey-lighten-4"
-                            indeterminate
-                          />
-                        </div>
-                      </template>
-                      <!-- 이미지 로딩 실패 시 플레이스홀더 표시 -->
-                      <template v-slot:error>
-                        <div class="d-flex align-center justify-center fill-height">
-                          <v-icon size="64" color="grey-lighten-2">mdi-image-off</v-icon>
-                        </div>
-                      </template>
-                    </v-img>
-                    
-                    <!-- 상태 뱃지 -->
-                    <div class="position-absolute top-0 right-0 pa-2">
-                      <v-chip
-                        v-if="!menu.available"
-                        color="red"
-                        size="small"
-                        class="mb-1"
-                      >
-                        품절
-                      </v-chip>
-                      <v-chip
-                        v-if="menu.recommended"
-                        color="orange"
-                        size="small"
-                      >
-                        추천
-                      </v-chip>
-                    </div>
-                    
-                    <!-- 액션 버튼 -->
-                    <div class="position-absolute top-0 left-0 pa-2">
-                      <v-btn
-                        icon="mdi-pencil"
-                        size="small"
-                        color="white"
-                        variant="elevated"
-                        @click.stop="editMenu(menu)"
-                        class="me-1"
-                      />
-                      <v-btn
-                        icon="mdi-delete"
-                        size="small"
-                        color="red"
-                        variant="elevated"
-                        @click.stop="confirmDeleteMenu(menu)"
-                      />
-                    </div>
-                  </div>
-                  
-                  <v-card-text class="pa-3">
-                    <div class="d-flex justify-space-between align-start mb-2">
-                      <h4 class="text-subtitle-1 font-weight-bold">
-                        {{ menu.menuName || menu.name }}
-                      </h4>
-                      <v-chip
-                        :color="menu.available ? 'green' : 'red'"
-                        size="small"
-                        variant="tonal"
-                      >
-                        {{ menu.available ? '판매중' : '품절' }}
-                      </v-chip>
-                    </div>
-                    
-                    <p class="text-body-2 text-grey text-truncate-2 mb-2">
-                      {{ menu.description || '설명이 없습니다' }}
-                    </p>
-                    
-                    <div class="d-flex justify-space-between align-center">
-                      <span class="text-h6 font-weight-bold text-primary">
-                        {{ menu.price ? menu.price.toLocaleString() : '0' }}원
-                      </span>
-                      <v-chip
-                        size="small"
-                        variant="outlined"
-                        color="primary"
-                      >
-                        {{ menu.category }}
-                      </v-chip>
-                    </div>
-                  </v-card-text>
-                </v-card>
-              </v-col>
-            </v-row>
-          </div>
-
-          <!-- 메뉴가 없는 경우 -->
-          <v-card v-else class="text-center pa-8" elevation="2">
-            <v-icon size="64" color="grey-lighten-1" class="mb-4">mdi-food-off</v-icon>
-            <h3 class="text-h6 mb-2">등록된 메뉴가 없습니다</h3>
-            <p class="text-grey mb-4">첫 번째 메뉴를 등록해보세요</p>
+        <!-- 2단계: 검색박스 + 새 콘텐츠 생성 버튼 (같은 줄에 배치) -->
+        <v-row align="center" class="ga-3">
+          <!-- 검색박스 (왼쪽, 넓게) -->
+          <v-col cols="12" md="9">
+            <v-text-field
+              v-model="searchQuery"
+              label="제목, 내용, 해시태그로 검색..."
+              prepend-inner-icon="mdi-magnify"
+              variant="outlined"
+              density="comfortable"
+              clearable
+              hide-details
+              class="search-field"
+              @update:model-value="applyFilters"
+            />
+          </v-col>
+          
+          <!-- 새 콘텐츠 생성 버튼 (오른쪽) -->
+          <v-col cols="12" md="3" class="d-flex justify-end">
             <v-btn
               color="primary"
               prepend-icon="mdi-plus"
-              @click="openCreateMenuDialog"
+              @click="$router.push('/content/create')"
+              size="large"
+              class="text-none font-weight-medium create-btn"
+              elevation="2"
             >
-              메뉴 등록하기
+              새 콘텐츠 생성
             </v-btn>
-          </v-card>
-        </v-tabs-window-item>
-      </v-tabs-window>
-    </div>
+          </v-col>
+        </v-row>
+      </v-card-text>
+    </v-card>
 
-    <!-- 로딩 상태 -->
-    <div v-else class="text-center pa-8">
-      <v-progress-circular indeterminate color="primary" size="64" />
-      <p class="text-grey mt-4">매장 정보를 불러오는 중...</p>
-    </div>
-
-    <!-- 매장 등록/수정 다이얼로그 -->
-    <v-dialog 
-      v-model="showCreateDialog" 
-      max-width="600" 
-      persistent
-      :style="{ zIndex: 2000 }"
-      class="store-dialog"
-    >
-      <v-card class="store-dialog-card">
-        <v-card-title class="pa-4">
-          <div class="d-flex align-center">
-            <v-icon class="mr-2" color="primary">mdi-store</v-icon>
-            {{ editMode ? '매장 정보 수정' : '새 매장 등록' }}
-          </div>
-        </v-card-title>
-        
-        <v-divider />
-        
-        <!-- ✅ 스크롤 가능한 컨텐츠 영역 -->
-        <v-card-text class="pa-4 store-dialog-content">
-          <v-form ref="storeFormRef" v-model="formValid">
-            <v-row>
-              <v-col cols="12">
-                <v-text-field
-                  v-model="formData.storeName"
-                  label="매장명 *"
-                  :rules="[v => !!v || '매장명을 입력해주세요']"
-                  variant="outlined"
-                  density="compact"
-                  required
-                />
-              </v-col>
-              
-              <v-col cols="12" sm="6">
-                <v-select
-                  v-model="formData.businessType"
-                  :items="businessTypes"
-                  label="업종 *"
-                  :rules="[v => !!v || '업종을 선택해주세요']"
-                  variant="outlined"
-                  density="compact"
-                  required
-                />
-              </v-col>
-              
-              <v-col cols="12" sm="6">
-                <v-text-field
-                  v-model.number="formData.seatCount"
-                  label="좌석 수"
-                  type="number"
-                  variant="outlined"
-                  density="compact"
-                />
-              </v-col>
-              
-              <v-col cols="12">
-                <v-text-field
-                  v-model="formData.address"
-                  label="주소 *"
-                  :rules="[v => !!v || '주소를 입력해주세요']"
-                  variant="outlined"
-                  density="compact"
-                  required
-                />
-              </v-col>
-              
-              <v-col cols="12" sm="6">
-                <v-text-field
-                  v-model="formData.phoneNumber"
-                  label="전화번호"
-                  variant="outlined"
-                  density="compact"
-                />
-              </v-col>
-              
-              <v-col cols="12" sm="6">
-                <v-text-field
-                  v-model="formData.instagramUrl"
-                  label="인스타그램 URL"
-                  variant="outlined"
-                  density="compact"
-                />
-              </v-col>
-              
-              <v-col cols="12" sm="6">
-                <v-text-field
-                  v-model="formData.openTime"
-                  label="오픈 시간"
-                  type="time"
-                  variant="outlined"
-                  density="compact"
-                />
-              </v-col>
-              
-              <v-col cols="12" sm="6">
-                <v-text-field
-                  v-model="formData.closeTime"
-                  label="마감 시간"
-                  type="time"
-                  variant="outlined"
-                  density="compact"
-                />
-              </v-col>
-              
-              <v-col cols="12">
-                <v-select
-                  v-model="formData.holidays"
-                  :items="weekDays"
-                  item-title="title"
-                  item-value="value"
-                  label="휴무일"
-                  multiple
-                  chips
-                  variant="outlined"
-                  density="compact"
-                />
-              </v-col>
-              
-              <v-col cols="12">
-                <v-text-field
-                  v-model="formData.blogUrl"
-                  label="블로그 URL"
-                  variant="outlined"
-                  density="compact"
-                />
-              </v-col>
-              
-              <v-col cols="12">
-                <v-textarea
-                  v-model="formData.description"
-                  label="매장 소개"
-                  variant="outlined"
-                  density="compact"
-                  rows="2"
-                />
-              </v-col>
-            </v-row>
-          </v-form>
-        </v-card-text>
-        
-        <v-card-actions class="pa-4">
-          <v-spacer />
+    <!-- 선택된 항목 일괄 작업 -->
+    <div v-if="selectedItems.length > 0" class="mb-4">
+      <v-alert color="info" variant="tonal" class="selected-alert">
+        <div class="d-flex justify-space-between align-center">
+          <span class="font-weight-medium">{{ selectedItems.length }}개 항목이 선택됨</span>
           <v-btn
+            color="error"
             variant="text"
-            @click="showCreateDialog = false"
+            prepend-icon="mdi-delete"
+            @click="deleteSelectedItems"
+            class="font-weight-medium"
           >
-            취소
+            선택 항목 삭제
           </v-btn>
+        </div>
+      </v-alert>
+    </div>
+
+    <!-- 콘텐츠 목록 -->
+    <v-card elevation="2">
+      <v-card-text class="pa-0">
+        <div v-if="loading" class="text-center pa-8">
+          <v-progress-circular indeterminate color="primary" size="48" width="4" />
+          <div class="mt-4 text-body-1 text-grey-darken-1">콘텐츠를 불러오는 중...</div>
+        </div>
+
+        <div v-else-if="paginatedContents.length === 0" class="text-center pa-12 empty-state">
+          <v-icon size="80" color="grey-lighten-2" class="mb-4">mdi-file-document-outline</v-icon>
+          <div class="text-h6 mb-3 text-grey-darken-1">표시할 콘텐츠가 없습니다</div>
+          <div class="text-body-2 text-grey mb-6">새로운 콘텐츠를 생성해보세요</div>
           <v-btn
             color="primary"
-            @click="saveStore"
-            :loading="saving"
-            :disabled="!formValid"
+            size="large"
+            prepend-icon="mdi-plus"
+            @click="$router.push('/content/create')"
+            class="font-weight-medium"
+            elevation="2"
           >
-            {{ editMode ? '수정' : '등록' }}
+            콘텐츠 생성하기
           </v-btn>
-        </v-card-actions>
-      </v-card>
-</v-dialog>
+        </div>
 
-    <!-- 메뉴 등록/수정 다이얼로그 -->
-    <v-dialog 
-      v-model="showMenuDialog" 
-      max-width="600" 
-      persistent
-      :style="{ zIndex: 2000 }"
-      class="menu-dialog"
-    >
-      <v-card class="menu-dialog-card">
-        <v-card-title class="pa-4">
-          <div class="d-flex align-center">
-            <v-icon class="mr-2" color="primary">mdi-food</v-icon>
-            {{ menuEditMode ? '메뉴 수정' : '새 메뉴 등록' }}
-          </div>
-        </v-card-title>
-        
-        <v-divider />
-        
-        <!-- ✅ 스크롤 가능한 컨텐츠 영역 -->
-        <v-card-text class="pa-4 dialog-content">
-          <v-form ref="menuFormRef" v-model="menuFormValid">
-            <v-row>
-              <!-- 메뉴 이미지 업로드 -->
-              <v-col cols="12">
-                <div class="mb-4">
-                  <h4 class="text-subtitle-1 font-weight-bold mb-3 d-flex align-center">
-                    <v-icon class="mr-2" color="primary">mdi-image</v-icon>
-                    메뉴 이미지 {{ !menuEditMode ? '*' : '' }}
-                  </h4>
-                  
-                  <!-- 이미지 미리보기 -->
-                  <div v-if="shouldShowImagePreview" class="mb-3">
-                    <v-img
-                      :src="shouldShowImagePreview"
-                      max-height="180"
-                      max-width="280"
-                      class="rounded mx-auto"
-                      style="border: 2px solid #e0e0e0;"
-                    />
-                    <div class="text-center mt-2">
-                      <v-chip 
-                        v-if="previewImageUrl" 
-                        color="success" 
-                        size="small" 
-                        class="mr-2"
-                      >
-                        새 이미지 선택됨
-                      </v-chip>
-                      <v-chip 
-                        v-else-if="menuEditMode" 
-                        color="info" 
-                        size="small" 
-                        class="mr-2"
-                      >
-                        현재 이미지
-                      </v-chip>
-                      <v-btn
-                        size="small"
-                        color="primary"
-                        variant="outlined"
-                        prepend-icon="mdi-image-edit"
-                        @click="resetImageSelection"
-                      >
-                        다른 이미지 선택
-                      </v-btn>
-                    </div>
-                  </div>
-                  
-                  <!-- 이미지 선택 섹션 -->
-                  <div v-else>
-                    <v-file-input
-                      v-model="selectedImageFile"
-                      label="메뉴 이미지 선택 *"
-                      accept="image/*"
-                      prepend-icon="mdi-camera"
-                      variant="outlined"
-                      density="compact"
-                      :rules="[
-                        v => menuEditMode || !!v || '메뉴 이미지는 필수입니다',
-                        v => !v || v.size < 10485760 || '파일 크기는 10MB 이하여야 합니다',
-                        v => !v || v.type.startsWith('image/') || '이미지 파일만 업로드 가능합니다'
-                      ]"
-                      @update:modelValue="onFileInputChange"
-                      show-size
-                      required
-                    />
-                    
-                    <!-- 드래그앤드롭 영역 - 높이 축소 -->
-                    <div
-                      class="drop-zone pa-3 text-center"
-                      style="border: 2px dashed #ccc; border-radius: 8px; background: #fafafa; min-height: 80px;"
-                      @drop="onDropImage"
-                      @dragover.prevent
-                      @dragenter.prevent
+        <!-- 콘텐츠 목록 테이블 -->
+        <div v-else>
+          <v-table hover class="content-table">
+            <thead>
+              <tr class="table-header">
+                <th width="50" class="pa-4">
+                  <v-checkbox
+                    v-model="selectAll"
+                    @change="toggleSelectAll"
+                    density="compact"
+                    color="primary"
+                  />
+                </th>
+                <th width="450" class="pa-4 font-weight-bold text-grey-darken-2">제목</th>
+                <th width="150" class="pa-4 font-weight-bold text-grey-darken-2">플랫폼</th>
+                <th width="200" class="pa-4 sortable-header cursor-pointer" @click="sortByPromotionDate">
+                  <div class="d-flex align-center">
+                    <span class="font-weight-bold text-grey-darken-2">프로모션 기간</span>
+                    <v-icon 
+                      :color="promotionSortOrder === 'none' ? 'grey-lighten-1' : 'primary'"
+                      size="18" 
+                      class="ml-2"
                     >
-                      <v-icon size="32" color="grey-lighten-2">mdi-cloud-upload</v-icon>
-                      <p class="text-grey text-center mt-1 mb-1 text-caption">
-                        이미지를 드래그하여 업로드하거나 위의 버튼을 클릭하세요
-                      </p>
-                      <p class="text-caption text-grey text-center">
-                        JPG, PNG 파일만 업로드 가능 (최대 10MB)
-                      </p>
+                      {{
+                        promotionSortOrder === 'asc' ? 'mdi-arrow-up' :
+                        promotionSortOrder === 'desc' ? 'mdi-arrow-down' :
+                        'mdi-unfold-more-horizontal'
+                      }}
+                    </v-icon>
+                  </div>
+                </th>
+                <th width="120" class="pa-4 font-weight-bold text-grey-darken-2">액션</th>
+              </tr>
+            </thead>
+            <tbody>
+              <tr 
+                v-for="content in paginatedContents" 
+                :key="content.id" 
+                class="content-row cursor-pointer" 
+                @click="showDetail(content)"
+              >
+                <td class="pa-4" @click.stop>
+                  <v-checkbox
+                    v-model="selectedItems"
+                    :value="content.id"
+                    density="compact"
+                    color="primary"
+                  />
+                </td>
+                <td class="pa-4">
+                  <div class="d-flex flex-column">
+                    <div class="d-flex align-center mb-2">
+                      <span class="font-weight-medium text-subtitle-2 mr-3">{{ content.title }}</span>
+                      <v-chip
+                        :color="getStatusColor(content.status)"
+                        size="x-small"
+                        variant="tonal"
+                        class="font-weight-medium"
+                      >
+                        {{ getStatusText(content.status) }}
+                      </v-chip>
+                    </div>
+                    <div class="text-caption text-truncate text-grey-darken-1" style="max-width: 400px;">
+                      {{ content.content ? content.content.replace(/<[^>]*>/g, '').substring(0, 100) + '...' : 'string...' }}
                     </div>
                   </div>
-                </div>
-              </v-col>
-              
-              <v-col cols="12">
-                <v-text-field
-                  v-model="menuFormData.menuName"
-                  label="메뉴명 *"
-                  :rules="[v => !!v || '메뉴명을 입력해주세요']"
-                  variant="outlined"
-                  density="compact"
-                  required
-                />
-              </v-col>
-              
-              <v-col cols="12" sm="6">
-                <v-select
-                  v-model="menuFormData.category"
-                  :items="menuCategories"
-                  label="카테고리 *"
-                  :rules="[v => !!v || '카테고리를 선택해주세요']"
-                  variant="outlined"
-                  density="compact"
-                  required
-                />
-              </v-col>
-              
-              <v-col cols="12" sm="6">
-                <v-text-field
-                  v-model.number="menuFormData.price"
-                  label="가격 (원) *"
-                  type="number"
-                  :rules="[
-                    v => !!v || '가격을 입력해주세요',
-                    v => v > 0 || '가격은 0보다 커야 합니다'
-                  ]"
-                  variant="outlined"
-                  density="compact"
-                  required
-                />
-              </v-col>
-              
-              <v-col cols="12">
+                </td>
+                <td class="pa-4">
+                  <v-chip
+                    :color="getPlatformColor(content.platform)"
+                    size="small"
+                    variant="tonal"
+                    class="font-weight-medium"
+                  >
+                    {{ getPlatformText(content.platform) }}
+                  </v-chip>
+                </td>
+                <td class="pa-4">
+                  <div class="text-body-2 text-grey-darken-1">
+                    {{ formatDateRange(content.startDate, content.endDate) }}
+                  </div>
+                </td>
+                <td class="pa-4" @click.stop>
+                  <div class="d-flex align-center ga-1">
+                    <v-btn
+                      icon="mdi-pencil"
+                      size="small"
+                      variant="text"
+                      color="primary"
+                      @click="showDetailWithEdit(content)"
+                      class="action-btn"
+                    />
+                    <v-btn
+                      icon="mdi-delete"
+                      size="small"
+                      variant="text"
+                      color="error"
+                      @click="confirmDelete(content)"
+                      class="action-btn"
+                    />
+                  </div>
+                </td>
+              </tr>
+            </tbody>
+          </v-table>
+
+          <!-- 페이지네이션 -->
+          <div v-if="totalPages > 1" class="pa-4 d-flex justify-center">
+            <v-pagination
+              v-model="currentPage"
+              :length="totalPages"
+              :total-visible="7"
+              rounded="circle"
+              color="primary"
+              class="pagination-custom"
+            />
+          </div>
+        </div>
+      </v-card-text>
+    </v-card>
+
+    <!-- 콘텐츠 상세/수정 다이얼로그 -->
+    <v-dialog v-model="showDetailDialog" max-width="800" persistent>
+      <v-card class="detail-dialog">
+        <v-card-title class="pa-6 pb-4">
+          <div class="d-flex align-center">
+            <v-icon class="mr-3" color="primary">
+              {{ isEditMode ? 'mdi-pencil' : 'mdi-eye' }}
+            </v-icon>
+            <span class="text-h6 font-weight-bold">
+              {{ isEditMode ? '콘텐츠 수정' : '콘텐츠 상세' }}
+            </span>
+          </div>
+        </v-card-title>
+        
+        <v-divider />
+        
+        <v-card-text class="pa-6" style="max-height: 70vh; overflow-y: auto;">
+          <v-form ref="editForm" v-model="editFormValid" v-if="selectedContent">
+            <!-- 제목 -->
+            <div class="mb-6">
+              <label class="text-subtitle-2 font-weight-bold mb-3 d-block text-grey-darken-2">제목</label>
+              <v-text-field
+                v-if="isEditMode"
+                v-model="editingContent.title"
+                variant="outlined"
+                density="comfortable"
+                :rules="titleRules"
+                hide-details="auto"
+                class="edit-field"
+              />
+              <div v-else class="text-body-1 pa-3 bg-grey-lighten-5 rounded">
+                {{ selectedContent.title }}
+              </div>
+            </div>
+
+            <!-- 콘텐츠 내용 -->
+            <div class="mb-6">
+              <label class="text-subtitle-2 font-weight-bold mb-3 d-block text-grey-darken-2">내용</label>
+              <div v-if="isEditMode">
                 <v-textarea
-                  v-model="menuFormData.description"
-                  label="메뉴 설명"
+                  v-model="editingContent.content"
                   variant="outlined"
-                  density="compact"
-                  rows="2"
+                  rows="8"
+                  auto-grow
+                  hide-details
+                  class="edit-field"
                 />
-              </v-col>
-              
-              <v-col cols="12" sm="6">
-                <v-switch
-                  v-model="menuFormData.available"
-                  label="판매 가능"
+              </div>
+              <div v-else class="content-display pa-4 bg-grey-lighten-5 rounded">
+                <div v-if="selectedContent.content && selectedContent.content.includes('<')" 
+                     v-html="selectedContent.content"
+                     class="content-html">
+                </div>
+                <div v-else class="text-body-1" style="white-space: pre-wrap;">
+                  {{ selectedContent.content }}
+                </div>
+              </div>
+            </div>
+
+            <!-- 해시태그 -->
+            <div class="mb-6">
+              <label class="text-subtitle-2 font-weight-bold mb-3 d-block text-grey-darken-2">해시태그</label>
+              <div class="d-flex flex-wrap ga-2">
+                <v-chip
+                  v-for="tag in selectedContent.hashtags"
+                  :key="tag"
+                  size="small"
                   color="primary"
-                  density="compact"
-                />
+                  variant="tonal"
+                  class="font-weight-medium"
+                >
+                  #{{ tag }}
+                </v-chip>
+              </div>
+              <div v-if="isEditMode" class="text-caption text-grey mt-2">
+                해시태그는 수정할 수 없습니다. 새로 생성해주세요.
+              </div>
+            </div>
+
+            <!-- 플랫폼 및 상태 정보 -->
+            <v-row>
+              <v-col cols="6">
+                <label class="text-subtitle-2 font-weight-bold mb-3 d-block text-grey-darken-2">플랫폼</label>
+                <v-chip
+                  :color="getPlatformColor(selectedContent.platform)"
+                  variant="tonal"
+                  class="font-weight-medium"
+                >
+                  {{ getPlatformText(selectedContent.platform) }}
+                </v-chip>
               </v-col>
-              
-              <v-col cols="12" sm="6">
-                <v-switch
-                  v-model="menuFormData.recommended"
-                  label="추천 메뉴"
-                  color="orange"
-                  density="compact"
-                />
+              <v-col cols="6">
+                <label class="text-subtitle-2 font-weight-bold mb-3 d-block text-grey-darken-2">상태</label>
+                <v-chip
+                  :color="getStatusColor(selectedContent.status)"
+                  variant="tonal"
+                  class="font-weight-medium"
+                >
+                  {{ getStatusText(selectedContent.status) }}
+                </v-chip>
               </v-col>
             </v-row>
           </v-form>
         </v-card-text>
         
-        <v-card-actions class="pa-4">
+        <v-divider />
+        
+        <!-- 다이얼로그 액션 버튼 -->
+        <v-card-actions class="pa-6 pt-4">
           <v-spacer />
-          <v-btn
-            variant="text"
-            @click="cancelMenuForm"
-          >
-            취소
-          </v-btn>
-          <v-btn
-            color="primary"
-            @click="saveMenu"
-            :loading="saving"
-            :disabled="!menuFormValid"
-          >
-            {{ menuEditMode ? '수정' : '등록' }}
-          </v-btn>
-        </v-card-actions>
-      </v-card>
-    </v-dialog>
-    <!-- 메뉴 상세 다이얼로그 -->
-    <v-dialog v-model="showMenuDetailDialog" max-width="500">
-      <v-card v-if="selectedMenu">
-        <v-img
-          :src="getMenuImageUrl(selectedMenu)"
-          height="250"
-          cover
-          @error="handleImageError($event, selectedMenu)"
-        />
-        
-        <v-card-title class="pa-4 d-flex justify-space-between align-center">
-          <span>{{ selectedMenu.menuName || selectedMenu.name }}</span>
-          <v-chip
-            :color="selectedMenu.available ? 'green' : 'red'"
-            size="small"
-          >
-            {{ selectedMenu.available ? '판매중' : '품절' }}
-          </v-chip>
-        </v-card-title>
-        
-        <v-card-text class="pa-4">
-          <div class="mb-3">
-            <div class="text-caption text-grey">카테고리</div>
-            <div class="text-body-1">{{ selectedMenu.category }}</div>
+          <div v-if="isEditMode" class="d-flex ga-3">
+            <v-btn 
+              variant="outlined"
+              color="grey-darken-1"
+              @click="cancelEdit"
+              class="px-6 font-weight-medium"
+            >
+              취소
+            </v-btn>
+            <v-btn 
+              color="primary" 
+              @click="saveEdit"
+              :loading="updating"
+              :disabled="!editFormValid"
+              class="px-6 font-weight-medium"
+              elevation="2"
+            >
+              저장
+            </v-btn>
           </div>
-          
-          <div class="mb-3">
-            <div class="text-caption text-grey">가격</div>
-            <div class="text-h6 text-primary font-weight-bold">
-              {{ selectedMenu.price ? selectedMenu.price.toLocaleString() : '0' }}원
-            </div>
+          <div v-else class="d-flex ga-3">
+            <v-btn 
+              variant="outlined"
+              color="grey-darken-1"
+              @click="closeDialog"
+              class="px-6 font-weight-medium"
+            >
+              닫기
+            </v-btn>
+            <v-btn 
+              variant="outlined"
+              color="primary"
+              prepend-icon="mdi-pencil"
+              @click="showEditMode"
+              class="px-6 font-weight-medium"
+            >
+              수정
+            </v-btn>
+            <v-btn 
+              variant="outlined"
+              color="error"
+              prepend-icon="mdi-delete"
+              @click="confirmDelete(selectedContent)"
+              class="px-6 font-weight-medium"
+            >
+              삭제
+            </v-btn>
           </div>
-          
-          <div class="mb-3">
-            <div class="text-caption text-grey">설명</div>
-            <div class="text-body-1">{{ selectedMenu.description || '설명이 없습니다' }}</div>
-          </div>
-          
-          <div v-if="selectedMenu.recommended" class="mb-3">
-            <v-chip color="orange" size="small">추천 메뉴</v-chip>
-          </div>
-        </v-card-text>
-        
-        <v-card-actions class="pa-4">
-          <v-spacer />
-          <v-btn
-            variant="text"
-            @click="closeMenuDetail"
-          >
-            닫기
-          </v-btn>
-          <v-btn
-            color="primary"
-            variant="text"
-            @click="editMenu(selectedMenu); closeMenuDetail()"
-          >
-            수정
-          </v-btn>
         </v-card-actions>
       </v-card>
     </v-dialog>
 
-    <!-- 스낵바 -->
-    <v-snackbar
-      v-model="snackbar.show"
-      :color="snackbar.color"
-      :timeout="3000"
-      location="bottom"
-    >
-      {{ snackbar.message }}
+    <!-- 성공/오류 스낵바 -->
+    <v-snackbar v-model="showSuccess" color="success" timeout="4000" location="bottom">
+      <v-icon class="mr-2">mdi-check-circle</v-icon>
+      {{ successMessage }}
+    </v-snackbar>
+    
+    <v-snackbar v-model="showError" color="error" timeout="4000" location="bottom">
+      <v-icon class="mr-2">mdi-alert-circle</v-icon>
+      {{ errorMessage }}
     </v-snackbar>
   </v-container>
 </template>
 
+
 <script setup>
 import { ref, computed, onMounted, watch, nextTick } from 'vue'
 import { useStoreStore } from '@/store/index'
@@ -2235,4 +1850,168 @@ onMounted(async () => {
 .store-dialog-content::-webkit-scrollbar-thumb:hover {
   background: #a8a8a8;
 }
+/* 🎨 소이님 UI 개선을 위한 스타일 */
+
+/* 필터 칩 호버 효과 */
+.chip-hover {
+  transition: all 0.3s cubic-bezier(0.4, 0, 0.2, 1);
+  cursor: pointer;
+}
+
+.chip-hover:hover {
+  transform: translateY(-2px);
+  box-shadow: 0 4px 12px rgba(0,0,0,0.15);
+}
+
+/* 검색 필드 스타일 */
+.search-field {
+  transition: all 0.3s ease;
+}
+
+.search-field:hover {
+  box-shadow: 0 2px 8px rgba(0,0,0,0.1);
+}
+
+/* 새 콘텐츠 생성 버튼 */
+.create-btn {
+  transition: all 0.3s cubic-bezier(0.4, 0, 0.2, 1);
+  min-width: 160px;
+}
+
+.create-btn:hover {
+  transform: translateY(-2px);
+  box-shadow: 0 6px 20px rgba(25, 118, 210, 0.3);
+}
+
+/* 선택된 항목 알림 */
+.selected-alert {
+  border-left: 4px solid #2196F3;
+  background: linear-gradient(90deg, rgba(33, 150, 243, 0.05) 0%, rgba(33, 150, 243, 0.02) 100%);
+}
+
+/* 테이블 스타일 */
+.content-table {
+  border-radius: 0;
+}
+
+.table-header {
+  background: linear-gradient(90deg, #fafafa 0%, #f5f5f5 100%);
+  border-bottom: 2px solid #e0e0e0;
+}
+
+.content-row {
+  transition: all 0.2s ease;
+  border-bottom: 1px solid #f0f0f0;
+}
+
+.content-row:hover {
+  background: linear-gradient(90deg, rgba(25, 118, 210, 0.02) 0%, rgba(25, 118, 210, 0.01) 100%);
+  transform: translateX(2px);
+  box-shadow: 2px 0 8px rgba(0,0,0,0.05);
+}
+
+.content-row:last-child {
+  border-bottom: none;
+}
+
+/* 정렬 가능한 헤더 */
+.sortable-header {
+  transition: all 0.2s ease;
+  border-radius: 4px;
+}
+
+.sortable-header:hover {
+  background: rgba(25, 118, 210, 0.08);
+  color: #1976D2;
+}
+
+/* 액션 버튼 */
+.action-btn {
+  transition: all 0.2s ease;
+}
+
+.action-btn:hover {
+  transform: scale(1.1);
+}
+
+/* 빈 상태 */
+.empty-state {
+  background: linear-gradient(145deg, #fafafa 0%, #f0f0f0 100%);
+  border-radius: 12px;
+  margin: 20px;
+}
+
+/* 다이얼로그 스타일 */
+.detail-dialog {
+  border-radius: 12px;
+  overflow: hidden;
+}
+
+.edit-field {
+  transition: all 0.3s ease;
+}
+
+.edit-field:hover {
+  box-shadow: 0 2px 8px rgba(0,0,0,0.1);
+}
+
+.content-display {
+  min-height: 100px;
+  border: 1px solid #e0e0e0;
+}
+
+.content-html {
+  line-height: 1.6;
+}
+
+.content-html img {
+  max-width: 100%;
+  height: auto;
+  border-radius: 8px;
+  margin: 8px 0;
+}
+
+.content-html p {
+  margin-bottom: 12px;
+}
+
+/* 페이지네이션 */
+.pagination-custom {
+  margin-top: 16px;
+}
+
+/* 반응형 디자인 */
+@media (max-width: 768px) {
+  .create-btn {
+    width: 100%;
+    min-width: unset;
+  }
+  
+  .content-row:hover {
+    transform: none;
+  }
+  
+  .chip-hover:hover {
+    transform: none;
+  }
+}
+
+/* 스크롤바 커스터마이징 */
+::-webkit-scrollbar {
+  width: 6px;
+}
+
+::-webkit-scrollbar-track {
+  background: #f1f1f1;
+  border-radius: 3px;
+}
+
+::-webkit-scrollbar-thumb {
+  background: #c1c1c1;
+  border-radius: 3px;
+}
+
+::-webkit-scrollbar-thumb:hover {
+  background: #a8a8a8;
+}
 </style>
\ No newline at end of file

From 7be3af65602566f19d9413923d69ff145bafef54 Mon Sep 17 00:00:00 2001
From: unknown <yyoooona@gmail.com>
Date: Wed, 18 Jun 2025 15:54:00 +0900
Subject: [PATCH 09/11] store source release

---
 src/store/store.js                |  722 +++++-----------
 src/views/StoreManagementView.vue | 1334 +++++++++++++++++------------
 2 files changed, 980 insertions(+), 1076 deletions(-)

diff --git a/src/store/store.js b/src/store/store.js
index a09960c..ef920ed 100644
--- a/src/store/store.js
+++ b/src/store/store.js
@@ -1,533 +1,243 @@
-//* src/services/store.js - 병합 충돌 해결된 매장 서비스
-import { storeApi, menuApi, handleApiError, formatSuccessResponse } from './api.js'
+//* src/store/content.js 수정 - 매장 정보 조회 후 콘텐츠 목록 조회
+import { defineStore } from 'pinia'
+import { ref, computed } from 'vue'
+import contentService from '@/services/content'
+import { useAuthStore } from '@/store/auth'
 
-/**
- * 매장 관련 API 서비스
- * 백엔드 Store Controller와 연동 (포트 8082)
- */
-class StoreService {
-  /**
-   * 매장 등록 (STR-015: 매장 등록)
-   * @param {Object} storeData - 매장 정보
-   * @returns {Promise<Object>} 매장 등록 결과
-   */
-  async registerStore(storeData) {
-    try {
-      console.log('=== 매장 등록 API 호출 ===')
-      console.log('요청 데이터:', storeData)
-      
-      // 백엔드 StoreCreateRequest에 맞는 형태로 변환
-      const requestData = {
-        storeName: storeData.storeName,
-        businessType: storeData.businessType,
-        address: storeData.address,
-        phoneNumber: storeData.phoneNumber,
-        businessHours: storeData.businessHours,
-        closedDays: storeData.closedDays,
-        seatCount: parseInt(storeData.seatCount) || 0,
-        instaAccounts: storeData.instaAccounts || '',
-        blogAccounts: storeData.blogAccounts || '',
-        description: storeData.description || ''
-      }
-      
-      console.log('=== 각 필드 상세 검증 ===')
-      console.log('storeName:', requestData.storeName, '(타입:', typeof requestData.storeName, ')')
-      console.log('businessType:', requestData.businessType, '(타입:', typeof requestData.businessType, ')')
-      console.log('address:', requestData.address, '(타입:', typeof requestData.address, ')')
-      console.log('seatCount:', requestData.seatCount, '(타입:', typeof requestData.seatCount, ')')
-      
-      console.log('백엔드 전송 데이터:', requestData)
-      
-      const response = await storeApi.post('/register', requestData)
-      
-      console.log('매장 등록 API 응답:', response.data)
-      
-      // 백엔드 응답 구조에 맞게 처리
-      if (response.data && (response.data.status === 200 || response.data.success !== false)) {
-        return {
-          success: true,
-          message: response.data.message || '매장이 등록되었습니다.',
-          data: response.data.data
-        }
-      } else {
-        throw new Error(response.data.message || '매장 등록에 실패했습니다.')
-      }
-    } catch (error) {
-      console.error('매장 등록 실패:', error)
-      
-      if (error.response) {
-        console.error('응답 상태:', error.response.status)
-        console.error('응답 데이터:', error.response.data)
-      }
-      
-      return handleApiError(error)
-    }
-  }
+export const useContentStore = defineStore('content', () => {
+  // 상태
+  const contentList = ref([])
+  const contents = ref([]) // ContentManagementView에서 사용하는 속성
+  const ongoingContents = ref([])
+  const selectedContent = ref(null)
+  const generatedContent = ref(null)
+  const isLoading = ref(false)
 
-  /**
-   * 매장 정보 조회 (STR-005: 매장 정보 관리)
-   * @returns {Promise<Object>} 매장 정보
-   */
-  async getStore() {
-    try {
-      console.log('=== 매장 정보 조회 API 호출 ===')
-      
-      // URL 슬래시 문제 해결: 빈 문자열로 호출하여 '/api/store'가 되도록 함
-      const response = await storeApi.get('')
-      
-      console.log('매장 정보 조회 API 응답:', response.data)
-      
-      // 백엔드 응답 구조 수정: 디버깅 결과에 맞게 처리
-      if (response.data && response.data.status === 200 && response.data.data) {
-        console.log('✅ 매장 정보 조회 성공:', response.data.data)
-        return {
-          success: true,
-          message: response.data.message || '매장 정보를 조회했습니다.',
-          data: response.data.data
-        }
-      } else if (response.data && response.data.status === 404) {
-        // 매장이 없는 경우
-        console.log('⚠️ 등록된 매장이 없음')
-        return {
-          success: false,
-          message: '등록된 매장이 없습니다',
-          data: null
-        }
-      } else {
-        console.warn('예상치 못한 응답 구조:', response.data)
-        throw new Error(response.data.message || '매장 정보를 찾을 수 없습니다.')
-      }
-    } catch (error) {
-      console.error('매장 정보 조회 실패:', error)
-      
-      // 404 오류 처리 (매장이 없음)
-      if (error.response?.status === 404) {
-        return {
-          success: false,
-          message: '등록된 매장이 없습니다',
-          data: null
-        }
-      }
-      
-      // 500 오류 처리 (서버 내부 오류)
-      if (error.response?.status === 500) {
-        console.error('서버 내부 오류 - 백엔드 로그 확인 필요:', error.response?.data)
-        return {
-          success: false,
-          message: '서버 오류가 발생했습니다. 관리자에게 문의하세요.',
-          data: null
-        }
-      }
-      
-      return handleApiError(error)
-    }
-  }
+  // computed 속성들
+  const contentCount = computed(() => contentList.value.length)
+  const ongoingContentCount = computed(() => ongoingContents.value.length)
 
-  /**
-   * 매장 정보 수정 (STR-010: 매장 수정)
-   * @param {number} storeId - 매장 ID (현재는 사용하지 않음 - JWT에서 사용자 확인)
-   * @param {Object} storeData - 수정할 매장 정보
-   * @returns {Promise<Object>} 매장 수정 결과
-   */
-  async updateStore(storeId, storeData) {
+  // 콘텐츠 목록 로딩 (ContentManagementView에서 사용)
+  const loadContents = async (filters = {}) => {
+    console.log('=== 콘텐츠 목록 조회 시작 ===')
+    isLoading.value = true
+    
     try {
-      console.log('=== 매장 정보 수정 API 호출 ===')
-      console.log('요청 데이터:', storeData)
+      // 1단계: 매장 정보 조회하여 실제 storeId 가져오기
+      const userInfo = useAuthStore().user
+      let storeId = null
       
-      // 백엔드 StoreUpdateRequest에 맞는 형태로 변환
-      const requestData = {
-        storeName: storeData.storeName,
-        businessType: storeData.businessType,
-        address: storeData.address,
-        phoneNumber: storeData.phoneNumber,
-        businessHours: storeData.businessHours,
-        closedDays: storeData.closedDays,
-        seatCount: parseInt(storeData.seatCount) || 0,
-        instaAccounts: storeData.instaAccounts || '',
-        blogAccounts: storeData.blogAccounts || '',
-        description: storeData.description || ''
-      }
-      
-      console.log('백엔드 전송 데이터:', requestData)
-      
-      // PUT 요청 (storeId는 JWT에서 추출하므로 URL에 포함하지 않음)
-      const response = await storeApi.put('/', requestData)
-      
-      console.log('매장 정보 수정 API 응답:', response.data)
-      
-      if (response.data && (response.data.status === 200 || response.data.success !== false)) {
-        return {
-          success: true,
-          message: response.data.message || '매장 정보가 수정되었습니다.',
-          data: response.data.data
-        }
-      } else {
-        throw new Error(response.data.message || '매장 정보 수정에 실패했습니다.')
-      }
-    } catch (error) {
-      console.error('매장 정보 수정 실패:', error)
-      return handleApiError(error)
-    }
-  }
-
-  /**
-   * 매출 정보 조회 (STR-020: 대시보드)
-   * @param {string} period - 조회 기간 (today, week, month, year)
-   * @returns {Promise<Object>} 매출 정보
-   */
-  async getSales(period = 'today') {
-    try {
-      console.log('=== 매출 정보 조회 API 호출 ===')
-      console.log('조회 기간:', period)
-      
-      // 현재는 목업 데이터 반환 (추후 실제 API 연동 시 수정)
-      const mockSalesData = {
-        todaySales: 150000,
-        yesterdaySales: 120000,
-        changeRate: 25.0,
-        monthlyTarget: 3000000,
-        achievementRate: 45.2,
-        yearSales: this.generateMockYearSales()
-      }
-      
-      // 매출 트렌드 분석 추가
-      if (mockSalesData.yearSales && mockSalesData.yearSales.length > 0) {
-        mockSalesData.trendAnalysis = this.analyzeSalesTrend(mockSalesData.yearSales)
-        mockSalesData.chartData = this.prepareChartData(mockSalesData.yearSales)
-      }
-      
-      return formatSuccessResponse(mockSalesData, '매출 정보를 조회했습니다.')
-    } catch (error) {
-      console.error('매출 정보 조회 실패:', error)
-      return handleApiError(error)
-    }
-  }
-
-  /**
-   * 메뉴 목록 조회 (최종 통합 버전 - 모든 충돌 해결)
-   * @param {number} storeId - 매장 ID (옵션, 없으면 목업 데이터 반환)
-   * @returns {Promise<Object>} 메뉴 목록
-   */
-  async getMenus(storeId) {
-    try {
-      console.log('=== 메뉴 목록 조회 API 호출 ===')
-      console.log('매장 ID:', storeId)
-      
-      // storeId가 없으면 목업 데이터 반환 (개발 중)
-      if (!storeId) {
-        console.warn('매장 ID가 없어서 목업 데이터 반환')
-        const mockMenus = [
-          {
-            menuId: 1, // id 대신 menuId 사용
-            id: 1, // 호환성을 위해
-            name: '아메리카노',
-            menuName: '아메리카노', // 백엔드 형식
-            price: 4000,
-            category: '커피',
-            description: '진한 풍미의 아메리카노',
-            imageUrl: '/images/americano.jpg',
-            isAvailable: true,
-            available: true // 백엔드 형식
-          },
-          {
-            menuId: 2,
-            id: 2,
-            name: '카페라떼',
-            menuName: '카페라떼',
-            price: 4500,
-            category: '커피',
-            description: '부드러운 우유가 들어간 라떼',
-            imageUrl: '/images/latte.jpg',
-            isAvailable: true,
-            available: true
-          }
-        ]
-        return formatSuccessResponse(mockMenus, '목업 메뉴 목록을 조회했습니다.')
-      }
-      
-      // 실제 백엔드 API 호출 시도
       try {
-        // GET /api/menu?storeId={storeId}
-        const response = await menuApi.get('', {
-          params: { storeId }
+        // 매장 정보 API 호출
+        const storeApiUrl = (window.__runtime_config__ && window.__runtime_config__.STORE_URL) 
+          ? window.__runtime_config__.STORE_URL 
+          : 'http://localhost:8082/api/store'
+        
+        console.log('매장 API URL:', storeApiUrl)
+        
+        const token = localStorage.getItem('accessToken') || localStorage.getItem('auth_token') || localStorage.getItem('token')
+        const storeResponse = await fetch(`${storeApiUrl}`, {
+          headers: {
+            'Authorization': `Bearer ${token}`,
+            'Content-Type': 'application/json'
+          }
         })
         
-        console.log('메뉴 목록 조회 API 응답:', response.data)
-        
-        if (response.data && response.data.status === 200) {
-          // 백엔드에서 받은 메뉴 데이터를 프론트엔드 형식으로 변환
-          const menus = response.data.data.map(menu => ({
-            menuId: menu.menuId,
-            id: menu.menuId, // 호환성을 위해
-            storeId: menu.storeId,
-            menuName: menu.menuName,
-            name: menu.menuName, // 호환성을 위해
-            category: menu.category,
-            price: menu.price,
-            description: menu.description,
-            available: menu.available !== undefined ? menu.available : true,
-            isAvailable: menu.available !== undefined ? menu.available : true, // 호환성
-            imageUrl: menu.imageUrl || '/images/menu-placeholder.png',
-            createdAt: menu.createdAt,
-            updatedAt: menu.updatedAt
-          }))
-          
-          return formatSuccessResponse(menus, '메뉴 목록을 조회했습니다.')
+        if (storeResponse.ok) {
+          const storeData = await storeResponse.json()
+          storeId = storeData.data?.storeId
+          console.log('✅ 매장 정보 조회 성공, storeId:', storeId)
         } else {
-          throw new Error(response.data.message || '메뉴 목록을 찾을 수 없습니다.')
+          throw new Error(`매장 정보 조회 실패: ${storeResponse.status}`)
         }
-      } catch (apiError) {
-        console.error('백엔드 API 호출 실패:', apiError)
-        
-        // 백엔드 미구현이나 네트워크 오류 시 목업 데이터 반환
-        if (apiError.response?.status === 404 || 
-            apiError.code === 'ECONNREFUSED' || 
-            apiError.message.includes('Network Error')) {
-          console.warn('백엔드 미구현 - 목업 데이터 반환')
-          
-          const mockMenus = [
-            {
-              menuId: 1,
-              id: 1,
-              storeId: storeId,
-              name: '아메리카노',
-              menuName: '아메리카노',
-              price: 4000,
-              category: '커피',
-              description: '진한 풍미의 아메리카노',
-              imageUrl: '/images/americano.jpg',
-              isAvailable: true,
-              available: true
-            },
-            {
-              menuId: 2,
-              id: 2,
-              storeId: storeId,
-              name: '카페라떼',
-              menuName: '카페라떼',
-              price: 4500,
-              category: '커피',
-              description: '부드러운 우유가 들어간 라떼',
-              imageUrl: '/images/latte.jpg',
-              isAvailable: true,
-              available: true
-            }
-          ]
-          
-          return formatSuccessResponse(mockMenus, '목업 메뉴 목록을 조회했습니다. (백엔드 미구현)')
-        }
-        
-        throw apiError
+      } catch (error) {
+        console.error('❌ 매장 정보 조회 실패:', error)
+        throw new Error('매장 정보를 조회할 수 없습니다.')
+      }
+      
+      if (!storeId) {
+        throw new Error('매장 ID를 찾을 수 없습니다.')
+      }
+      
+      console.log('사용자 정보:', userInfo)
+      console.log('조회된 storeId:', storeId)
+
+      // 2단계: 조회된 storeId로 콘텐츠 목록 조회
+      const apiFilters = {
+        platform: filters.platform || null, // 전체, INSTAGRAM, NAVER_BLOG, POSTER 등
+        storeId: storeId,
+        sortBy: filters.sortBy || 'latest'
+        // contentType, period는 백엔드에서 사용하지 않으므로 제외
+      }
+      
+      console.log('API 요청 필터:', apiFilters)
+      
+      const result = await contentService.getContents(apiFilters)
+      
+      console.log('🔍 contentService.getContents 결과:', result)
+      console.log('🔍 result.success:', result.success)
+      console.log('🔍 result.data:', result.data)
+      console.log('🔍 result.data 타입:', typeof result.data)
+      console.log('🔍 result.data 길이:', result.data?.length)
+
+
+      if (result.success) {
+        contents.value = result.data || []
+        contentList.value = result.data || []
+        console.log('✅ 콘텐츠 로딩 성공:', contents.value.length, '개')
+        return { success: true }
+      } else {
+        console.error('❌ 콘텐츠 로딩 실패:', result.error)
+        contents.value = []
+        contentList.value = []
+        return { success: false, error: result.error }
       }
     } catch (error) {
-      console.error('메뉴 목록 조회 실패:', error)
-      return handleApiError(error)
+      console.error('❌ 콘텐츠 로딩 실패:', error)
+      contents.value = []
+      contentList.value = []
+      return { success: false, error: error.message || '네트워크 오류가 발생했습니다.' }
+    } finally {
+      isLoading.value = false
     }
   }
 
-  /**
-   * 메뉴 목록 조회 별칭 (fetchMenus)
-   * @param {number} storeId - 매장 ID
-   * @returns {Promise<Object>} 메뉴 목록
-   */
-  async fetchMenus(storeId) {
-    return await this.getMenus(storeId)
-  }
-
-  /**
-   * 목업 메뉴 데이터 생성
-   * @param {number} storeId - 매장 ID (옵션)
-   * @returns {Array} 목업 메뉴 배열
-   */
-  getMockMenus(storeId = null) {
-    return [
-      {
-        menuId: 1,
-        id: 1,
-        storeId: storeId,
-        name: '아메리카노',
-        menuName: '아메리카노',
-        price: 4000,
-        category: '커피',
-        description: '진한 풍미의 아메리카노',
-        imageUrl: '/images/americano.jpg',
-        isAvailable: true,
-        available: true
-      },
-      {
-        menuId: 2,
-        id: 2,
-        storeId: storeId,
-        name: '카페라떼',
-        menuName: '카페라떼',
-        price: 4500,
-        category: '커피',
-        description: '부드러운 우유가 들어간 라떼',
-        imageUrl: '/images/latte.jpg',
-        isAvailable: true,
-        available: true
-      },
-      {
-        menuId: 3,
-        id: 3,
-        storeId: storeId,
-        name: '에스프레소',
-        menuName: '에스프레소',
-        price: 3500,
-        category: '커피',
-        description: '진한 에스프레소 한 잔',
-        imageUrl: '/images/espresso.jpg',
-        isAvailable: true,
-        available: true
-      }
-    ]
-  }
-
-  /**
-   * 목업 연간 매출 데이터 생성
-   * @returns {Array} 목업 매출 데이터
-   */
-  generateMockYearSales() {
-    const salesData = []
-    const today = new Date()
+  // AI 콘텐츠 생성
+  const generateContent = async (type, formData) => {
+    isLoading.value = true
     
-    // 최근 90일 데이터 생성
-    for (let i = 89; i >= 0; i--) {
-      const date = new Date(today)
-      date.setDate(date.getDate() - i)
-      
-      // 랜덤하지만 현실적인 매출 패턴 생성
-      const baseAmount = 120000 + Math.random() * 80000 // 120,000 ~ 200,000
-      const weekendBonus = date.getDay() === 0 || date.getDay() === 6 ? 1.3 : 1.0
-      const monthlyTrend = 1 + (Math.sin(i / 30) * 0.2) // 월별 트렌드
-      
-      salesData.push({
-        salesDate: date.toISOString().split('T')[0],
-        salesAmount: Math.round(baseAmount * weekendBonus * monthlyTrend)
-      })
-    }
-    
-    return salesData
-  }
-
-  /**
-   * 매출 트렌드 분석 및 변곡점 계산
-   * @param {Array} yearSales - 연간 매출 데이터
-   * @returns {Object} 트렌드 분석 결과
-   */
-  analyzeSalesTrend(yearSales) {
-    if (!yearSales || yearSales.length < 7) {
-      return {
-        inflectionPoints: [],
-        overallTrend: 'insufficient_data',
-        growthRate: 0
+    try {
+      let result
+      if (type === 'sns') {
+        result = await contentService.generateSnsContent(formData)
+      } else if (type === 'poster') {
+        result = await contentService.generatePoster(formData)
       }
-    }
-
-    // 날짜순 정렬
-    const sortedData = [...yearSales].sort((a, b) => 
-      new Date(a.salesDate) - new Date(b.salesDate)
-    )
-
-    const inflectionPoints = []
-    const dailyData = sortedData.map(item => ({
-      date: item.salesDate,
-      amount: parseFloat(item.salesAmount) || 0
-    }))
-
-    // 7일 이동평균으로 변곡점 탐지
-    for (let i = 7; i < dailyData.length - 7; i++) {
-      const prevWeekAvg = this.calculateMovingAverage(dailyData, i - 7, 7)
-      const currentWeekAvg = this.calculateMovingAverage(dailyData, i, 7)
-      const nextWeekAvg = this.calculateMovingAverage(dailyData, i + 7, 7)
       
-      const trend1 = currentWeekAvg - prevWeekAvg
-      const trend2 = nextWeekAvg - currentWeekAvg
-      
-      // 변곡점 조건: 트렌드 방향 변화 + 임계값 초과
-      if (Math.sign(trend1) !== Math.sign(trend2) && 
-          Math.abs(trend1) > 10000 && Math.abs(trend2) > 10000) {
-        
-        inflectionPoints.push({
-          date: dailyData[i].date,
-          amount: dailyData[i].amount,
-          type: trend1 > 0 ? 'peak' : 'valley',
-          significance: Math.abs(trend1) + Math.abs(trend2)
-        })
+      if (result.success) {
+        generatedContent.value = result.data
+        return { success: true, data: result.data }
+      } else {
+        return { success: false, error: result.message }
       }
-    }
-
-    // 전체 트렌드 계산
-    const firstWeekAvg = this.calculateMovingAverage(dailyData, 0, 7)
-    const lastWeekAvg = this.calculateMovingAverage(dailyData, dailyData.length - 7, 7)
-    const growthRate = ((lastWeekAvg - firstWeekAvg) / firstWeekAvg) * 100
-
-    let overallTrend = 'stable'
-    if (Math.abs(growthRate) > 5) {
-      overallTrend = growthRate > 0 ? 'increasing' : 'decreasing'
-    }
-
-    console.log('변곡점 분석 결과:', { inflectionPoints, overallTrend, growthRate })
-
-    return {
-      inflectionPoints: inflectionPoints.slice(0, 5), // 상위 5개만
-      overallTrend,
-      growthRate: Math.round(growthRate * 10) / 10
+    } catch (error) {
+      return { success: false, error: '네트워크 오류가 발생했습니다.' }
+    } finally {
+      isLoading.value = false
     }
   }
 
-  /**
-   * 이동평균 계산
-   * @param {Array} data - 데이터 배열
-   * @param {number} startIndex - 시작 인덱스
-   * @param {number} period - 기간
-   * @returns {number} 이동평균값
-   */
-  calculateMovingAverage(data, startIndex, period) {
-    const slice = data.slice(startIndex, startIndex + period)
-    const sum = slice.reduce((acc, item) => acc + item.amount, 0)
-    return sum / slice.length
-  }
-
-  /**
-   * 차트용 데이터 준비
-   * @param {Array} yearSales - 연간 매출 데이터
-   * @returns {Object} 차트 데이터
-   */
-  prepareChartData(yearSales) {
-    if (!yearSales || yearSales.length === 0) {
-      return { labels: [], salesData: [], targetData: [] }
-    }
-
-    // 최근 30일 데이터만 사용 (차트 표시용)
-    const sortedData = [...yearSales]
-      .sort((a, b) => new Date(a.salesDate) - new Date(b.salesDate))
-      .slice(-30)
-
-    const labels = sortedData.map(item => {
-      const date = new Date(item.salesDate)
-      return `${date.getMonth() + 1}/${date.getDate()}`
-    })
-
-    const salesData = sortedData.map(item => parseFloat(item.salesAmount) || 0)
+  // 콘텐츠 저장
+  const saveContent = async (type, contentData) => {
+    isLoading.value = true
     
-    // 목표 매출 라인 (평균의 110%)
-    const averageSales = salesData.reduce((a, b) => a + b, 0) / salesData.length
-    const targetData = salesData.map(() => Math.round(averageSales * 1.1))
-
-    return {
-      labels,
-      salesData,
-      targetData
+    try {
+      let result
+      if (type === 'sns') {
+        result = await contentService.saveSnsContent(contentData)
+      } else if (type === 'poster') {
+        result = await contentService.savePoster(contentData)
+      }
+      
+      if (result.success) {
+        // 콘텐츠 목록 새로고침
+        await loadContents()
+        return { success: true, message: '콘텐츠가 저장되었습니다.' }
+      } else {
+        return { success: false, error: result.message }
+      }
+    } catch (error) {
+      return { success: false, error: '네트워크 오류가 발생했습니다.' }
+    } finally {
+      isLoading.value = false
     }
   }
-}
 
-// 싱글톤 인스턴스 생성 및 export
-export const storeService = new StoreService()
-export default storeService
+  // fetchContentList - 기존 호환성 유지
+  const fetchContentList = async (filters = {}) => {
+    return await loadContents(filters)
+  }
 
-// 디버깅을 위한 전역 노출 (개발 환경에서만)
-if (process.env.NODE_ENV === 'development') {
-  window.storeService = storeService
-}
\ No newline at end of file
+  // 진행 중인 콘텐츠 조회
+  const fetchOngoingContents = async (period = 'month') => {
+    isLoading.value = true
+    
+    try {
+      const result = await contentService.getOngoingContents(period)
+      
+      if (result.success) {
+        ongoingContents.value = result.data
+        return { success: true }
+      } else {
+        return { success: false, error: result.message }
+      }
+    } catch (error) {
+      return { success: false, error: '네트워크 오류가 발생했습니다.' }
+    } finally {
+      isLoading.value = false
+    }
+  }
+
+  // 콘텐츠 수정
+  const updateContent = async (contentId, updateData) => {
+    isLoading.value = true
+    
+    try {
+      const result = await contentService.updateContent(contentId, updateData)
+      
+      if (result.success) {
+        await loadContents()
+        return { success: true, message: '콘텐츠가 수정되었습니다.' }
+      } else {
+        return { success: false, error: result.message }
+      }
+    } catch (error) {
+      return { success: false, error: '네트워크 오류가 발생했습니다.' }
+    } finally {
+      isLoading.value = false
+    }
+  }
+
+  // 콘텐츠 삭제
+  const deleteContent = async (contentId) => {
+    isLoading.value = true
+    
+    try {
+      const result = await contentService.deleteContent(contentId)
+      
+      if (result.success) {
+        await loadContents()
+        return { success: true, message: '콘텐츠가 삭제되었습니다.' }
+      } else {
+        return { success: false, error: result.message }
+      }
+    } catch (error) {
+      return { success: false, error: '네트워크 오류가 발생했습니다.' }
+    } finally {
+      isLoading.value = false
+    }
+  }
+
+  return {
+    // 상태
+    contentList,
+    contents, // ContentManagementView에서 사용
+    ongoingContents,
+    selectedContent,
+    generatedContent,
+    isLoading,
+    
+    // 컴퓨티드
+    contentCount,
+    ongoingContentCount,
+    
+    // 메서드
+    loadContents, // 새로 추가된 메서드
+    generateContent,
+    saveContent,
+    fetchContentList, // 기존 호환성 유지
+    fetchOngoingContents,
+    updateContent,
+    deleteContent
+  }
+})
\ No newline at end of file
diff --git a/src/views/StoreManagementView.vue b/src/views/StoreManagementView.vue
index 4a1250c..a24f8c2 100644
--- a/src/views/StoreManagementView.vue
+++ b/src/views/StoreManagementView.vue
@@ -1,404 +1,789 @@
 <template>
   <v-container fluid class="pa-4">
-    <!-- 🎨 소이님 UI 개선: 필터 → 검색+버튼 순서로 변경 -->
-    <v-card class="mb-6" elevation="2">
-      <v-card-text class="pa-4">
-        <!-- 1단계: 필터 탭들 (전체 너비로 배치) -->
-        <v-row class="mb-4">
-          <v-col cols="12">
-            <div class="d-flex align-center flex-wrap ga-2">
-              <span class="text-subtitle-2 font-weight-medium mr-3 text-grey-darken-1">콘텐츠 타입:</span>
-              <v-chip
-                v-for="type in contentTypeOptions"
-                :key="type.value"
-                :color="selectedContentType === type.value ? type.color : 'default'"
-                :variant="selectedContentType === type.value ? 'flat' : 'outlined'"
-                size="small"
-                class="mr-2 mb-1 chip-hover"
-                @click="selectContentType(type.value)"
-              >
-                <span class="mr-1">{{ type.emoji }}</span>
-                {{ type.title.replace(type.emoji + ' ', '') }}
-                <span v-if="type.value !== 'all'" class="ml-1">({{ getTypeCount(type.value) }})</span>
-                <span v-else class="ml-1">({{ getTotalCount() }})</span>
-              </v-chip>
-            </div>
-          </v-col>
-        </v-row>
+    <!-- 뒤로가기 버튼과 제목 -->
+    <div class="d-flex align-center mb-4">
+      <v-btn
+        icon
+        variant="text"
+        @click="$router.go(-1)"
+        class="me-2"
+      >
+        <v-icon>mdi-arrow-left</v-icon>
+      </v-btn>
+      <h1 class="text-h5 font-weight-bold">매장 관리</h1>
+    </div>
 
-        <!-- 2단계: 검색박스 + 새 콘텐츠 생성 버튼 (같은 줄에 배치) -->
-        <v-row align="center" class="ga-3">
-          <!-- 검색박스 (왼쪽, 넓게) -->
-          <v-col cols="12" md="9">
-            <v-text-field
-              v-model="searchQuery"
-              label="제목, 내용, 해시태그로 검색..."
-              prepend-inner-icon="mdi-magnify"
-              variant="outlined"
-              density="comfortable"
-              clearable
-              hide-details
-              class="search-field"
-              @update:model-value="applyFilters"
+    <!-- 매장 정보가 없는 경우 -->
+    <div v-if="!storeStore.hasStoreInfo && !storeStore.loading">
+      <v-row justify="center">
+        <v-col cols="12" md="8">
+          <v-card class="text-center pa-8" elevation="4">
+            <v-img
+              src="/images/store-placeholder.png"
+              max-width="200"
+              class="mx-auto mb-4"
             />
-          </v-col>
-          
-          <!-- 새 콘텐츠 생성 버튼 (오른쪽) -->
-          <v-col cols="12" md="3" class="d-flex justify-end">
+            <h2 class="text-h5 font-weight-bold mb-3">첫 매장을 등록해볼까요?</h2>
+            <p class="text-grey mb-4">
+              매장 정보를 등록하면 AI 마케팅 서비스를 이용할 수 있습니다
+            </p>
+            <div class="d-flex flex-column gap-3">
+              <v-btn
+                color="primary"
+                size="large"
+                prepend-icon="mdi-store-plus"
+                @click="openCreateDialog"
+              >
+                매장 정보 등록하기
+              </v-btn>
+            </div>
+          </v-card>
+        </v-col>
+      </v-row>
+    </div>
+
+    <!-- 매장 정보가 있는 경우 -->
+    <div v-else-if="storeStore.hasStoreInfo">
+      <!-- 탭 메뉴 -->
+      <v-row class="mb-4">
+        <v-col cols="12">
+          <v-tabs v-model="currentTab" color="primary">
+            <v-tab value="basic">기본 정보</v-tab>
+            <v-tab value="menu">메뉴 관리</v-tab>
+          </v-tabs>
+        </v-col>
+      </v-row>
+
+      <v-tabs-window v-model="currentTab">
+        <!-- 기본 정보 탭 -->
+        <v-tabs-window-item value="basic">
+          <v-card elevation="2">
+            <v-card-title class="pa-4 d-flex align-center justify-space-between">
+              <div class="d-flex align-center">
+                <v-icon class="mr-2" color="primary">mdi-store</v-icon>
+                매장 기본 정보
+              </div>
+              <v-btn
+                color="primary"
+                variant="outlined"
+                prepend-icon="mdi-pencil"
+                @click="editBasicInfo"
+              >
+                수정
+              </v-btn>
+            </v-card-title>
+            
+            <v-divider />
+            
+            <v-card-text class="pa-6">
+              <v-row>
+                <!-- 매장 이미지 -->
+                <v-col cols="12" md="4" class="text-center">
+                  <v-avatar size="120" class="mb-3">
+                    <v-img
+                      :src="storeInfo.imageUrl || '/images/store-placeholder.png'"
+                      alt="매장 이미지"
+                    />
+                  </v-avatar>
+                  <h3 class="text-h6 font-weight-bold">{{ storeInfo.storeName }}</h3>
+                  <p class="text-grey">{{ storeInfo.businessType }}</p>
+                </v-col>
+
+                <!-- 기본 정보 -->
+                <v-col cols="12" md="8">
+                  <v-row>
+                    <v-col cols="12" sm="6">
+                      <div class="info-item">
+                        <v-icon class="mr-2" color="grey">mdi-map-marker</v-icon>
+                        <div>
+                          <div class="text-caption text-grey">주소</div>
+                          <div class="text-body-1">{{ storeInfo.address || '미입력' }}</div>
+                        </div>
+                      </div>
+                    </v-col>
+                    
+                    <v-col cols="12" sm="6">
+                      <div class="info-item">
+                        <v-icon class="mr-2" color="grey">mdi-phone</v-icon>
+                        <div>
+                          <div class="text-caption text-grey">전화번호</div>
+                          <div class="text-body-1">{{ storeInfo.phoneNumber || '미입력' }}</div>
+                        </div>
+                      </div>
+                    </v-col>
+                    
+                    <v-col cols="12" sm="6">
+                      <div class="info-item">
+                        <v-icon class="mr-2" color="grey">mdi-clock</v-icon>
+                        <div>
+                          <div class="text-caption text-grey">영업시간</div>
+                          <div class="text-body-1">{{ storeInfo.businessHours || '미입력' }}</div>
+                        </div>
+                      </div>
+                    </v-col>
+                
+                    <v-col cols="12" sm="6">
+                      <div class="info-item">
+                        <v-icon class="mr-2" color="grey">mdi-account-group</v-icon>
+                        <div>
+                          <div class="text-caption text-grey">좌석 수</div>
+                          <div class="text-body-1">{{ storeInfo.seatCount || 0 }}석</div>
+                        </div>
+                      </div>
+                    </v-col>
+                    
+                    <v-col cols="12" sm="6">
+                      <div class="info-item">
+                        <v-icon class="mr-2" color="grey">mdi-calendar-off</v-icon>
+                        <div>
+                          <div class="text-caption text-grey">휴무일</div>
+                          <div class="text-body-1">{{ formatClosedDays(storeInfo.holidays) }}</div>
+                        </div>
+                      </div>
+                    </v-col>
+                    
+                    <v-col cols="12" sm="6">
+                      <div class="info-item">
+                        <v-icon class="mr-2" color="grey">mdi-instagram</v-icon>
+                        <div>
+                          <div class="text-caption text-grey">인스타그램</div>
+                          <div class="text-body-1">{{ storeInfo.instaAccounts || '미입력' }}</div>
+                        </div>
+                      </div>
+                    </v-col>
+                  </v-row>
+                  
+                  <!-- 매장 소개 -->
+                  <v-divider class="my-4" />
+                  <div class="info-item">
+                    <v-icon class="mr-2" color="grey">mdi-text</v-icon>
+                    <div>
+                      <div class="text-caption text-grey">매장 소개</div>
+                      <div class="text-body-1">{{ storeInfo.description || '매장 소개가 없습니다' }}</div>
+                    </div>
+                  </div>
+                </v-col>
+              </v-row>
+            </v-card-text>
+          </v-card>
+        </v-tabs-window-item>
+
+        <!-- 메뉴 관리 탭 -->
+        <v-tabs-window-item value="menu">
+          <!-- 검색 및 필터 섹션 -->
+          <v-card class="mb-4" elevation="2">
+            <v-card-text>
+              <v-row>
+                <v-col cols="12" md="6">
+                  <v-text-field
+                    v-model="menuSearch"
+                    prepend-inner-icon="mdi-magnify"
+                    label="메뉴 검색"
+                    variant="outlined"
+                    density="compact"
+                    clearable
+                  />
+                </v-col>
+                <v-col cols="12" md="3">
+                  <v-select
+                    v-model="menuCategoryFilter"
+                    :items="['전체', ...menuCategories]"
+                    label="카테고리"
+                    variant="outlined"
+                    density="compact"
+                  />
+                </v-col>
+                <v-col cols="12" md="3" class="d-flex align-center gap-2">
+                  <v-btn
+                    color="primary"
+                    variant="outlined"
+                    prepend-icon="mdi-filter-off"
+                    @click="clearFilters"
+                    size="small"
+                  >
+                    필터 초기화
+                  </v-btn>
+                  <v-btn
+                    color="primary"
+                    prepend-icon="mdi-plus"
+                    @click="openCreateMenuDialog"
+                    size="small"
+                  >
+                    메뉴 추가
+                  </v-btn>
+                </v-col>
+              </v-row>
+            </v-card-text>
+          </v-card>
+
+          <!-- 메뉴 목록 -->
+          <div v-if="filteredMenus.length > 0">
+            <v-row>
+              <v-col
+                v-for="menu in filteredMenus"
+                :key="menu.id || menu.menuId"
+                cols="12"
+                sm="6"
+                md="4"
+                lg="3"
+              >
+                <v-card
+                  class="menu-card h-100"
+                  elevation="2"
+                  @click="viewMenuDetail(menu)"
+                >
+                  <div class="position-relative">
+                    <!-- 메뉴 카드에서 이미지 표시 수정 -->
+                    <v-img
+                      :src="getMenuImageUrl(menu)"
+                      height="200"
+                      cover
+                      class="grey lighten-2"
+                      @error="handleImageError($event, menu)"
+                    >
+                      <template v-slot:placeholder>
+                        <div class="d-flex align-center justify-center fill-height">
+                          <v-progress-circular
+                            color="grey-lighten-4"
+                            indeterminate
+                          />
+                        </div>
+                      </template>
+                      <!-- 이미지 로딩 실패 시 플레이스홀더 표시 -->
+                      <template v-slot:error>
+                        <div class="d-flex align-center justify-center fill-height">
+                          <v-icon size="64" color="grey-lighten-2">mdi-image-off</v-icon>
+                        </div>
+                      </template>
+                    </v-img>
+                    
+                    <!-- 상태 뱃지 -->
+                    <div class="position-absolute top-0 right-0 pa-2">
+                      <v-chip
+                        v-if="!menu.available"
+                        color="red"
+                        size="small"
+                        class="mb-1"
+                      >
+                        품절
+                      </v-chip>
+                      <v-chip
+                        v-if="menu.recommended"
+                        color="orange"
+                        size="small"
+                      >
+                        추천
+                      </v-chip>
+                    </div>
+                    
+                    <!-- 액션 버튼 -->
+                    <div class="position-absolute top-0 left-0 pa-2">
+                      <v-btn
+                        icon="mdi-pencil"
+                        size="small"
+                        color="white"
+                        variant="elevated"
+                        @click.stop="editMenu(menu)"
+                        class="me-1"
+                      />
+                      <v-btn
+                        icon="mdi-delete"
+                        size="small"
+                        color="red"
+                        variant="elevated"
+                        @click.stop="confirmDeleteMenu(menu)"
+                      />
+                    </div>
+                  </div>
+                  
+                  <v-card-text class="pa-3">
+                    <div class="d-flex justify-space-between align-start mb-2">
+                      <h4 class="text-subtitle-1 font-weight-bold">
+                        {{ menu.menuName || menu.name }}
+                      </h4>
+                      <v-chip
+                        :color="menu.available ? 'green' : 'red'"
+                        size="small"
+                        variant="tonal"
+                      >
+                        {{ menu.available ? '판매중' : '품절' }}
+                      </v-chip>
+                    </div>
+                    
+                    <p class="text-body-2 text-grey text-truncate-2 mb-2">
+                      {{ menu.description || '설명이 없습니다' }}
+                    </p>
+                    
+                    <div class="d-flex justify-space-between align-center">
+                      <span class="text-h6 font-weight-bold text-primary">
+                        {{ menu.price ? menu.price.toLocaleString() : '0' }}원
+                      </span>
+                      <v-chip
+                        size="small"
+                        variant="outlined"
+                        color="primary"
+                      >
+                        {{ menu.category }}
+                      </v-chip>
+                    </div>
+                  </v-card-text>
+                </v-card>
+              </v-col>
+            </v-row>
+          </div>
+
+          <!-- 메뉴가 없는 경우 -->
+          <v-card v-else class="text-center pa-8" elevation="2">
+            <v-icon size="64" color="grey-lighten-1" class="mb-4">mdi-food-off</v-icon>
+            <h3 class="text-h6 mb-2">등록된 메뉴가 없습니다</h3>
+            <p class="text-grey mb-4">첫 번째 메뉴를 등록해보세요</p>
             <v-btn
               color="primary"
               prepend-icon="mdi-plus"
-              @click="$router.push('/content/create')"
-              size="large"
-              class="text-none font-weight-medium create-btn"
-              elevation="2"
+              @click="openCreateMenuDialog"
             >
-              새 콘텐츠 생성
+              메뉴 등록하기
             </v-btn>
-          </v-col>
-        </v-row>
-      </v-card-text>
-    </v-card>
-
-    <!-- 선택된 항목 일괄 작업 -->
-    <div v-if="selectedItems.length > 0" class="mb-4">
-      <v-alert color="info" variant="tonal" class="selected-alert">
-        <div class="d-flex justify-space-between align-center">
-          <span class="font-weight-medium">{{ selectedItems.length }}개 항목이 선택됨</span>
-          <v-btn
-            color="error"
-            variant="text"
-            prepend-icon="mdi-delete"
-            @click="deleteSelectedItems"
-            class="font-weight-medium"
-          >
-            선택 항목 삭제
-          </v-btn>
-        </div>
-      </v-alert>
+          </v-card>
+        </v-tabs-window-item>
+      </v-tabs-window>
     </div>
 
-    <!-- 콘텐츠 목록 -->
-    <v-card elevation="2">
-      <v-card-text class="pa-0">
-        <div v-if="loading" class="text-center pa-8">
-          <v-progress-circular indeterminate color="primary" size="48" width="4" />
-          <div class="mt-4 text-body-1 text-grey-darken-1">콘텐츠를 불러오는 중...</div>
-        </div>
+    <!-- 로딩 상태 -->
+    <div v-else class="text-center pa-8">
+      <v-progress-circular indeterminate color="primary" size="64" />
+      <p class="text-grey mt-4">매장 정보를 불러오는 중...</p>
+    </div>
 
-        <div v-else-if="paginatedContents.length === 0" class="text-center pa-12 empty-state">
-          <v-icon size="80" color="grey-lighten-2" class="mb-4">mdi-file-document-outline</v-icon>
-          <div class="text-h6 mb-3 text-grey-darken-1">표시할 콘텐츠가 없습니다</div>
-          <div class="text-body-2 text-grey mb-6">새로운 콘텐츠를 생성해보세요</div>
-          <v-btn
-            color="primary"
-            size="large"
-            prepend-icon="mdi-plus"
-            @click="$router.push('/content/create')"
-            class="font-weight-medium"
-            elevation="2"
-          >
-            콘텐츠 생성하기
-          </v-btn>
-        </div>
-
-        <!-- 콘텐츠 목록 테이블 -->
-        <div v-else>
-          <v-table hover class="content-table">
-            <thead>
-              <tr class="table-header">
-                <th width="50" class="pa-4">
-                  <v-checkbox
-                    v-model="selectAll"
-                    @change="toggleSelectAll"
-                    density="compact"
-                    color="primary"
-                  />
-                </th>
-                <th width="450" class="pa-4 font-weight-bold text-grey-darken-2">제목</th>
-                <th width="150" class="pa-4 font-weight-bold text-grey-darken-2">플랫폼</th>
-                <th width="200" class="pa-4 sortable-header cursor-pointer" @click="sortByPromotionDate">
-                  <div class="d-flex align-center">
-                    <span class="font-weight-bold text-grey-darken-2">프로모션 기간</span>
-                    <v-icon 
-                      :color="promotionSortOrder === 'none' ? 'grey-lighten-1' : 'primary'"
-                      size="18" 
-                      class="ml-2"
-                    >
-                      {{
-                        promotionSortOrder === 'asc' ? 'mdi-arrow-up' :
-                        promotionSortOrder === 'desc' ? 'mdi-arrow-down' :
-                        'mdi-unfold-more-horizontal'
-                      }}
-                    </v-icon>
-                  </div>
-                </th>
-                <th width="120" class="pa-4 font-weight-bold text-grey-darken-2">액션</th>
-              </tr>
-            </thead>
-            <tbody>
-              <tr 
-                v-for="content in paginatedContents" 
-                :key="content.id" 
-                class="content-row cursor-pointer" 
-                @click="showDetail(content)"
-              >
-                <td class="pa-4" @click.stop>
-                  <v-checkbox
-                    v-model="selectedItems"
-                    :value="content.id"
-                    density="compact"
-                    color="primary"
-                  />
-                </td>
-                <td class="pa-4">
-                  <div class="d-flex flex-column">
-                    <div class="d-flex align-center mb-2">
-                      <span class="font-weight-medium text-subtitle-2 mr-3">{{ content.title }}</span>
-                      <v-chip
-                        :color="getStatusColor(content.status)"
-                        size="x-small"
-                        variant="tonal"
-                        class="font-weight-medium"
-                      >
-                        {{ getStatusText(content.status) }}
-                      </v-chip>
-                    </div>
-                    <div class="text-caption text-truncate text-grey-darken-1" style="max-width: 400px;">
-                      {{ content.content ? content.content.replace(/<[^>]*>/g, '').substring(0, 100) + '...' : 'string...' }}
-                    </div>
-                  </div>
-                </td>
-                <td class="pa-4">
-                  <v-chip
-                    :color="getPlatformColor(content.platform)"
-                    size="small"
-                    variant="tonal"
-                    class="font-weight-medium"
-                  >
-                    {{ getPlatformText(content.platform) }}
-                  </v-chip>
-                </td>
-                <td class="pa-4">
-                  <div class="text-body-2 text-grey-darken-1">
-                    {{ formatDateRange(content.startDate, content.endDate) }}
-                  </div>
-                </td>
-                <td class="pa-4" @click.stop>
-                  <div class="d-flex align-center ga-1">
-                    <v-btn
-                      icon="mdi-pencil"
-                      size="small"
-                      variant="text"
-                      color="primary"
-                      @click="showDetailWithEdit(content)"
-                      class="action-btn"
-                    />
-                    <v-btn
-                      icon="mdi-delete"
-                      size="small"
-                      variant="text"
-                      color="error"
-                      @click="confirmDelete(content)"
-                      class="action-btn"
-                    />
-                  </div>
-                </td>
-              </tr>
-            </tbody>
-          </v-table>
-
-          <!-- 페이지네이션 -->
-          <div v-if="totalPages > 1" class="pa-4 d-flex justify-center">
-            <v-pagination
-              v-model="currentPage"
-              :length="totalPages"
-              :total-visible="7"
-              rounded="circle"
-              color="primary"
-              class="pagination-custom"
-            />
-          </div>
-        </div>
-      </v-card-text>
-    </v-card>
-
-    <!-- 콘텐츠 상세/수정 다이얼로그 -->
-    <v-dialog v-model="showDetailDialog" max-width="800" persistent>
-      <v-card class="detail-dialog">
-        <v-card-title class="pa-6 pb-4">
+    <!-- 매장 등록/수정 다이얼로그 -->
+    <v-dialog 
+      v-model="showCreateDialog" 
+      max-width="600" 
+      persistent
+      :style="{ zIndex: 2000 }"
+      class="store-dialog"
+    >
+      <v-card class="store-dialog-card">
+        <v-card-title class="pa-4">
           <div class="d-flex align-center">
-            <v-icon class="mr-3" color="primary">
-              {{ isEditMode ? 'mdi-pencil' : 'mdi-eye' }}
-            </v-icon>
-            <span class="text-h6 font-weight-bold">
-              {{ isEditMode ? '콘텐츠 수정' : '콘텐츠 상세' }}
-            </span>
+            <v-icon class="mr-2" color="primary">mdi-store</v-icon>
+            {{ editMode ? '매장 정보 수정' : '새 매장 등록' }}
           </div>
         </v-card-title>
         
         <v-divider />
         
-        <v-card-text class="pa-6" style="max-height: 70vh; overflow-y: auto;">
-          <v-form ref="editForm" v-model="editFormValid" v-if="selectedContent">
-            <!-- 제목 -->
-            <div class="mb-6">
-              <label class="text-subtitle-2 font-weight-bold mb-3 d-block text-grey-darken-2">제목</label>
-              <v-text-field
-                v-if="isEditMode"
-                v-model="editingContent.title"
-                variant="outlined"
-                density="comfortable"
-                :rules="titleRules"
-                hide-details="auto"
-                class="edit-field"
-              />
-              <div v-else class="text-body-1 pa-3 bg-grey-lighten-5 rounded">
-                {{ selectedContent.title }}
-              </div>
-            </div>
-
-            <!-- 콘텐츠 내용 -->
-            <div class="mb-6">
-              <label class="text-subtitle-2 font-weight-bold mb-3 d-block text-grey-darken-2">내용</label>
-              <div v-if="isEditMode">
-                <v-textarea
-                  v-model="editingContent.content"
-                  variant="outlined"
-                  rows="8"
-                  auto-grow
-                  hide-details
-                  class="edit-field"
-                />
-              </div>
-              <div v-else class="content-display pa-4 bg-grey-lighten-5 rounded">
-                <div v-if="selectedContent.content && selectedContent.content.includes('<')" 
-                     v-html="selectedContent.content"
-                     class="content-html">
-                </div>
-                <div v-else class="text-body-1" style="white-space: pre-wrap;">
-                  {{ selectedContent.content }}
-                </div>
-              </div>
-            </div>
-
-            <!-- 해시태그 -->
-            <div class="mb-6">
-              <label class="text-subtitle-2 font-weight-bold mb-3 d-block text-grey-darken-2">해시태그</label>
-              <div class="d-flex flex-wrap ga-2">
-                <v-chip
-                  v-for="tag in selectedContent.hashtags"
-                  :key="tag"
-                  size="small"
-                  color="primary"
-                  variant="tonal"
-                  class="font-weight-medium"
-                >
-                  #{{ tag }}
-                </v-chip>
-              </div>
-              <div v-if="isEditMode" class="text-caption text-grey mt-2">
-                해시태그는 수정할 수 없습니다. 새로 생성해주세요.
-              </div>
-            </div>
-
-            <!-- 플랫폼 및 상태 정보 -->
+        <!-- ✅ 스크롤 가능한 컨텐츠 영역 -->
+        <v-card-text class="pa-4 store-dialog-content">
+          <v-form ref="storeFormRef" v-model="formValid">
             <v-row>
-              <v-col cols="6">
-                <label class="text-subtitle-2 font-weight-bold mb-3 d-block text-grey-darken-2">플랫폼</label>
-                <v-chip
-                  :color="getPlatformColor(selectedContent.platform)"
-                  variant="tonal"
-                  class="font-weight-medium"
-                >
-                  {{ getPlatformText(selectedContent.platform) }}
-                </v-chip>
+              <v-col cols="12">
+                <v-text-field
+                  v-model="formData.storeName"
+                  label="매장명 *"
+                  :rules="[v => !!v || '매장명을 입력해주세요']"
+                  variant="outlined"
+                  density="compact"
+                  required
+                />
               </v-col>
-              <v-col cols="6">
-                <label class="text-subtitle-2 font-weight-bold mb-3 d-block text-grey-darken-2">상태</label>
-                <v-chip
-                  :color="getStatusColor(selectedContent.status)"
-                  variant="tonal"
-                  class="font-weight-medium"
-                >
-                  {{ getStatusText(selectedContent.status) }}
-                </v-chip>
+              
+              <v-col cols="12" sm="6">
+                <v-select
+                  v-model="formData.businessType"
+                  :items="businessTypes"
+                  label="업종 *"
+                  :rules="[v => !!v || '업종을 선택해주세요']"
+                  variant="outlined"
+                  density="compact"
+                  required
+                />
+              </v-col>
+              
+              <v-col cols="12" sm="6">
+                <v-text-field
+                  v-model.number="formData.seatCount"
+                  label="좌석 수"
+                  type="number"
+                  variant="outlined"
+                  density="compact"
+                />
+              </v-col>
+              
+              <v-col cols="12">
+                <v-text-field
+                  v-model="formData.address"
+                  label="주소 *"
+                  :rules="[v => !!v || '주소를 입력해주세요']"
+                  variant="outlined"
+                  density="compact"
+                  required
+                />
+              </v-col>
+              
+              <v-col cols="12" sm="6">
+                <v-text-field
+                  v-model="formData.phoneNumber"
+                  label="전화번호"
+                  variant="outlined"
+                  density="compact"
+                />
+              </v-col>
+              
+              <v-col cols="12" sm="6">
+                <v-text-field
+                  v-model="formData.instagramUrl"
+                  label="인스타그램 URL"
+                  variant="outlined"
+                  density="compact"
+                />
+              </v-col>
+              
+              <v-col cols="12" sm="6">
+                <v-text-field
+                  v-model="formData.openTime"
+                  label="오픈 시간"
+                  type="time"
+                  variant="outlined"
+                  density="compact"
+                />
+              </v-col>
+              
+              <v-col cols="12" sm="6">
+                <v-text-field
+                  v-model="formData.closeTime"
+                  label="마감 시간"
+                  type="time"
+                  variant="outlined"
+                  density="compact"
+                />
+              </v-col>
+              
+              <v-col cols="12">
+                <v-select
+                  v-model="formData.holidays"
+                  :items="weekDays"
+                  item-title="title"
+                  item-value="value"
+                  label="휴무일"
+                  multiple
+                  chips
+                  variant="outlined"
+                  density="compact"
+                />
+              </v-col>
+              
+              <v-col cols="12">
+                <v-text-field
+                  v-model="formData.blogUrl"
+                  label="블로그 URL"
+                  variant="outlined"
+                  density="compact"
+                />
+              </v-col>
+              
+              <v-col cols="12">
+                <v-textarea
+                  v-model="formData.description"
+                  label="매장 소개"
+                  variant="outlined"
+                  density="compact"
+                  rows="2"
+                />
               </v-col>
             </v-row>
           </v-form>
         </v-card-text>
         
-        <v-divider />
-        
-        <!-- 다이얼로그 액션 버튼 -->
-        <v-card-actions class="pa-6 pt-4">
+        <v-card-actions class="pa-4">
           <v-spacer />
-          <div v-if="isEditMode" class="d-flex ga-3">
-            <v-btn 
-              variant="outlined"
-              color="grey-darken-1"
-              @click="cancelEdit"
-              class="px-6 font-weight-medium"
-            >
-              취소
-            </v-btn>
-            <v-btn 
-              color="primary" 
-              @click="saveEdit"
-              :loading="updating"
-              :disabled="!editFormValid"
-              class="px-6 font-weight-medium"
-              elevation="2"
-            >
-              저장
-            </v-btn>
-          </div>
-          <div v-else class="d-flex ga-3">
-            <v-btn 
-              variant="outlined"
-              color="grey-darken-1"
-              @click="closeDialog"
-              class="px-6 font-weight-medium"
-            >
-              닫기
-            </v-btn>
-            <v-btn 
-              variant="outlined"
-              color="primary"
-              prepend-icon="mdi-pencil"
-              @click="showEditMode"
-              class="px-6 font-weight-medium"
-            >
-              수정
-            </v-btn>
-            <v-btn 
-              variant="outlined"
-              color="error"
-              prepend-icon="mdi-delete"
-              @click="confirmDelete(selectedContent)"
-              class="px-6 font-weight-medium"
-            >
-              삭제
-            </v-btn>
-          </div>
+          <v-btn
+            variant="text"
+            @click="showCreateDialog = false"
+          >
+            취소
+          </v-btn>
+          <v-btn
+            color="primary"
+            @click="saveStore"
+            :loading="saving"
+            :disabled="!formValid"
+          >
+            {{ editMode ? '수정' : '등록' }}
+          </v-btn>
         </v-card-actions>
       </v-card>
     </v-dialog>
 
-    <!-- 성공/오류 스낵바 -->
-    <v-snackbar v-model="showSuccess" color="success" timeout="4000" location="bottom">
-      <v-icon class="mr-2">mdi-check-circle</v-icon>
-      {{ successMessage }}
-    </v-snackbar>
-    
-    <v-snackbar v-model="showError" color="error" timeout="4000" location="bottom">
-      <v-icon class="mr-2">mdi-alert-circle</v-icon>
-      {{ errorMessage }}
+    <!-- 메뉴 등록/수정 다이얼로그 -->
+    <v-dialog 
+      v-model="showMenuDialog" 
+      max-width="600" 
+      persistent
+      :style="{ zIndex: 2000 }"
+      class="menu-dialog"
+    >
+      <v-card class="menu-dialog-card">
+        <v-card-title class="pa-4">
+          <div class="d-flex align-center">
+            <v-icon class="mr-2" color="primary">mdi-food</v-icon>
+            {{ menuEditMode ? '메뉴 수정' : '새 메뉴 등록' }}
+          </div>
+        </v-card-title>
+        
+        <v-divider />
+        
+        <!-- ✅ 스크롤 가능한 컨텐츠 영역 -->
+        <v-card-text class="pa-4 dialog-content">
+          <v-form ref="menuFormRef" v-model="menuFormValid">
+            <v-row>
+              <!-- 메뉴 이미지 업로드 -->
+              <v-col cols="12">
+                <div class="mb-4">
+                  <h4 class="text-subtitle-1 font-weight-bold mb-3 d-flex align-center">
+                    <v-icon class="mr-2" color="primary">mdi-image</v-icon>
+                    메뉴 이미지 {{ !menuEditMode ? '*' : '' }}
+                  </h4>
+                  
+                  <!-- 이미지 미리보기 -->
+                  <div v-if="shouldShowImagePreview" class="mb-3">
+                    <v-img
+                      :src="shouldShowImagePreview"
+                      max-height="180"
+                      max-width="280"
+                      class="rounded mx-auto"
+                      style="border: 2px solid #e0e0e0;"
+                    />
+                    <div class="text-center mt-2">
+                      <v-chip 
+                        v-if="previewImageUrl" 
+                        color="success" 
+                        size="small" 
+                        class="mr-2"
+                      >
+                        새 이미지 선택됨
+                      </v-chip>
+                      <v-chip 
+                        v-else-if="menuEditMode" 
+                        color="info" 
+                        size="small" 
+                        class="mr-2"
+                      >
+                        현재 이미지
+                      </v-chip>
+                      <v-btn
+                        size="small"
+                        color="primary"
+                        variant="outlined"
+                        prepend-icon="mdi-image-edit"
+                        @click="resetImageSelection"
+                      >
+                        다른 이미지 선택
+                      </v-btn>
+                    </div>
+                  </div>
+                  
+                  <!-- 이미지 선택 섹션 -->
+                  <div v-else>
+                    <v-file-input
+                      v-model="selectedImageFile"
+                      label="메뉴 이미지 선택 *"
+                      accept="image/*"
+                      prepend-icon="mdi-camera"
+                      variant="outlined"
+                      density="compact"
+                      :rules="[
+                        v => menuEditMode || !!v || '메뉴 이미지는 필수입니다',
+                        v => !v || v.size < 10485760 || '파일 크기는 10MB 이하여야 합니다',
+                        v => !v || v.type.startsWith('image/') || '이미지 파일만 업로드 가능합니다'
+                      ]"
+                      @update:modelValue="onFileInputChange"
+                      show-size
+                      required
+                    />
+                    
+                    <!-- 드래그앤드롭 영역 - 높이 축소 -->
+                    <div
+                      class="drop-zone pa-3 text-center"
+                      style="border: 2px dashed #ccc; border-radius: 8px; background: #fafafa; min-height: 80px;"
+                      @drop="onDropImage"
+                      @dragover.prevent
+                      @dragenter.prevent
+                    >
+                      <v-icon size="32" color="grey-lighten-2">mdi-cloud-upload</v-icon>
+                      <p class="text-grey text-center mt-1 mb-1 text-caption">
+                        이미지를 드래그하여 업로드하거나 위의 버튼을 클릭하세요
+                      </p>
+                      <p class="text-caption text-grey text-center">
+                        JPG, PNG 파일만 업로드 가능 (최대 10MB)
+                      </p>
+                    </div>
+                  </div>
+                </div>
+              </v-col>
+              
+              <v-col cols="12">
+                <v-text-field
+                  v-model="menuFormData.menuName"
+                  label="메뉴명 *"
+                  :rules="[v => !!v || '메뉴명을 입력해주세요']"
+                  variant="outlined"
+                  density="compact"
+                  required
+                />
+              </v-col>
+              
+              <v-col cols="12" sm="6">
+                <v-select
+                  v-model="menuFormData.category"
+                  :items="menuCategories"
+                  label="카테고리 *"
+                  :rules="[v => !!v || '카테고리를 선택해주세요']"
+                  variant="outlined"
+                  density="compact"
+                  required
+                />
+              </v-col>
+              
+              <v-col cols="12" sm="6">
+                <v-text-field
+                  v-model.number="menuFormData.price"
+                  label="가격 (원) *"
+                  type="number"
+                  :rules="[
+                    v => !!v || '가격을 입력해주세요',
+                    v => v > 0 || '가격은 0보다 커야 합니다'
+                  ]"
+                  variant="outlined"
+                  density="compact"
+                  required
+                />
+              </v-col>
+              
+              <v-col cols="12">
+                <v-textarea
+                  v-model="menuFormData.description"
+                  label="메뉴 설명"
+                  variant="outlined"
+                  density="compact"
+                  rows="2"
+                />
+              </v-col>
+              
+              <v-col cols="12" sm="6">
+                <v-switch
+                  v-model="menuFormData.available"
+                  label="판매 가능"
+                  color="primary"
+                  density="compact"
+                />
+              </v-col>
+              
+              <v-col cols="12" sm="6">
+                <v-switch
+                  v-model="menuFormData.recommended"
+                  label="추천 메뉴"
+                  color="orange"
+                  density="compact"
+                />
+              </v-col>
+            </v-row>
+          </v-form>
+        </v-card-text>
+        
+        <v-card-actions class="pa-4">
+          <v-spacer />
+          <v-btn
+            variant="text"
+            @click="cancelMenuForm"
+          >
+            취소
+          </v-btn>
+          <v-btn
+            color="primary"
+            @click="saveMenu"
+            :loading="saving"
+            :disabled="!menuFormValid"
+          >
+            {{ menuEditMode ? '수정' : '등록' }}
+          </v-btn>
+        </v-card-actions>
+      </v-card>
+    </v-dialog>
+
+    <!-- 메뉴 상세 다이얼로그 -->
+    <v-dialog v-model="showMenuDetailDialog" max-width="500">
+      <v-card v-if="selectedMenu">
+        <v-img
+          :src="getMenuImageUrl(selectedMenu)"
+          height="250"
+          cover
+          @error="handleImageError($event, selectedMenu)"
+        />
+        
+        <v-card-title class="pa-4 d-flex justify-space-between align-center">
+          <span>{{ selectedMenu.menuName || selectedMenu.name }}</span>
+          <v-chip
+            :color="selectedMenu.available ? 'green' : 'red'"
+            size="small"
+          >
+            {{ selectedMenu.available ? '판매중' : '품절' }}
+          </v-chip>
+        </v-card-title>
+        
+        <v-card-text class="pa-4">
+          <div class="mb-3">
+            <div class="text-caption text-grey">카테고리</div>
+            <div class="text-body-1">{{ selectedMenu.category }}</div>
+          </div>
+          
+          <div class="mb-3">
+            <div class="text-caption text-grey">가격</div>
+            <div class="text-h6 text-primary font-weight-bold">
+              {{ selectedMenu.price ? selectedMenu.price.toLocaleString() : '0' }}원
+            </div>
+          </div>
+          
+          <div class="mb-3">
+            <div class="text-caption text-grey">설명</div>
+            <div class="text-body-1">{{ selectedMenu.description || '설명이 없습니다' }}</div>
+          </div>
+          
+          <div v-if="selectedMenu.recommended" class="mb-3">
+            <v-chip color="orange" size="small">추천 메뉴</v-chip>
+          </div>
+        </v-card-text>
+        
+        <v-card-actions class="pa-4">
+          <v-spacer />
+          <v-btn
+            variant="text"
+            @click="closeMenuDetail"
+          >
+            닫기
+          </v-btn>
+          <v-btn
+            color="primary"
+            variant="text"
+            @click="editMenu(selectedMenu); closeMenuDetail()"
+          >
+            수정
+          </v-btn>
+        </v-card-actions>
+      </v-card>
+    </v-dialog>
+
+    <!-- 스낵바 -->
+    <v-snackbar
+      v-model="snackbar.show"
+      :color="snackbar.color"
+      :timeout="3000"
+      location="bottom"
+    >
+      {{ snackbar.message }}
     </v-snackbar>
   </v-container>
 </template>
-
-
 <script setup>
 import { ref, computed, onMounted, watch, nextTick } from 'vue'
 import { useStoreStore } from '@/store/index'
@@ -523,6 +908,7 @@ const shouldShowImagePreview = computed(() => {
   
   return null
 })
+
 // ===== 유틸리티 함수들 =====
 
 /**
@@ -1007,8 +1393,6 @@ const cancelMenuForm = () => {
 
 // ===== 저장 관련 함수들 =====
 
-// ✅ StoreManagementView.vue의 saveStore 함수 수정
-
 // 매장 정보 저장 함수
 const saveStore = async () => {
   if (!storeFormRef.value) {
@@ -1026,19 +1410,17 @@ const saveStore = async () => {
   
   try {
     console.log('매장 정보 저장 시작')
-    console.log('폼 데이터:', formData.value)
     
-    // ✅ 백엔드 형식에 맞는 데이터 구조로 변환
+    // 백엔드 형식에 맞는 데이터 구조로 변환
     const storeData = {
       storeName: formData.value.storeName,
       businessType: formData.value.businessType,
       address: formData.value.address,
       phoneNumber: formData.value.phoneNumber || '',
-      // ✅ 수정: 시간 범위 문자열로 생성
-      businessHours: `${formData.value.openTime || '09:00'}-${formData.value.closeTime || '21:00'}`,
-      // ✅ 수정: 휴무일 배열을 문자열로 변환
-      closedDays: Array.isArray(formData.value.holidays) ? 
-        formData.value.holidays.join(',') : (formData.value.holidays || ''),
+      openTime: formData.value.openTime || '09:00',
+      closeTime: formData.value.closeTime || '21:00',
+      holidays: Array.isArray(formData.value.holidays) ? 
+        formData.value.holidays.join(',') : '',
       seatCount: parseInt(formData.value.seatCount) || 0,
       instaAccounts: formData.value.instagramUrl || '',
       blogAccounts: formData.value.blogUrl || '',
@@ -1046,19 +1428,11 @@ const saveStore = async () => {
     }
     
     console.log('백엔드로 전송할 데이터:', storeData)
-    console.log('=== 필드별 상세 정보 ===')
-    console.log('storeName:', storeData.storeName, '(타입:', typeof storeData.storeName, ')')
-    console.log('businessType:', storeData.businessType, '(타입:', typeof storeData.businessType, ')')
-    console.log('businessHours:', storeData.businessHours, '(타입:', typeof storeData.businessHours, ')')
-    console.log('closedDays:', storeData.closedDays, '(타입:', typeof storeData.closedDays, ')')
-    console.log('seatCount:', storeData.seatCount, '(타입:', typeof storeData.seatCount, ')')
     
     let result
     if (editMode.value) {
-      console.log('🔄 매장 정보 수정 API 호출')
       result = await storeStore.updateStore(storeInfo.value.storeId, storeData)
     } else {
-      console.log('➕ 매장 정보 등록 API 호출')
       result = await storeStore.registerStore(storeData)
     }
     
@@ -1084,8 +1458,6 @@ const saveStore = async () => {
   }
 }
 
-// ✅ 메뉴 수정 후 위치 유지를 위한 saveMenu 함수 개선
-
 // 메뉴 저장 함수
 const saveMenu = async () => {
   console.log('=== 메뉴 저장 시작 ===')
@@ -1118,7 +1490,6 @@ const saveMenu = async () => {
     
     let menuResult
     let savedMenuId
-    let isEdit = menuEditMode.value // ✅ 수정 모드 여부 저장
     
     if (menuEditMode.value) {
       // 메뉴 수정
@@ -1180,33 +1551,21 @@ const saveMenu = async () => {
       
       if (imageUrl) {
         console.log('✅ 이미지 업로드 완료:', imageUrl)
-        showSnackbar(`메뉴가 ${isEdit ? '수정' : '등록'}되었고 이미지도 업로드되었습니다`, 'success')
+        showSnackbar(`메뉴가 ${menuEditMode.value ? '수정' : '등록'}되었고 이미지도 업로드되었습니다`, 'success')
       } else {
         console.warn('⚠️ 이미지 업로드 실패')
-        showSnackbar(`메뉴는 ${isEdit ? '수정' : '등록'}되었지만 이미지 업로드에 실패했습니다`, 'warning')
+        showSnackbar(`메뉴는 ${menuEditMode.value ? '수정' : '등록'}되었지만 이미지 업로드에 실패했습니다`, 'warning')
       }
     } else {
       console.log('새 이미지가 선택되지 않아 이미지 업로드 건너뜀')
-      showSnackbar(`메뉴가 ${isEdit ? '수정' : '등록'}되었습니다`, 'success')
+      showSnackbar(`메뉴가 ${menuEditMode.value ? '수정' : '등록'}되었습니다`, 'success')
     }
     
-    // ✅ 다이얼로그 닫기 및 상태 초기화
+    // 다이얼로그 닫기 및 목록 새로고침
     showMenuDialog.value = false
     menuEditMode.value = false
     resetMenuForm()
-    
-    // ✅ 메뉴 목록 새로고침 (수정 모드일 때는 지연 없이 즉시)
-    if (isEdit) {
-      // 수정인 경우: 즉시 새로고침하여 위치 유지
-      await loadMenus()
-      console.log('✅ 메뉴 수정 완료 - 목록 새로고침됨 (위치 유지)')
-    } else {
-      // 신규 등록인 경우: 약간의 지연 후 새로고침 (새 메뉴가 맨 앞에 추가됨)
-      setTimeout(async () => {
-        await loadMenus()
-        console.log('✅ 메뉴 등록 완료 - 목록 새로고침됨')
-      }, 500)
-    }
+    await loadMenus()
     
   } catch (error) {
     console.error('❌ 메뉴 저장 중 예외 발생:', error)
@@ -1729,7 +2088,6 @@ onMounted(async () => {
 .warning-state .v-icon {
   color: #ed6c02;
 }
-
 /* ✅ 메뉴 다이얼로그 스타일 추가 - Style 부분에 추가 */
 
 /* 메뉴 다이얼로그 전용 스타일 */
@@ -1850,168 +2208,4 @@ onMounted(async () => {
 .store-dialog-content::-webkit-scrollbar-thumb:hover {
   background: #a8a8a8;
 }
-/* 🎨 소이님 UI 개선을 위한 스타일 */
-
-/* 필터 칩 호버 효과 */
-.chip-hover {
-  transition: all 0.3s cubic-bezier(0.4, 0, 0.2, 1);
-  cursor: pointer;
-}
-
-.chip-hover:hover {
-  transform: translateY(-2px);
-  box-shadow: 0 4px 12px rgba(0,0,0,0.15);
-}
-
-/* 검색 필드 스타일 */
-.search-field {
-  transition: all 0.3s ease;
-}
-
-.search-field:hover {
-  box-shadow: 0 2px 8px rgba(0,0,0,0.1);
-}
-
-/* 새 콘텐츠 생성 버튼 */
-.create-btn {
-  transition: all 0.3s cubic-bezier(0.4, 0, 0.2, 1);
-  min-width: 160px;
-}
-
-.create-btn:hover {
-  transform: translateY(-2px);
-  box-shadow: 0 6px 20px rgba(25, 118, 210, 0.3);
-}
-
-/* 선택된 항목 알림 */
-.selected-alert {
-  border-left: 4px solid #2196F3;
-  background: linear-gradient(90deg, rgba(33, 150, 243, 0.05) 0%, rgba(33, 150, 243, 0.02) 100%);
-}
-
-/* 테이블 스타일 */
-.content-table {
-  border-radius: 0;
-}
-
-.table-header {
-  background: linear-gradient(90deg, #fafafa 0%, #f5f5f5 100%);
-  border-bottom: 2px solid #e0e0e0;
-}
-
-.content-row {
-  transition: all 0.2s ease;
-  border-bottom: 1px solid #f0f0f0;
-}
-
-.content-row:hover {
-  background: linear-gradient(90deg, rgba(25, 118, 210, 0.02) 0%, rgba(25, 118, 210, 0.01) 100%);
-  transform: translateX(2px);
-  box-shadow: 2px 0 8px rgba(0,0,0,0.05);
-}
-
-.content-row:last-child {
-  border-bottom: none;
-}
-
-/* 정렬 가능한 헤더 */
-.sortable-header {
-  transition: all 0.2s ease;
-  border-radius: 4px;
-}
-
-.sortable-header:hover {
-  background: rgba(25, 118, 210, 0.08);
-  color: #1976D2;
-}
-
-/* 액션 버튼 */
-.action-btn {
-  transition: all 0.2s ease;
-}
-
-.action-btn:hover {
-  transform: scale(1.1);
-}
-
-/* 빈 상태 */
-.empty-state {
-  background: linear-gradient(145deg, #fafafa 0%, #f0f0f0 100%);
-  border-radius: 12px;
-  margin: 20px;
-}
-
-/* 다이얼로그 스타일 */
-.detail-dialog {
-  border-radius: 12px;
-  overflow: hidden;
-}
-
-.edit-field {
-  transition: all 0.3s ease;
-}
-
-.edit-field:hover {
-  box-shadow: 0 2px 8px rgba(0,0,0,0.1);
-}
-
-.content-display {
-  min-height: 100px;
-  border: 1px solid #e0e0e0;
-}
-
-.content-html {
-  line-height: 1.6;
-}
-
-.content-html img {
-  max-width: 100%;
-  height: auto;
-  border-radius: 8px;
-  margin: 8px 0;
-}
-
-.content-html p {
-  margin-bottom: 12px;
-}
-
-/* 페이지네이션 */
-.pagination-custom {
-  margin-top: 16px;
-}
-
-/* 반응형 디자인 */
-@media (max-width: 768px) {
-  .create-btn {
-    width: 100%;
-    min-width: unset;
-  }
-  
-  .content-row:hover {
-    transform: none;
-  }
-  
-  .chip-hover:hover {
-    transform: none;
-  }
-}
-
-/* 스크롤바 커스터마이징 */
-::-webkit-scrollbar {
-  width: 6px;
-}
-
-::-webkit-scrollbar-track {
-  background: #f1f1f1;
-  border-radius: 3px;
-}
-
-::-webkit-scrollbar-thumb {
-  background: #c1c1c1;
-  border-radius: 3px;
-}
-
-::-webkit-scrollbar-thumb:hover {
-  background: #a8a8a8;
-}
 </style>
\ No newline at end of file

From 64427ef9c460269161979a6a228dead29df3dac3 Mon Sep 17 00:00:00 2001
From: SeoJHeasdw <tjwpghangel@naver.com>
Date: Wed, 18 Jun 2025 15:57:24 +0900
Subject: [PATCH 10/11] release

---
 src/components/poster/PosterForm.vue    | 407 +++++++++++++++++++++
 src/components/poster/PosterPreview.vue | 318 ++++++++++++++++
 src/services/content.js                 | 267 +++++++++-----
 src/store/poster.js                     | 281 +++++++++++++++
 src/views/ContentCreationView.vue       | 461 +++++++++++++++++-------
 src/views/PosterCreationView.vue        | 235 ++++++++++++
 6 files changed, 1751 insertions(+), 218 deletions(-)
 create mode 100644 src/components/poster/PosterForm.vue
 create mode 100644 src/components/poster/PosterPreview.vue
 create mode 100644 src/store/poster.js
 create mode 100644 src/views/PosterCreationView.vue

diff --git a/src/components/poster/PosterForm.vue b/src/components/poster/PosterForm.vue
new file mode 100644
index 0000000..abdcfcc
--- /dev/null
+++ b/src/components/poster/PosterForm.vue
@@ -0,0 +1,407 @@
+//* src/components/poster/PosterForm.vue
+<template>
+  <v-form ref="form" v-model="valid" @submit.prevent="handleGenerate">
+    <!-- 기본 정보 -->
+    <div class="mb-6">
+      <h3 class="text-h6 mb-4">
+        <v-icon class="mr-2">mdi-information</v-icon>
+        기본 정보
+      </h3>
+      
+      <v-text-field
+        v-model="formData.title"
+        label="포스터 제목"
+        placeholder="예: 신메뉴 출시 이벤트"
+        :rules="titleRules"
+        variant="outlined"
+        class="mb-4"
+      />
+
+      <v-select
+        v-model="formData.targetAudience"
+        label="홍보 대상"
+        :items="targetAudienceOptions"
+        variant="outlined"
+        class="mb-4"
+      />
+
+      <v-textarea
+        v-model="formData.requirement"
+        label="구체적인 요구사항"
+        placeholder="어떤 포스터를 원하시는지 자세히 설명해주세요"
+        rows="3"
+        variant="outlined"
+        class="mb-4"
+      />
+    </div>
+
+    <!-- 프로모션 정보 -->
+    <div class="mb-6">
+      <h3 class="text-h6 mb-4">
+        <v-icon class="mr-2">mdi-calendar-range</v-icon>
+        프로모션 정보
+      </h3>
+
+      <v-text-field
+        v-model="formData.eventName"
+        label="이벤트명"
+        placeholder="예: 신메뉴 출시 기념 이벤트"
+        variant="outlined"
+        class="mb-4"
+      />
+
+      <v-row>
+        <v-col cols="12" sm="6">
+          <v-text-field
+            v-model="formData.promotionStartDate"
+            label="홍보 시작일"
+            type="datetime-local"
+            variant="outlined"
+            :rules="startDateRules"
+          />
+        </v-col>
+        <v-col cols="12" sm="6">
+          <v-text-field
+            v-model="formData.promotionEndDate"
+            label="홍보 종료일"
+            type="datetime-local"
+            variant="outlined"
+            :rules="endDateRules"
+          />
+        </v-col>
+      </v-row>
+
+      <v-row>
+        <v-col cols="12" sm="6">
+          <v-text-field
+            v-model="formData.startDate"
+            label="이벤트 시작일"
+            type="date"
+            variant="outlined"
+          />
+        </v-col>
+        <v-col cols="12" sm="6">
+          <v-text-field
+            v-model="formData.endDate"
+            label="이벤트 종료일"
+            type="date"
+            variant="outlined"
+          />
+        </v-col>
+      </v-row>
+    </div>
+
+    <!-- 디자인 설정 -->
+    <div class="mb-6">
+      <h3 class="text-h6 mb-4">
+        <v-icon class="mr-2">mdi-palette</v-icon>
+        디자인 설정
+      </h3>
+
+      <v-row>
+        <v-col cols="12" sm="6">
+          <v-select
+            v-model="formData.imageStyle"
+            label="이미지 스타일"
+            :items="imageStyleOptions"
+            variant="outlined"
+          />
+        </v-col>
+        <v-col cols="12" sm="6">
+          <v-select
+            v-model="formData.photoStyle"
+            label="사진 스타일"
+            :items="photoStyleOptions"
+            variant="outlined"
+          />
+        </v-col>
+      </v-row>
+
+      <v-row>
+        <v-col cols="12" sm="6">
+          <v-select
+            v-model="formData.promotionType"
+            label="프로모션 유형"
+            :items="promotionTypeOptions"
+            variant="outlined"
+          />
+        </v-col>
+        <v-col cols="12" sm="6">
+          <v-select
+            v-model="formData.emotionIntensity"
+            label="감정 강도"
+            :items="emotionIntensityOptions"
+            variant="outlined"
+          />
+        </v-col>
+      </v-row>
+
+      <v-select
+        v-model="formData.toneAndManner"
+        label="톤앤매너"
+        :items="toneAndMannerOptions"
+        variant="outlined"
+        class="mb-4"
+      />
+
+      <v-select
+        v-model="formData.category"
+        label="카테고리"
+        :items="categoryOptions"
+        variant="outlined"
+        class="mb-4"
+      />
+    </div>
+
+    <!-- 이미지 업로드 -->
+    <div class="mb-6">
+      <h3 class="text-h6 mb-4">
+        <v-icon class="mr-2">mdi-image-multiple</v-icon>
+        이미지 업로드
+      </h3>
+
+      <v-file-input
+        v-model="uploadedFiles"
+        label="이미지 선택"
+        placeholder="포스터에 포함할 이미지를 선택하세요"
+        accept="image/*"
+        multiple
+        show-size
+        variant="outlined"
+        prepend-icon="mdi-camera"
+        @change="handleFileUpload"
+        :rules="imageRules"
+        class="mb-4"
+      />
+
+      <!-- 업로드된 이미지 미리보기 -->
+      <div v-if="formData.images.length > 0" class="mb-4">
+        <v-row>
+          <v-col
+            v-for="(image, index) in formData.images"
+            :key="index"
+            cols="6"
+            sm="4"
+            md="3"
+          >
+            <v-card class="elevation-2">
+              <v-img
+                :src="image"
+                height="120"
+                cover
+              />
+              <v-card-actions class="pa-2">
+                <v-btn
+                  icon="mdi-delete"
+                  size="small"
+                  color="error"
+                  variant="text"
+                  @click="removeImage(index)"
+                />
+              </v-card-actions>
+            </v-card>
+          </v-col>
+        </v-row>
+      </div>
+    </div>
+
+    <!-- 액션 버튼 -->
+    <div class="d-flex gap-3">
+      <v-btn
+        color="primary"
+        size="large"
+        variant="elevated"
+        :loading="loading"
+        :disabled="!valid || formData.images.length === 0"
+        @click="handleGenerate"
+        class="flex-grow-1"
+      >
+        <v-icon class="mr-2">mdi-magic-staff</v-icon>
+        AI 포스터 생성
+      </v-btn>
+
+      <v-btn
+        color="success"
+        size="large"
+        variant="elevated"
+        :disabled="!canSave"
+        @click="handleSave"
+        class="flex-grow-1"
+      >
+        <v-icon class="mr-2">mdi-content-save</v-icon>
+        포스터 저장
+      </v-btn>
+    </div>
+  </v-form>
+</template>
+
+<script setup>
+import { ref, computed, watch } from 'vue'
+
+/**
+ * 포스터 생성 폼 컴포넌트
+ * - 포스터 정보 입력
+ * - 이미지 업로드
+ * - 폼 유효성 검증
+ */
+
+// Props 정의
+const props = defineProps({
+  modelValue: {
+    type: Object,
+    required: true
+  },
+  loading: {
+    type: Boolean,
+    default: false
+  }
+})
+
+// Emits 정의
+const emit = defineEmits(['update:modelValue', 'generate', 'save'])
+
+// 반응형 데이터
+const form = ref(null)
+const valid = ref(false)
+const uploadedFiles = ref([])
+
+// 컴퓨티드 속성
+const formData = computed({
+  get: () => props.modelValue,
+  set: (value) => emit('update:modelValue', value)
+})
+
+const canSave = computed(() => {
+  return formData.value.title && formData.value.images.length > 0
+})
+
+// 옵션 데이터
+const targetAudienceOptions = [
+  '메뉴', '이벤트', '매장', '서비스', '할인혜택'
+]
+
+const imageStyleOptions = [
+  '모던', '클래식', '미니멀', '화려한', '자연스러운', '빈티지'
+]
+
+const photoStyleOptions = [
+  '밝고 화사한', '따뜻한 톤', '차분한 톤', '선명하고 대비가 강한', '부드러운 톤', '시크한 톤'
+]
+
+const promotionTypeOptions = [
+  '할인 정보', '신메뉴 소개', '이벤트 안내', '매장 홍보', '서비스 안내'
+]
+
+const emotionIntensityOptions = [
+  '약함', '보통', '강함', '매우 강함'
+]
+
+const toneAndMannerOptions = [
+  '전문적', '친근한', '활기찬', '고급스러운', '캐주얼한', '신뢰감 있는'
+]
+
+const categoryOptions = [
+  '이벤트', '메뉴', '할인', '공지', '홍보'
+]
+
+// 유효성 검증 규칙
+const titleRules = [
+  v => !!v || '제목은 필수입니다',
+  v => (v && v.length <= 100) || '제목은 100자 이하로 입력해주세요'
+]
+
+const startDateRules = [
+  v => !!v || '홍보 시작일은 필수입니다'
+]
+
+const endDateRules = [
+  v => !!v || '홍보 종료일은 필수입니다',
+  v => {
+    if (!v || !formData.value.promotionStartDate) return true
+    return new Date(v) > new Date(formData.value.promotionStartDate) || '종료일은 시작일보다 늦어야 합니다'
+  }
+]
+
+const imageRules = [
+  v => formData.value.images.length > 0 || '최소 1개의 이미지를 업로드해야 합니다'
+]
+
+/**
+ * 파일 업로드 처리 - 오류 수정된 버전
+ */
+const handleFileUpload = (files) => {
+  console.log('📁 파일 업로드 시작:', files)
+  
+  // 파일이 없는 경우 처리
+  if (!files || files.length === 0) {
+    console.log('파일이 선택되지 않음')
+    return
+  }
+
+  // FileList를 배열로 변환
+  const fileArray = Array.from(files)
+  console.log('📁 변환된 파일 배열:', fileArray)
+
+  const newImages = []
+  let processedCount = 0
+  
+  fileArray.forEach((file, index) => {
+    // 이미지 파일인지 확인
+    if (file && file.type && file.type.startsWith('image/')) {
+      const reader = new FileReader()
+      
+      reader.onload = (e) => {
+        newImages.push(e.target.result)
+        processedCount++
+        
+        // 모든 파일 처리 완료 시
+        if (processedCount === fileArray.length) {
+          console.log('📁 모든 이미지 처리 완료:', newImages.length)
+          // 기존 이미지에 새 이미지 추가
+          formData.value.images.push(...newImages)
+        }
+      }
+      
+      reader.onerror = (error) => {
+        console.error('파일 읽기 오류:', error)
+        processedCount++
+      }
+      
+      reader.readAsDataURL(file)
+    } else {
+      console.warn('지원하지 않는 파일 형식:', file?.type)
+      processedCount++
+    }
+  })
+}
+
+/**
+ * 이미지 제거
+ */
+const removeImage = (index) => {
+  formData.value.images.splice(index, 1)
+}
+
+/**
+ * 포스터 생성 요청
+ */
+const handleGenerate = () => {
+  if (form.value?.validate()) {
+    emit('generate', formData.value)
+  }
+}
+
+/**
+ * 포스터 저장 요청
+ */
+const handleSave = () => {
+  emit('save')
+}
+
+// 시작일이 변경되면 종료일 유효성 재검증
+watch(() => formData.value.promotionStartDate, () => {
+  if (form.value) {
+    form.value.validate()
+  }
+})
+</script>
\ No newline at end of file
diff --git a/src/components/poster/PosterPreview.vue b/src/components/poster/PosterPreview.vue
new file mode 100644
index 0000000..a615f54
--- /dev/null
+++ b/src/components/poster/PosterPreview.vue
@@ -0,0 +1,318 @@
+//* src/components/poster/PosterPreview.vue
+<template>
+  <div class="poster-preview">
+    <!-- 로딩 상태 -->
+    <div v-if="loading" class="text-center py-12">
+      <v-progress-circular
+        indeterminate
+        size="64"
+        color="primary"
+        class="mb-4"
+      />
+      <div class="text-h6">포스터 생성 중...</div>
+      <div class="text-body-2 text-grey-600 mt-2">AI가 멋진 포스터를 만들고 있어요</div>
+    </div>
+
+    <!-- 포스터 없음 -->
+    <div v-else-if="!posterData" class="text-center py-12">
+      <v-icon size="80" color="grey-lighten-2" class="mb-4">
+        mdi-image-outline
+      </v-icon>
+      <div class="text-h6 mb-2">포스터 미리보기</div>
+      <div class="text-body-2 text-grey-600">
+        좌측 폼을 작성하고 'AI 포스터 생성' 버튼을 클릭하세요
+      </div>
+    </div>
+
+    <!-- 생성된 포스터 -->
+    <div v-else class="poster-result">
+      <!-- 포스터 이미지 -->
+      <div class="poster-image-container mb-4">
+        <v-img
+          :src="posterData.posterImage || '/images/placeholder-poster.jpg'"
+          :alt="posterData.title"
+          cover
+          class="rounded-lg elevation-4"
+          style="aspect-ratio: 3/4; max-height: 400px;"
+        >
+          <template v-slot:placeholder>
+            <div class="d-flex align-center justify-center fill-height">
+              <v-progress-circular indeterminate />
+            </div>
+          </template>
+          
+          <template v-slot:error>
+            <div class="d-flex align-center justify-center fill-height bg-grey-lighten-3">
+              <v-icon size="48" color="grey">mdi-image-broken</v-icon>
+            </div>
+          </template>
+        </v-img>
+
+        <!-- 이미지 액션 버튼 -->
+        <div class="image-actions mt-3">
+          <v-btn
+            size="small"
+            variant="outlined"
+            prepend-icon="mdi-download"
+            @click="downloadPoster"
+            class="mr-2"
+          >
+            다운로드
+          </v-btn>
+          
+          <v-btn
+            size="small"
+            variant="outlined"
+            prepend-icon="mdi-share-variant"
+            @click="sharePoster"
+          >
+            공유
+          </v-btn>
+        </div>
+      </div>
+
+      <!-- 포스터 정보 -->
+      <v-card variant="outlined" class="mb-4">
+        <v-card-title class="text-h6">
+          {{ posterData.title }}
+        </v-card-title>
+        
+        <v-card-text>
+          <div v-if="posterData.content" class="mb-3">
+            <div class="text-subtitle-2 mb-1">포스터 내용:</div>
+            <div class="text-body-2">{{ posterData.content }}</div>
+          </div>
+
+          <div class="d-flex align-center mb-2">
+            <v-chip
+              :color="getStatusColor(posterData.status)"
+              size="small"
+              class="mr-2"
+            >
+              {{ getStatusText(posterData.status) }}
+            </v-chip>
+            <v-chip
+              color="primary"
+              size="small"
+              variant="outlined"
+            >
+              {{ posterData.contentType }}
+            </v-chip>
+          </div>
+
+          <div v-if="posterData.imageStyle" class="text-caption text-grey-600">
+            스타일: {{ posterData.imageStyle }}
+          </div>
+        </v-card-text>
+      </v-card>
+
+      <!-- 포스터 사이즈 옵션 -->
+      <v-card v-if="posterData.posterSizes && Object.keys(posterData.posterSizes).length > 0" variant="outlined">
+        <v-card-title class="text-subtitle-1">
+          <v-icon class="mr-2">mdi-resize</v-icon>
+          다양한 사이즈
+        </v-card-title>
+        
+        <v-card-text>
+          <div class="d-flex flex-wrap gap-2">
+            <v-chip
+              v-for="(url, size) in posterData.posterSizes"
+              :key="size"
+              @click="viewPosterSize(size, url)"
+              class="cursor-pointer"
+              variant="outlined"
+            >
+              {{ size }}
+            </v-chip>
+          </div>
+        </v-card-text>
+      </v-card>
+
+      <!-- 원본 이미지들 -->
+      <div v-if="posterData.originalImages && posterData.originalImages.length > 0" class="mt-4">
+        <div class="text-subtitle-2 mb-2">사용된 원본 이미지:</div>
+        <v-row>
+          <v-col
+            v-for="(image, index) in posterData.originalImages"
+            :key="index"
+            cols="6"
+            sm="4"
+          >
+            <v-img
+              :src="image"
+              :alt="`원본 이미지 ${index + 1}`"
+              cover
+              height="80"
+              class="rounded"
+            />
+          </v-col>
+        </v-row>
+      </div>
+    </div>
+
+    <!-- 포스터 사이즈 보기 다이얼로그 -->
+    <v-dialog v-model="showSizeDialog" max-width="600">
+      <v-card>
+        <v-card-title>
+          포스터 사이즈: {{ selectedSize }}
+        </v-card-title>
+        
+        <v-card-text class="text-center">
+          <v-img
+            :src="selectedSizeUrl"
+            :alt="`포스터 ${selectedSize}`"
+            contain
+            max-height="400"
+          />
+        </v-card-text>
+        
+        <v-card-actions>
+          <v-spacer />
+          <v-btn
+            color="primary"
+            prepend-icon="mdi-download"
+            @click="downloadSelectedSize"
+          >
+            다운로드
+          </v-btn>
+          <v-btn @click="showSizeDialog = false">
+            닫기
+          </v-btn>
+        </v-card-actions>
+      </v-card>
+    </v-dialog>
+  </div>
+</template>
+
+<script setup>
+import { ref } from 'vue'
+
+/**
+ * 포스터 미리보기 컴포넌트
+ * - 생성된 포스터 표시
+ * - 다운로드 및 공유 기능
+ * - 다양한 사이즈 보기
+ */
+
+// Props 정의
+const props = defineProps({
+  posterData: {
+    type: Object,
+    default: null
+  },
+  loading: {
+    type: Boolean,
+    default: false
+  }
+})
+
+// 반응형 데이터
+const showSizeDialog = ref(false)
+const selectedSize = ref('')
+const selectedSizeUrl = ref('')
+
+/**
+ * 상태 색상 반환
+ */
+const getStatusColor = (status) => {
+  const colors = {
+    'DRAFT': 'orange',
+    'PUBLISHED': 'success',
+    'ARCHIVED': 'grey'
+  }
+  return colors[status] || 'primary'
+}
+
+/**
+ * 상태 텍스트 반환
+ */
+const getStatusText = (status) => {
+  const texts = {
+    'DRAFT': '임시저장',
+    'PUBLISHED': '발행',
+    'ARCHIVED': '보관'
+  }
+  return texts[status] || status
+}
+
+/**
+ * 포스터 다운로드
+ */
+const downloadPoster = () => {
+  if (!props.posterData?.posterImage) return
+
+  const link = document.createElement('a')
+  link.href = props.posterData.posterImage
+  link.download = `${props.posterData.title || '포스터'}.jpg`
+  document.body.appendChild(link)
+  link.click()
+  document.body.removeChild(link)
+}
+
+/**
+ * 포스터 공유
+ */
+const sharePoster = async () => {
+  if (!props.posterData?.posterImage) return
+
+  if (navigator.share) {
+    try {
+      await navigator.share({
+        title: props.posterData.title,
+        text: '생성된 홍보 포스터를 확인해보세요!',
+        url: props.posterData.posterImage
+      })
+    } catch (error) {
+      console.log('공유 취소됨')
+    }
+  } else {
+    // 클립보드에 URL 복사
+    try {
+      await navigator.clipboard.writeText(props.posterData.posterImage)
+      // 성공 알림 표시 (부모 컴포넌트에서 처리)
+    } catch (error) {
+      console.error('클립보드 복사 실패:', error)
+    }
+  }
+}
+
+/**
+ * 특정 사이즈 포스터 보기
+ */
+const viewPosterSize = (size, url) => {
+  selectedSize.value = size
+  selectedSizeUrl.value = url
+  showSizeDialog.value = true
+}
+
+/**
+ * 선택된 사이즈 포스터 다운로드
+ */
+const downloadSelectedSize = () => {
+  const link = document.createElement('a')
+  link.href = selectedSizeUrl.value
+  link.download = `${props.posterData.title || '포스터'}_${selectedSize.value}.jpg`
+  document.body.appendChild(link)
+  link.click()
+  document.body.removeChild(link)
+}
+</script>
+
+<style scoped>
+.poster-preview {
+  min-height: 400px;
+}
+
+.poster-image-container {
+  position: relative;
+}
+
+.image-actions {
+  display: flex;
+  justify-content: center;
+}
+
+.cursor-pointer {
+  cursor: pointer;
+}
+</style>
\ No newline at end of file
diff --git a/src/services/content.js b/src/services/content.js
index d700972..e45bf01 100644
--- a/src/services/content.js
+++ b/src/services/content.js
@@ -1,4 +1,4 @@
-//* src/services/content.js - 두 파일 완전 통합 버전
+//* src/services/content.js - 완전한 파일 (모든 수정사항 포함)
 import axios from 'axios'
 
 // runtime-env.js에서 API URL 가져오기 (대체 방식 포함)
@@ -106,11 +106,6 @@ class ContentService {
   /**
    * 콘텐츠 목록 조회 (CON-021: 콘텐츠 조회)
    * @param {Object} filters - 필터 조건
-   * @param {string} filters.platform - 플랫폼 (instagram, blog, poster)
-   * @param {number} filters.storeId - 매장 ID
-   * @param {string} filters.contentType - 콘텐츠 타입
-   * @param {string} filters.period - 조회 기간
-   * @param {string} filters.sortBy - 정렬 기준
    * @returns {Promise<Object>} 콘텐츠 목록
    */
   async getContents(filters = {}) {
@@ -182,7 +177,7 @@ class ContentService {
   }
 
   /**
-   * SNS 콘텐츠 생성 (CON-019: AI 콘텐츠 생성)
+   * SNS 콘텐츠 생성 (CON-019: AI 콘텐츠 생성) - 수정된 버전
    * @param {Object} contentData - 콘텐츠 생성 데이터
    * @returns {Promise<Object>} 생성된 콘텐츠
    */
@@ -190,97 +185,171 @@ class ContentService {
     try {
       console.log('🤖 SNS 콘텐츠 생성 요청:', contentData)
       
-      // ✅ 이미지 처리 (SNS는 선택사항)
-      let processedImages = []
-      if (contentData.images && Array.isArray(contentData.images) && contentData.images.length > 0) {
-        console.log('📁 [API] SNS 이미지 처리:', contentData.images.length, '개')
-        
-        processedImages = contentData.images.filter(img => {
-          const isValid = img && typeof img === 'string' && img.length > 0
-          console.log('📁 [API] SNS 이미지 유효성:', { isValid, type: typeof img, length: img?.length })
-          return isValid
-        })
-        
-        console.log('📁 [API] SNS 유효 이미지:', processedImages.length, '개')
+      // ✅ contentData 기본 검증
+      if (!contentData || typeof contentData !== 'object') {
+        throw new Error('콘텐츠 데이터가 전달되지 않았습니다.')
       }
       
-      // ✅ 실제 전달받은 데이터만 사용 (백엔드 API 스펙에 맞춤)
-      const requestData = {}
+      // ✅ images 속성 보장 (방어 코드)
+      if (!contentData.hasOwnProperty('images')) {
+        console.warn('⚠️ [API] images 속성이 없음, 빈 배열로 설정')
+        contentData.images = []
+      }
       
-      if (contentData.storeId !== undefined) requestData.storeId = contentData.storeId
+      if (!Array.isArray(contentData.images)) {
+        console.warn('⚠️ [API] images가 배열이 아님, 빈 배열로 변환:', typeof contentData.images)
+        contentData.images = []
+      }
+      
+      // ✅ 필수 필드 검증
+      const requiredFields = ['title', 'platform']
+      const missingFields = requiredFields.filter(field => !contentData[field])
+      
+      if (missingFields.length > 0) {
+        throw new Error(`필수 필드가 누락되었습니다: ${missingFields.join(', ')}`)
+      }
+      
+      // ✅ 플랫폼 형식 통일
+      const normalizeplatform = (platform) => {
+        const platformMap = {
+          'INSTAGRAM': 'instagram',
+          'instagram': 'instagram',
+          'NAVER_BLOG': 'naver_blog', 
+          'naver_blog': 'naver_blog',
+          'FACEBOOK': 'facebook',
+          'facebook': 'facebook',
+          'KAKAO_STORY': 'kakao_story',
+          'kakao_story': 'kakao_story'
+        }
+        return platformMap[platform] || platform.toLowerCase()
+      }
+      
+      // ✅ 카테고리 매핑
+      const getCategoryFromTargetType = (targetType) => {
+        const categoryMap = {
+          'new_menu': '메뉴소개',
+          'menu': '메뉴소개',
+          'discount': '이벤트',
+          'event': '이벤트',
+          'store': '매장홍보',
+          'service': '서비스',
+          'interior': '인테리어',
+          'daily': '일상',
+          'review': '고객후기'
+        }
+        return categoryMap[targetType] || '기타'
+      }
+      
+      // ✅ 요청 데이터 구성
+      const requestData = {
+        // 필수 필드들
+        title: contentData.title.trim(),
+        platform: normalizeplatform(contentData.platform),
+        contentType: contentData.contentType || 'sns',
+        category: contentData.category || getCategoryFromTargetType(contentData.targetType),
+        images: contentData.images || [] // 기본값 보장
+      }
+      
+      // ✅ storeId 처리
+      if (contentData.storeId !== undefined && contentData.storeId !== null) {
+        requestData.storeId = contentData.storeId
+      } else {
+        try {
+          const storeInfo = JSON.parse(localStorage.getItem('storeInfo') || '{}')
+          requestData.storeId = storeInfo.storeId || 1
+        } catch {
+          requestData.storeId = 1
+        }
+      }
+      
+      // ✅ 선택적 필드들
       if (contentData.storeName) requestData.storeName = contentData.storeName
       if (contentData.storeType) requestData.storeType = contentData.storeType
-      if (contentData.platform) requestData.platform = contentData.platform
-      if (contentData.title) requestData.title = contentData.title
-      if (contentData.category) requestData.category = contentData.category
       if (contentData.requirement || contentData.requirements) {
         requestData.requirement = contentData.requirement || contentData.requirements
       }
       if (contentData.target || contentData.targetAudience) {
         requestData.target = contentData.target || contentData.targetAudience
       }
-      if (contentData.contentType) requestData.contentType = contentData.contentType
       if (contentData.eventName) requestData.eventName = contentData.eventName
       if (contentData.startDate) requestData.startDate = contentData.startDate
       if (contentData.endDate) requestData.endDate = contentData.endDate
-      if (contentData.photoStyle) requestData.photoStyle = contentData.photoStyle
       if (contentData.targetAge) requestData.targetAge = contentData.targetAge
-      if (contentData.toneAndManner) requestData.toneAndManner = contentData.toneAndManner
-      if (contentData.emotionalIntensity || contentData.emotionIntensity) {
-        requestData.emotionalIntensity = contentData.emotionalIntensity || contentData.emotionIntensity
-      }
-      if (contentData.promotionalType || contentData.promotionType) {
-        requestData.promotionalType = contentData.promotionalType || contentData.promotionType
-      }
-      if (contentData.eventDate) requestData.eventDate = contentData.eventDate
-      if (contentData.hashtagStyle) requestData.hashtagStyle = contentData.hashtagStyle
-      if (contentData.hashtagCount) requestData.hashtagCount = contentData.hashtagCount
-      if (contentData.contentLength) requestData.contentLength = contentData.contentLength
       
-      // 이미지는 처리된 것으로 설정
+      // ✅ 이미지 처리 (contentData.images가 보장됨)
+      console.log('📁 [API] 이미지 처리 시작:', contentData.images.length, '개')
+      
+      const processedImages = contentData.images
+        .filter(img => img && typeof img === 'string' && img.length > 50)
+        .map(img => {
+          if (typeof img === 'string' && img.startsWith('data:image/')) {
+            return img // Base64 그대로 사용
+          } else if (typeof img === 'string' && (img.startsWith('http') || img.startsWith('//'))) {
+            return img // URL 그대로 사용
+          } else {
+            console.warn('📁 [API] 알 수 없는 이미지 형식:', img.substring(0, 50))
+            return img
+          }
+        })
+      
       requestData.images = processedImages
+      console.log('📁 [API] 처리된 이미지:', processedImages.length, '개')
       
-      // Boolean 필드들 (기본값 처리)
-      if (contentData.includeHashtags !== undefined) requestData.includeHashtags = contentData.includeHashtags
-      if (contentData.includeEmojis !== undefined) requestData.includeEmojis = contentData.includeEmojis
-      if (contentData.includeEmoji !== undefined) requestData.includeEmoji = contentData.includeEmoji
-      if (contentData.includeCallToAction !== undefined) requestData.includeCallToAction = contentData.includeCallToAction
-      if (contentData.includeLocation !== undefined) requestData.includeLocation = contentData.includeLocation
-      if (contentData.forInstagramStory !== undefined) requestData.forInstagramStory = contentData.forInstagramStory
-      if (contentData.forNaverBlogPost !== undefined) requestData.forNaverBlogPost = contentData.forNaverBlogPost
-      
-      if (contentData.alternativeTitleCount !== undefined) requestData.alternativeTitleCount = contentData.alternativeTitleCount
-      if (contentData.alternativeHashtagSetCount !== undefined) requestData.alternativeHashtagSetCount = contentData.alternativeHashtagSetCount
-      if (contentData.preferredAiModel) requestData.preferredAiModel = contentData.preferredAiModel
-      
-      console.log('📝 [API] SNS 요청 데이터:', {
-        ...requestData,
-        images: `${requestData.images.length}개 이미지`
+      // ✅ 최종 검증
+      console.log('📝 [API] 최종 SNS 요청 데이터:', {
+        title: requestData.title,
+        platform: requestData.platform,
+        category: requestData.category,
+        contentType: requestData.contentType,
+        storeId: requestData.storeId,
+        imageCount: requestData.images.length
       })
       
-      // 기본 유효성 검사
-      if (!requestData.platform) {
-        throw new Error('플랫폼은 필수입니다.')
-      }
+      // ✅ Python AI 서비스 필수 필드 검증
+      const pythonRequiredFields = ['title', 'category', 'contentType', 'platform', 'images']
+      const pythonMissingFields = pythonRequiredFields.filter(field => {
+        if (field === 'images') {
+          return !Array.isArray(requestData[field])
+        }
+        return !requestData[field]
+      })
       
-      if (!requestData.title) {
-        throw new Error('제목은 필수입니다.')
+      if (pythonMissingFields.length > 0) {
+        console.error('❌ [API] Python AI 서비스 필수 필드 누락:', pythonMissingFields)
+        throw new Error(`AI 서비스 필수 필드가 누락되었습니다: ${pythonMissingFields.join(', ')}`)
       }
       
       const response = await contentApi.post('/sns/generate', requestData, {
-        timeout: 30000 // 30초
+        timeout: 30000
       })
 
       console.log('✅ [API] SNS 콘텐츠 생성 응답:', response.data)
       return formatSuccessResponse(response.data, 'SNS 게시물이 생성되었습니다.')
+      
     } catch (error) {
       console.error('❌ [API] SNS 콘텐츠 생성 실패:', error)
+      
+      if (error.response?.status === 400) {
+        const backendMessage = error.response.data?.message || '요청 데이터가 잘못되었습니다.'
+        return {
+          success: false,
+          message: backendMessage,
+          error: error.response.data
+        }
+      } else if (error.response?.status === 500) {
+        return {
+          success: false,
+          message: 'AI 서비스에서 콘텐츠 생성 중 오류가 발생했습니다. 잠시 후 다시 시도해 주세요.',
+          error: error.response.data
+        }
+      }
+      
       return handleApiError(error)
     }
   }
 
   /**
-   * 포스터 생성 (CON-020: AI 포스터 생성) - 이미지 처리 강화 및 상세 검증
+   * 포스터 생성 (CON-020: AI 포스터 생성) - 수정된 버전
    * @param {Object} posterData - 포스터 생성 데이터
    * @returns {Promise<Object>} 생성된 포스터
    */
@@ -532,15 +601,6 @@ class ContentService {
           backendMessage = '서버에서 포스터 생성 중 오류가 발생했습니다. 잠시 후 다시 시도해 주세요.'
         }
         
-        // 유효성 검사 오류가 있다면 추출
-        if (error.response.data && error.response.data.errors) {
-          console.error('❌ [API] 유효성 검사 오류:', error.response.data.errors)
-          const validationMessages = Object.values(error.response.data.errors).flat()
-          if (validationMessages.length > 0) {
-            backendMessage = validationMessages.join(', ')
-          }
-        }
-        
         return {
           success: false,
           message: backendMessage,
@@ -565,6 +625,37 @@ class ContentService {
     }
   }
 
+  /**
+   * 통합 콘텐츠 생성 (타입에 따라 SNS 또는 포스터 생성) - 수정된 버전
+   * @param {Object} contentData - 콘텐츠 생성 데이터
+   * @returns {Promise<Object>} 생성 결과
+   */
+  async generateContent(contentData) {
+    console.log('🎯 [API] 통합 콘텐츠 생성:', contentData)
+    
+    // ✅ contentData 유효성 검사 추가
+    if (!contentData || typeof contentData !== 'object') {
+      console.error('❌ [API] contentData가 유효하지 않음:', contentData)
+      return {
+        success: false,
+        message: '콘텐츠 데이터가 유효하지 않습니다.',
+        error: 'INVALID_CONTENT_DATA'
+      }
+    }
+    
+    // ✅ images 속성 보장
+    if (!Array.isArray(contentData.images)) {
+      console.warn('⚠️ [API] images 속성이 배열이 아님, 빈 배열로 초기화:', contentData.images)
+      contentData.images = []
+    }
+    
+    if (contentData.contentType === 'poster' || contentData.type === 'poster') {
+      return await this.generatePoster(contentData)
+    } else {
+      return await this.generateSnsContent(contentData)
+    }
+  }
+
   /**
    * SNS 콘텐츠 저장 (CON-010: SNS 게시물 저장)
    * @param {Object} saveData - 저장할 콘텐츠 데이터
@@ -639,21 +730,6 @@ class ContentService {
     }
   }
 
-  /**
-   * 통합 콘텐츠 생성 (타입에 따라 SNS 또는 포스터 생성)
-   * @param {Object} contentData - 콘텐츠 생성 데이터
-   * @returns {Promise<Object>} 생성 결과
-   */
-  async generateContent(contentData) {
-    console.log('🎯 [API] 통합 콘텐츠 생성:', contentData)
-    
-    if (contentData.contentType === 'poster' || contentData.type === 'poster') {
-      return await this.generatePoster(contentData)
-    } else {
-      return await this.generateSnsContent(contentData)
-    }
-  }
-
   /**
    * 진행 중인 콘텐츠 조회
    * @param {string} period - 조회 기간
@@ -662,7 +738,6 @@ class ContentService {
   async getOngoingContents(period = 'month') {
     try {
       const response = await contentApi.get(`/ongoing?period=${period}`)
-
       return formatSuccessResponse(response.data.data, '진행 중인 콘텐츠를 조회했습니다.')
     } catch (error) {
       return handleApiError(error)
@@ -677,7 +752,6 @@ class ContentService {
   async getContentDetail(contentId) {
     try {
       const response = await contentApi.get(`/${contentId}`)
-
       return formatSuccessResponse(response.data.data, '콘텐츠 상세 정보를 조회했습니다.')
     } catch (error) {
       return handleApiError(error)
@@ -708,7 +782,6 @@ class ContentService {
       if (updateData.images) requestData.images = updateData.images
       
       const response = await contentApi.put(`/${contentId}`, requestData)
-
       return formatSuccessResponse(response.data.data, '콘텐츠가 수정되었습니다.')
     } catch (error) {
       return handleApiError(error)
@@ -723,7 +796,6 @@ class ContentService {
   async deleteContent(contentId) {
     try {
       await contentApi.delete(`/${contentId}`)
-
       return formatSuccessResponse(null, '콘텐츠가 삭제되었습니다.')
     } catch (error) {
       return handleApiError(error)
@@ -866,6 +938,19 @@ class ContentService {
       return handleApiError(error)
     }
   }
+
+  /**
+   * 콘텐츠 저장 (통합)
+   * @param {Object} saveData - 저장할 콘텐츠 데이터
+   * @returns {Promise<Object>} 저장 결과
+   */
+  async saveContent(saveData) {
+    if (saveData.contentType === 'poster' || saveData.type === 'poster') {
+      return await this.savePoster(saveData)
+    } else {
+      return await this.saveSnsContent(saveData)
+    }
+  }
 }
 
 // 서비스 인스턴스 생성 및 내보내기
diff --git a/src/store/poster.js b/src/store/poster.js
new file mode 100644
index 0000000..121b477
--- /dev/null
+++ b/src/store/poster.js
@@ -0,0 +1,281 @@
+//* src/store/poster.js - 이미지 처리 강화 및 디버깅 추가
+import { defineStore } from 'pinia'
+import { contentService } from '@/services/content'
+import { useAuthStore } from '@/store/auth'
+
+export const usePosterStore = defineStore('poster', {
+  state: () => ({
+    posters: [],
+    currentPoster: null,
+    loading: false,
+    error: null
+  }),
+
+  getters: {
+    getPosterById: (state) => (id) => {
+      return state.posters.find(poster => poster.id === id)
+    },
+
+    recentPosters: (state) => {
+      return state.posters
+        .slice()
+        .sort((a, b) => new Date(b.createdAt) - new Date(a.createdAt))
+        .slice(0, 10)
+    }
+  },
+
+  actions: {
+    /**
+     * 포스터 생성 - 이미지 처리 강화
+     */
+    async generatePoster(posterData) {
+      this.loading = true
+      this.error = null
+
+      try {
+        console.log('🎯 [POSTER_STORE] 포스터 생성 요청 받음:', posterData)
+        console.log('📁 [POSTER_STORE] 이미지 상태 확인:', {
+          hasImages: !!posterData.images,
+          isArray: Array.isArray(posterData.images),
+          imageCount: posterData.images?.length || 0,
+          imageDetails: posterData.images?.map((img, idx) => ({
+            index: idx,
+            type: typeof img,
+            length: img?.length,
+            isBase64: typeof img === 'string' && img.startsWith('data:image/'),
+            preview: typeof img === 'string' ? img.substring(0, 30) + '...' : 'not string'
+          })) || []
+        })
+
+        // ✅ 이미지 전처리 및 검증
+        let processedImages = []
+        if (posterData.images && Array.isArray(posterData.images) && posterData.images.length > 0) {
+          console.log('📁 [POSTER_STORE] 이미지 전처리 시작...')
+          
+          processedImages = posterData.images
+            .filter((img, index) => {
+              const isValid = img && 
+                             typeof img === 'string' && 
+                             img.length > 100 &&
+                             (img.startsWith('data:image/') || img.startsWith('http'))
+              
+              console.log(`📁 [POSTER_STORE] 이미지 ${index + 1} 검증:`, {
+                isValid,
+                type: typeof img,
+                length: img?.length,
+                format: img?.substring(0, 20) || 'unknown'
+              })
+              
+              return isValid
+            })
+          
+          console.log('📁 [POSTER_STORE] 전처리 결과:', {
+            원본: posterData.images.length,
+            유효: processedImages.length,
+            제거됨: posterData.images.length - processedImages.length
+          })
+          
+          if (processedImages.length === 0) {
+            throw new Error('유효한 이미지가 없습니다. 이미지를 다시 업로드해 주세요.')
+          }
+        } else {
+          console.warn('⚠️ [POSTER_STORE] 이미지가 없습니다!')
+          throw new Error('포스터 생성을 위해 최소 1개의 이미지가 필요합니다.')
+        }
+
+        // ✅ API 요청에 맞는 형태로 데이터 변환 - 검증된 이미지 사용
+        const requestData = {
+          storeId: posterData.storeId,
+          title: posterData.title,
+          targetAudience: posterData.targetAudience,
+          promotionStartDate: posterData.promotionStartDate,
+          promotionEndDate: posterData.promotionEndDate,
+          images: processedImages, // 검증된 이미지만 사용
+          targetAge: posterData.targetAge
+        }
+
+        // 선택적 필드들
+        if (posterData.eventName) requestData.eventName = posterData.eventName
+        if (posterData.imageStyle) requestData.imageStyle = posterData.imageStyle
+        if (posterData.promotionType) requestData.promotionType = posterData.promotionType
+        if (posterData.emotionIntensity) requestData.emotionIntensity = posterData.emotionIntensity
+        if (posterData.category) requestData.category = posterData.category
+        if (posterData.requirement) requestData.requirement = posterData.requirement
+        if (posterData.toneAndManner) requestData.toneAndManner = posterData.toneAndManner
+        if (posterData.startDate) requestData.startDate = posterData.startDate
+        if (posterData.endDate) requestData.endDate = posterData.endDate
+        if (posterData.photoStyle) requestData.photoStyle = posterData.photoStyle
+
+        console.log('📤 [POSTER_STORE] 최종 요청 데이터:', {
+          ...requestData,
+          images: `${requestData.images.length}개 이미지 (${Math.round(JSON.stringify(requestData.images).length / 1024)}KB)`
+        })
+
+        // ✅ 마지막 검증
+        if (!requestData.title) {
+          throw new Error('제목은 필수입니다.')
+        }
+        if (!requestData.targetAudience) {
+          throw new Error('홍보 대상은 필수입니다.')
+        }
+        if (!requestData.images || requestData.images.length === 0) {
+          throw new Error('이미지는 필수입니다.')
+        }
+
+        console.log('🚀 [POSTER_STORE] contentService.generatePoster 호출...')
+        const result = await contentService.generatePoster(requestData)
+        
+        if (result.success) {
+          console.log('✅ [POSTER_STORE] 포스터 생성 성공:', result.data)
+          this.currentPoster = result.data
+          return result
+        } else {
+          console.error('❌ [POSTER_STORE] 포스터 생성 실패:', result.message)
+          this.error = result.message
+          return result
+        }
+
+      } catch (error) {
+        console.error('❌ [POSTER_STORE] 포스터 생성 예외:', error)
+        
+        // 상세한 오류 정보 로깅
+        if (error.response) {
+          console.error('❌ [POSTER_STORE] HTTP 오류:', {
+            status: error.response.status,
+            statusText: error.response.statusText,
+            data: error.response.data
+          })
+        }
+        
+        this.error = error.message || '포스터 생성 중 오류가 발생했습니다.'
+        return {
+          success: false,
+          message: this.error
+        }
+      } finally {
+        this.loading = false
+      }
+    },
+
+    /**
+     * 포스터 저장
+     */
+    async savePoster(saveData) {
+      this.loading = true
+      this.error = null
+
+      try {
+        console.log('💾 [POSTER_STORE] 포스터 저장 요청:', saveData)
+        
+        const result = await contentService.savePoster(saveData)
+        
+        if (result.success) {
+          console.log('✅ [POSTER_STORE] 포스터 저장 성공')
+          // 저장된 포스터를 목록에 추가
+          if (result.data) {
+            this.posters.unshift(result.data)
+          }
+          return result
+        } else {
+          console.error('❌ [POSTER_STORE] 포스터 저장 실패:', result.message)
+          this.error = result.message
+          return result
+        }
+
+      } catch (error) {
+        console.error('❌ [POSTER_STORE] 포스터 저장 예외:', error)
+        this.error = error.message || '포스터 저장 중 오류가 발생했습니다.'
+        return {
+          success: false,
+          message: this.error
+        }
+      } finally {
+        this.loading = false
+      }
+    },
+
+    /**
+     * 포스터 목록 조회
+     */
+    async fetchPosters() {
+      this.loading = true
+      this.error = null
+
+      try {
+        const result = await contentService.getContents({
+          contentType: 'poster',
+          sortBy: 'latest'
+        })
+        
+        if (result.success) {
+          this.posters = result.data || []
+          return result
+        } else {
+          this.error = result.message
+          return result
+        }
+
+      } catch (error) {
+        console.error('❌ [POSTER_STORE] 포스터 목록 조회 예외:', error)
+        this.error = error.message || '포스터 목록 조회 중 오류가 발생했습니다.'
+        return {
+          success: false,
+          message: this.error
+        }
+      } finally {
+        this.loading = false
+      }
+    },
+
+    /**
+     * 포스터 삭제
+     */
+    async deletePoster(posterId) {
+      this.loading = true
+      this.error = null
+
+      try {
+        const result = await contentService.deleteContent(posterId)
+        
+        if (result.success) {
+          // 목록에서 삭제
+          this.posters = this.posters.filter(poster => poster.id !== posterId)
+          
+          // 현재 포스터가 삭제된 포스터라면 초기화
+          if (this.currentPoster?.id === posterId) {
+            this.currentPoster = null
+          }
+          
+          return result
+        } else {
+          this.error = result.message
+          return result
+        }
+
+      } catch (error) {
+        console.error('❌ [POSTER_STORE] 포스터 삭제 예외:', error)
+        this.error = error.message || '포스터 삭제 중 오류가 발생했습니다.'
+        return {
+          success: false,
+          message: this.error
+        }
+      } finally {
+        this.loading = false
+      }
+    },
+
+    /**
+     * 에러 상태 초기화
+     */
+    clearError() {
+      this.error = null
+    },
+
+    /**
+     * 현재 포스터 설정
+     */
+    setCurrentPoster(poster) {
+      this.currentPoster = poster
+    }
+  }
+})
\ No newline at end of file
diff --git a/src/views/ContentCreationView.vue b/src/views/ContentCreationView.vue
index 370b9d8..b5338f7 100644
--- a/src/views/ContentCreationView.vue
+++ b/src/views/ContentCreationView.vue
@@ -1,4 +1,3 @@
-//* src/views/ContentCreationView.vue
 <template>
   <v-container fluid class="pa-0" style="height: 100vh; overflow: hidden;">
     <!-- 책자 형식 레이아웃 -->
@@ -69,7 +68,7 @@
               </v-card-text>
             </v-card>
 
-            <!-- 콘텐츠 생성 폼 -->
+            <!-- 콘텐츠 생성 폼 - SNS와 포스터 통합 -->
             <div v-if="selectedType">
               <!-- 기본 정보 -->
               <v-card class="mb-4" elevation="1">
@@ -79,17 +78,18 @@
                     <!-- 제목 -->
                     <v-text-field
                       v-model="formData.title"
-                      label="제목"
+                      :label="selectedType === 'poster' ? '포스터 제목' : '게시물 제목'"
                       variant="outlined"
                       :rules="titleRules"
                       required
                       density="compact"
                       class="mb-3"
-                      placeholder="예: 신메뉴 출시 이벤트"
+                      :placeholder="selectedType === 'poster' ? '예: 신메뉴 출시 이벤트' : '예: 맛있는 신메뉴 소개'"
                     />
 
-                    <!-- 플랫폼 선택 -->
+                    <!-- 플랫폼 선택 (SNS만) -->
                     <v-select
+                      v-if="selectedType === 'sns'"
                       v-model="formData.platform"
                       :items="platformOptions"
                       label="발행 플랫폼"
@@ -113,8 +113,8 @@
                     <!-- 홍보 대상 -->
                     <v-select
                       v-model="formData.targetType"
-                      :items="targetTypes"
-                      label="홍보 대상"
+                      :items="getTargetTypes(selectedType)"
+                      :label="selectedType === 'poster' ? '포스터 대상' : '홍보 대상'"
                       variant="outlined"
                       :rules="targetRules"
                       required
@@ -122,7 +122,7 @@
                       class="mb-3"
                     />
 
-                    <!-- 이벤트명 (홍보 대상이 이벤트인 경우) -->
+                    <!-- 이벤트명 -->
                     <v-text-field
                       v-if="formData.targetType === 'event'"
                       v-model="formData.eventName"
@@ -134,6 +134,30 @@
                       placeholder="예: 신메뉴 할인 이벤트"
                     />
 
+                    <!-- 프로모션 기간 (포스터만) -->
+                    <v-row v-if="selectedType === 'poster'">
+                      <v-col cols="6">
+                        <v-text-field
+                          v-model="formData.promotionStartDate"
+                          label="홍보 시작일"
+                          type="datetime-local"
+                          variant="outlined"
+                          density="compact"
+                          :rules="promotionStartDateRules"
+                        />
+                      </v-col>
+                      <v-col cols="6">
+                        <v-text-field
+                          v-model="formData.promotionEndDate"
+                          label="홍보 종료일"
+                          type="datetime-local"
+                          variant="outlined"
+                          density="compact"
+                          :rules="promotionEndDateRules"
+                        />
+                      </v-col>
+                    </v-row>
+
                     <!-- 이벤트 기간 (이벤트인 경우) -->
                     <v-row v-if="formData.targetType === 'event'">
                       <v-col cols="6">
@@ -161,18 +185,18 @@
                 </v-card-text>
               </v-card>
 
-              <!-- AI 설정 (백엔드 지원 필드만) -->
+              <!-- AI 설정 -->
               <v-card class="mb-4" elevation="1">
                 <v-card-title class="text-h6 py-3">
                   <v-icon class="mr-2" color="primary">mdi-robot</v-icon>
                   AI 설정
                 </v-card-title>
                 <v-card-text>
-                  <!-- 사진 스타일 -->
+                  <!-- 타겟 연령층 -->
                   <v-select
-                    v-model="aiOptions.photoStyle"
-                    :items="photoStyleOptions"
-                    label="사진 스타일"
+                    v-model="aiOptions.targetAge"
+                    :items="targetAgeOptions"
+                    label="타겟 연령층"
                     variant="outlined"
                     density="compact"
                     class="mb-3"
@@ -185,27 +209,30 @@
                     variant="outlined"
                     rows="3"
                     density="compact"
-                    placeholder="예: 젊은 고객층을 타겟으로 트렌디한 문구를 사용하고 싶어요"
+                    :placeholder="selectedType === 'poster' ? 
+                      '예: 밝고 활기찬 분위기의 포스터를 만들어주세요' : 
+                      '예: 젊은 고객층을 타겟으로 트렌디한 문구를 사용하고 싶어요'"
                   />
                 </v-card-text>
               </v-card>
 
-              <!-- 사진 업로드 -->
+              <!-- 이미지 업로드 -->
               <v-card class="mb-4" elevation="1">
                 <v-card-title class="text-h6 py-3">
                   <v-icon class="mr-2" color="primary">mdi-camera</v-icon>
-                  사진 업로드 (선택사항)
+                  {{ selectedType === 'poster' ? '포스터용 이미지 업로드' : '사진 업로드 (선택사항)' }}
                 </v-card-title>
                 <v-card-text>
                   <v-file-input
                     v-model="uploadedFiles"
-                    label="사진을 선택하세요"
+                    :label="selectedType === 'poster' ? '포스터에 포함할 이미지를 선택하세요' : '사진을 선택하세요'"
                     variant="outlined"
                     multiple
                     accept="image/*"
                     prepend-icon="mdi-camera"
                     @change="handleFileUpload"
                     density="compact"
+                    :rules="selectedType === 'poster' ? imageRequiredRules : []"
                   />
                   
                   <!-- 미리보기 -->
@@ -248,8 +275,8 @@
                     @click="generateContent"
                     class="px-8"
                   >
-                    <v-icon class="mr-2">mdi-robot</v-icon>
-                    AI로 콘텐츠 생성하기
+                    <v-icon class="mr-2">{{ selectedType === 'poster' ? 'mdi-image' : 'mdi-robot' }}</v-icon>
+                    {{ selectedType === 'poster' ? 'AI 포스터 생성하기' : 'AI로 콘텐츠 생성하기' }}
                   </v-btn>
                   
                   <div v-if="remainingGenerations <= 0" class="text-caption text-error mt-2">
@@ -288,7 +315,7 @@
               <v-row>
                 <v-col
                   v-for="(version, index) in generatedVersions"
-                  :key="index"
+                  :key="`version-${index}`"
                   cols="12"
                   class="mb-3"
                 >
@@ -357,11 +384,10 @@
                     {{ currentVersion.title }}
                   </div>
                   
-                  <!-- 콘텐츠 내용 (HTML 렌더링) -->
+                  <!-- 콘텐츠 내용 -->
                   <div class="text-body-2 mb-3" style="line-height: 1.6;">
                     <div v-if="isHtmlContent(currentVersion.content)" 
                          class="html-content preview-content">
-                      <!-- 미리보기용 축약 HTML -->
                       <div v-html="truncateHtmlContent(currentVersion.content, 200)"></div>
                       <div v-if="currentVersion.content.length > 500" class="text-caption text-grey mt-2">
                         ... 더 보려면 '자세히 보기'를 클릭하세요
@@ -369,7 +395,6 @@
                     </div>
                     <div v-else>{{ truncateText(currentVersion.content, 150) }}</div>
                   </div>
-
                   
                   <!-- 해시태그 -->
                   <div v-if="currentVersion.hashtags && currentVersion.hashtags.length > 0" class="mb-3">
@@ -441,8 +466,7 @@
         <v-divider />
         
         <v-card-text class="pa-4" style="max-height: 500px;">
-
-          <!-- 전체 콘텐츠 (HTML 렌더링) -->
+          <!-- 전체 콘텐츠 -->
           <div class="mb-4">
             <h4 class="text-h6 mb-2">콘텐츠</h4>
             <div v-if="isHtmlContent(currentVersion.content)" 
@@ -456,8 +480,6 @@
               {{ currentVersion.content }}
             </div>
           </div>
-
-        
           
           <!-- 해시태그 -->
           <div v-if="currentVersion.hashtags && currentVersion.hashtags.length > 0" class="mb-4">
@@ -571,7 +593,7 @@ const publishingIndex = ref(-1)
 const showDetailDialog = ref(false)
 const selectedVersion = ref(0)
 const generatedVersions = ref([])
-const remainingGenerations = ref(3) // AI 생성 가능 횟수
+const remainingGenerations = ref(3)
 
 // 폼 데이터
 const formData = ref({
@@ -582,11 +604,13 @@ const formData = ref({
   startDate: '',
   endDate: '',
   requirements: '',
+  promotionStartDate: '',
+  promotionEndDate: ''
 })
 
-// AI 옵션 (백엔드 DTO에 맞게 단순화)
+// AI 옵션 - 타겟 연령층만
 const aiOptions = ref({
-  photoStyle: 'bright' // 백엔드에서 지원하는 photoStyle만 유지
+  targetAge: '20대'
 })
 
 // 상수 정의
@@ -621,15 +645,31 @@ const targetTypes = [
   { title: '일반 이벤트', value: 'event' }
 ]
 
-// 백엔드에서 지원하지 않는 옵션들은 제거
-const photoStyleOptions = [
-  { title: '밝고 화사한', value: 'bright' },
-  { title: '차분하고 세련된', value: 'calm' },
-  { title: '빈티지한', value: 'vintage' },
-  { title: '모던한', value: 'modern' },
-  { title: '자연스러운', value: 'natural' }
+// 타겟 연령층 옵션
+const targetAgeOptions = [
+  { title: '10대', value: '10대' },
+  { title: '20대', value: '20대' },
+  { title: '30대', value: '30대' },
+  { title: '40대', value: '40대' },
+  { title: '50대', value: '50대' },
+  { title: '60대 이상', value: '60대 이상' }
 ]
 
+// 타입별 타겟 옵션 함수
+const getTargetTypes = (type) => {
+  if (type === 'poster') {
+    return [
+      { title: '메뉴', value: 'menu' },
+      { title: '이벤트', value: 'event' },
+      { title: '매장', value: 'store' },
+      { title: '서비스', value: 'service' },
+      { title: '할인혜택', value: 'discount' }
+    ]
+  } else {
+    return targetTypes
+  }
+}
+
 // 유효성 검사 규칙
 const titleRules = [
   v => !!v || '제목은 필수입니다',
@@ -657,6 +697,22 @@ const endDateRules = [
   v => !formData.value.startDate || !v || new Date(v) >= new Date(formData.value.startDate) || '종료일은 시작일보다 이후여야 합니다'
 ]
 
+const imageRequiredRules = [
+  v => selectedType.value !== 'poster' || (previewImages.value && previewImages.value.length > 0) || '포스터 생성을 위해 최소 1개의 이미지가 필요합니다'
+]
+
+const promotionStartDateRules = [
+  v => selectedType.value !== 'poster' || !!v || '홍보 시작일은 필수입니다'
+]
+
+const promotionEndDateRules = [
+  v => selectedType.value !== 'poster' || !!v || '홍보 종료일은 필수입니다',
+  v => {
+    if (selectedType.value !== 'poster' || !v || !formData.value.promotionStartDate) return true
+    return new Date(v) > new Date(formData.value.promotionStartDate) || '종료일은 시작일보다 늦어야 합니다'
+  }
+]
+
 // Computed
 const currentVersion = computed(() => {
   return generatedVersions.value[selectedVersion.value] || null
@@ -665,13 +721,27 @@ const currentVersion = computed(() => {
 // 메서드
 const selectContentType = (type) => {
   selectedType.value = type
+  console.log(`${type} 타입 선택됨`)
 }
 
-const handleFileUpload = () => {
+const handleFileUpload = (files) => {
+  console.log('📁 파일 업로드 시작:', files)
+  
+  // 파일이 없는 경우 처리
+  if (!files || files.length === 0) {
+    console.log('파일이 선택되지 않음')
+    return
+  }
+
+  // FileList를 배열로 변환
+  const fileArray = Array.from(files)
+  console.log('📁 변환된 파일 배열:', fileArray)
+
+  // 기존 이미지 초기화
   previewImages.value = []
   
-  if (uploadedFiles.value && uploadedFiles.value.length > 0) {
-    uploadedFiles.value.forEach(file => {
+  fileArray.forEach((file, index) => {
+    if (file && file.type && file.type.startsWith('image/')) {
       const reader = new FileReader()
       reader.onload = (e) => {
         previewImages.value.push({
@@ -680,8 +750,8 @@ const handleFileUpload = () => {
         })
       }
       reader.readAsDataURL(file)
-    })
-  }
+    }
+  })
 }
 
 const removeImage = (index) => {
@@ -701,54 +771,239 @@ const generateContent = async () => {
   }
 
   try {
-    console.log('🎯 콘텐츠 생성 요청 시작')
+    console.log(`🎯 [UI] ${selectedType.value.toUpperCase()} 콘텐츠 생성 요청 시작`)
     
-    // 백엔드 DTO에 맞는 데이터 구조
-    const contentData = {
-      // 기본 정보
-      title: formData.value.title,
-      platform: formData.value.platform, // 원본 플랫폼 값 그대로 전송
-      targetType: formData.value.targetType,
+    // ✅ 이미지 상태 상세 로깅
+    console.log('📁 [UI] 현재 이미지 상태:')
+    console.log('  - previewImages.value:', previewImages.value)
+    console.log('  - previewImages 타입:', typeof previewImages.value)
+    console.log('  - previewImages 배열 여부:', Array.isArray(previewImages.value))
+    console.log('  - previewImages 길이:', previewImages.value?.length)
+    
+    if (previewImages.value && Array.isArray(previewImages.value)) {
+      previewImages.value.forEach((img, index) => {
+        console.log(`  - 이미지 ${index + 1}:`, {
+          exists: !!img,
+          hasUrl: !!img?.url,
+          urlType: typeof img?.url,
+          urlLength: img?.url?.length,
+          urlPreview: img?.url?.substring(0, 50)
+        })
+      })
+    }
+    
+    // ✅ 실제 매장 ID 가져오기
+    let actualStoreId = 1
+    
+    try {
+      const storeInfo = JSON.parse(localStorage.getItem('storeInfo') || '{}')
+      const userInfo = JSON.parse(localStorage.getItem('userInfo') || '{}')
       
-      // 이벤트 정보
-      eventName: formData.value.eventName,
-      startDate: formData.value.startDate,
-      endDate: formData.value.endDate,
+      if (storeInfo.storeId) {
+        actualStoreId = storeInfo.storeId
+      } else if (userInfo.storeId) {
+        actualStoreId = userInfo.storeId
+      }
+    } catch (error) {
+      console.warn('⚠️ [UI] 매장 정보 파싱 실패, 기본값 사용:', actualStoreId)
+    }
+    
+    // ✅ 이미지 처리 함수 개선 (더 관대한 조건)
+    const processImages = () => {
+      const images = []
       
-      // 콘텐츠 정보
-      requirements: formData.value.requirements,
-      category: getCategory(formData.value.targetType),
+      console.log('📁 [UI] 이미지 처리 시작...')
       
-      // 미디어
-      images: previewImages.value.map(img => img.url),
+      // previewImages가 존재하고 배열인지 확인
+      if (!previewImages.value) {
+        console.log('📁 [UI] previewImages.value가 null/undefined')
+        return images
+      }
       
-      // AI 옵션 (UI에서 설정된 값들)
-      aiOptions: aiOptions.value,
+      if (!Array.isArray(previewImages.value)) {
+        console.log('📁 [UI] previewImages.value가 배열이 아님:', typeof previewImages.value)
+        return images
+      }
       
-      // 메타 정보
-      type: selectedType.value
+      if (previewImages.value.length === 0) {
+        console.log('📁 [UI] previewImages.value가 빈 배열')
+        return images
+      }
+      
+      // 각 이미지 처리 (조건 완화)
+      previewImages.value.forEach((img, index) => {
+        console.log(`📁 [UI] 이미지 ${index + 1} 처리:`)
+        console.log('  - img 존재:', !!img)
+        console.log('  - img 타입:', typeof img)
+        
+        if (!img) {
+          console.log('  - 결과: null/undefined, 건너뜀')
+          return
+        }
+        
+        let imageUrl = null
+        
+        // 이미지 URL 추출 (여러 형태 지원)
+        if (typeof img === 'string') {
+          // 직접 문자열인 경우
+          imageUrl = img
+          console.log('  - 문자열 이미지:', imageUrl.substring(0, 50))
+        } else if (img.url && typeof img.url === 'string') {
+          // 객체에 url 속성이 있는 경우
+          imageUrl = img.url
+          console.log('  - 객체 이미지 URL:', imageUrl.substring(0, 50))
+        } else if (img.src && typeof img.src === 'string') {
+          // 객체에 src 속성이 있는 경우
+          imageUrl = img.src
+          console.log('  - 객체 이미지 SRC:', imageUrl.substring(0, 50))
+        } else {
+          console.log('  - 알 수 없는 이미지 형태:', Object.keys(img))
+          return
+        }
+        
+        // ✅ URL 유효성 검사 (조건 완화)
+        if (imageUrl && typeof imageUrl === 'string' && imageUrl.length > 20) {
+          // Base64 또는 HTTP URL 확인
+          if (imageUrl.startsWith('data:image/') || 
+              imageUrl.startsWith('http') || 
+              imageUrl.startsWith('blob:') ||
+              imageUrl.startsWith('//')) {
+            
+            images.push(imageUrl)
+            console.log(`  - 결과: 유효한 이미지 추가 (${Math.round(imageUrl.length / 1024)}KB)`)
+          } else {
+            console.log('  - 결과: 유효하지 않은 형식, 건너뜀')
+          }
+        } else {
+          console.log('  - 결과: URL이 너무 짧거나 유효하지 않음, 건너뜀')
+        }
+      })
+      
+      console.log(`📁 [UI] 이미지 처리 완료: ${images.length}개 유효 이미지`)
+      return images
+    }
+    
+    // ✅ 이미지 처리 실행
+    const processedImages = processImages()
+    
+    // ✅ 기본 contentData 객체 생성
+    let contentData = {
+      storeId: actualStoreId,
+      title: (formData.value.title || '').trim(),
+      contentType: selectedType.value,
+      type: selectedType.value,
+      images: processedImages, // ✅ 처리된 이미지 배열
+      category: '기타',
+      platform: '',
+      targetAudience: '',
+      requirements: formData.value.requirements || '',
+      eventName: formData.value.eventName || '',
+      startDate: formData.value.startDate || '',
+      endDate: formData.value.endDate || '',
+      targetAge: (aiOptions.value && aiOptions.value.targetAge) ? aiOptions.value.targetAge : '20대'
+    }
+    
+    // ✅ 타입별 처리
+    if (selectedType.value === 'poster') {
+      console.log('🎯 [UI] 포스터 생성 데이터 구성')
+      console.log('📁 [UI] 포스터용 이미지 체크:', {
+        processedImagesCount: processedImages.length,
+        previewImagesCount: previewImages.value?.length || 0,
+        hasImages: processedImages.length > 0
+      })
+      
+      // ✅ 포스터 이미지 체크 (상세 로깅)
+      if (processedImages.length === 0) {
+        console.error('❌ [UI] 포스터 이미지 없음!')
+        console.error('❌ [UI] previewImages 상태:', {
+          exists: !!previewImages.value,
+          isArray: Array.isArray(previewImages.value),
+          length: previewImages.value?.length,
+          content: previewImages.value
+        })
+        
+        appStore.showSnackbar('포스터 생성을 위해 최소 1개의 이미지를 업로드해 주세요.', 'warning')
+        return
+      }
+      
+      contentData.targetAudience = formData.value.targetType || 'menu'
+      contentData.category = getCategory(formData.value.targetType)
+      
+      if (formData.value.promotionStartDate) {
+        contentData.promotionStartDate = formData.value.promotionStartDate
+      }
+      if (formData.value.promotionEndDate) {
+        contentData.promotionEndDate = formData.value.promotionEndDate
+      }
+      
+    } else {
+      console.log('🎯 [UI] SNS 생성 데이터 구성')
+      
+      if (!formData.value.platform) {
+        appStore.showSnackbar('플랫폼을 선택해주세요.', 'warning')
+        return
+      }
+      
+      contentData.platform = formData.value.platform
+      contentData.targetType = formData.value.targetType || 'new_menu'
+      contentData.category = getCategory(formData.value.targetType)
     }
 
-    console.log('📤 전송할 데이터:', contentData)
+    // ✅ 최종 검증 및 로깅
+    console.log('📤 [UI] 최종 contentData:', {
+      type: contentData.type,
+      title: contentData.title,
+      platform: contentData.platform,
+      category: contentData.category,
+      storeId: contentData.storeId,
+      imageCount: contentData.images.length,
+      firstImagePreview: contentData.images[0]?.substring(0, 50)
+    })
 
+    // ✅ 필수 필드 최종 체크
+    if (!contentData.title) {
+      throw new Error('제목을 입력해주세요.')
+    }
+    
+    if (selectedType.value === 'sns' && !contentData.platform) {
+      throw new Error('플랫폼을 선택해주세요.')
+    }
+    
+    if (selectedType.value === 'poster' && contentData.images.length === 0) {
+      throw new Error('포스터 생성을 위해서는 최소 1개의 이미지가 필요합니다.')
+    }
+
+    // ✅ contentData 무결성 체크
+    if (!contentData || typeof contentData !== 'object') {
+      throw new Error('콘텐츠 데이터 구성에 실패했습니다.')
+    }
+    
+    if (!Array.isArray(contentData.images)) {
+      console.error('❌ [UI] contentData.images가 배열이 아님!')
+      contentData.images = []
+    }
+
+    // ✅ Store 호출
+    console.log('🚀 [UI] contentStore.generateContent 호출')
     const generated = await contentStore.generateContent(contentData)
 
-      // ✅ 핵심: AI 생성 결과에 이미지를 직접 추가
-    let finalContent = generated.content
+    if (!generated || !generated.success) {
+      throw new Error(generated?.message || '콘텐츠 생성에 실패했습니다.')
+    }
+
+    let finalContent = generated.content || generated.data?.content || ''
     
-    // 업로드된 이미지가 있으면 콘텐츠 최상단에 추가
-    if (previewImages.value.length > 0) {
-      const imageHtml = previewImages.value.map(img => 
+    // SNS용 이미지 추가
+    if (selectedType.value === 'sns' && contentData.images && contentData.images.length > 0) {
+      const imageHtml = contentData.images.map(imageUrl => 
         `<div style="margin-bottom: 15px; text-align: center;">
-          <img src="${img.url}" style="width: 100%; max-width: 400px; border-radius: 12px; box-shadow: 0 4px 12px rgba(0,0,0,0.1);" />
+          <img src="${imageUrl}" style="width: 100%; max-width: 400px; border-radius: 12px; box-shadow: 0 4px 12px rgba(0,0,0,0.1);" />
          </div>`
       ).join('')
       
-      // HTML 콘텐츠인지 확인하고 이미지를 맨 앞에 추가
       if (isHtmlContent(finalContent)) {
         finalContent = imageHtml + finalContent
       } else {
-        // 일반 텍스트면 HTML로 변환해서 이미지 추가
         finalContent = imageHtml + `<div style="padding: 15px; font-family: 'Noto Sans KR', Arial, sans-serif; line-height: 1.6;">${finalContent.replace(/\n/g, '<br>')}</div>`
       }
     }
@@ -757,10 +1012,11 @@ const generateContent = async () => {
       id: Date.now() + Math.random(),
       ...contentData,
       content: finalContent,
-      hashtags: generated.hashtags || [],
+      hashtags: generated.hashtags || generated.data?.hashtags || [],
       createdAt: new Date(),
       status: 'draft',
-       uploadedImages: previewImages.value
+      uploadedImages: previewImages.value || [],
+      platform: contentData.platform || 'POSTER'
     }
 
     generatedVersions.value.push(newContent)
@@ -768,8 +1024,10 @@ const generateContent = async () => {
     remainingGenerations.value--
     
     appStore.showSnackbar(`콘텐츠 버전 ${generatedVersions.value.length}이 생성되었습니다!`, 'success')
+    
   } catch (error) {
-    console.error('❌ 콘텐츠 생성 실패:', error)
+    console.error('❌ [UI] 콘텐츠 생성 실패:', error)
+    console.error('❌ [UI] 에러 스택:', error.stack)
     appStore.showSnackbar(error.message || '콘텐츠 생성 중 오류가 발생했습니다.', 'error')
   }
 }
@@ -795,12 +1053,11 @@ const saveVersion = async (index) => {
   try {
     const version = generatedVersions.value[index]
     
-    // 백엔드 DTO에 맞는 저장 데이터 구성
     await contentStore.saveContent({
       title: version.title,
       content: version.content,
       hashtags: version.hashtags,
-      platform: version.platform, // 원본 플랫폼 값 그대로 전송
+      platform: version.platform,
       category: getCategory(version.targetType),
       eventName: version.eventName,
       eventDate: version.eventDate,
@@ -812,7 +1069,6 @@ const saveVersion = async (index) => {
     
     appStore.showSnackbar(`버전 ${index + 1}이 성공적으로 저장되었습니다!`, 'success')
     
-    // 저장 후 콘텐츠 관리 페이지로 이동할지 물어보기
     setTimeout(() => {
       if (confirm('저장된 콘텐츠를 확인하시겠습니까?')) {
         router.push('/content')
@@ -829,7 +1085,6 @@ const saveVersion = async (index) => {
 
 const copyToClipboard = async (content) => {
   try {
-    // HTML 콘텐츠인 경우 텍스트만 추출해서 복사
     const textToCopy = isHtmlContent(content) ? extractTextFromHtml(content) : content
     
     await navigator.clipboard.writeText(textToCopy)
@@ -840,19 +1095,16 @@ const copyToClipboard = async (content) => {
   }
 }
 
-// 전체 콘텐츠 복사 (콘텐츠 + 해시태그)
 const copyFullContent = async (version) => {
   try {
     let fullContent = ''
     
-    // 콘텐츠 추가 (HTML인 경우 텍스트만 추출)
     if (isHtmlContent(version.content)) {
       fullContent += extractTextFromHtml(version.content)
     } else {
       fullContent += version.content
     }
     
-    // 해시태그 추가
     if (version.hashtags && version.hashtags.length > 0) {
       fullContent += '\n\n' + version.hashtags.join(' ')
     }
@@ -872,7 +1124,6 @@ const getPlatformIcon = (platform) => {
     'naver_blog': 'mdi-web',
     'facebook': 'mdi-facebook',
     'kakao_story': 'mdi-chat',
-    // 백엔드에서 받는 값에 대한 매핑 추가
     'INSTAGRAM': 'mdi-instagram',
     'NAVER_BLOG': 'mdi-web',
     'FACEBOOK': 'mdi-facebook',
@@ -887,7 +1138,6 @@ const getPlatformColor = (platform) => {
     'naver_blog': 'green',
     'facebook': 'blue',
     'kakao_story': 'amber',
-    // 백엔드에서 받는 값에 대한 매핑 추가
     'INSTAGRAM': 'pink',
     'NAVER_BLOG': 'green',
     'FACEBOOK': 'blue',
@@ -902,7 +1152,6 @@ const getPlatformLabel = (platform) => {
     'naver_blog': '네이버 블로그',
     'facebook': '페이스북',
     'kakao_story': '카카오스토리',
-    // 백엔드에서 받는 값에 대한 매핑 추가
     'INSTAGRAM': '인스타그램',
     'NAVER_BLOG': '네이버 블로그',
     'FACEBOOK': '페이스북',
@@ -942,50 +1191,40 @@ const formatDateTime = (date) => {
 const truncateText = (text, maxLength) => {
   if (!text) return ''
   
-  // HTML 태그가 있으면 제거하고 텍스트만 추출
   const textOnly = text.replace(/<[^>]*>/g, '')
   
   if (textOnly.length <= maxLength) return textOnly
   return textOnly.substring(0, maxLength) + '...'
 }
 
-// HTML 콘텐츠 감지 함수
 const isHtmlContent = (content) => {
   if (!content) return false
-  // HTML 태그가 포함되어 있으면 HTML 콘텐츠로 판단
   return /<[^>]+>/.test(content)
 }
 
-// HTML에서 텍스트만 추출하는 함수
 const extractTextFromHtml = (html) => {
   if (!html) return ''
-  // 임시 div 엘리먼트를 만들어서 텍스트만 추출
   const tempDiv = document.createElement('div')
   tempDiv.innerHTML = html
   return tempDiv.textContent || tempDiv.innerText || ''
 }
 
-// HTML 콘텐츠를 축약하는 함수 (미리보기용)
 const truncateHtmlContent = (html, maxLength) => {
   if (!html) return ''
   
-  // 텍스트 길이가 maxLength보다 짧으면 그대로 반환
   const textContent = extractTextFromHtml(html)
   if (textContent.length <= maxLength) {
     return html
   }
   
-  // HTML을 간단하게 축약
   const tempDiv = document.createElement('div')
   tempDiv.innerHTML = html
   
-  // 첫 번째 섹션만 가져오기 (보통 제목 부분)
   const firstSection = tempDiv.querySelector('div[style*="background"]')
   if (firstSection) {
     return firstSection.outerHTML
   }
   
-  // 첫 번째 섹션이 없으면 텍스트만 축약해서 반환
   return `<div style="padding: 10px; font-family: 'Noto Sans KR', Arial, sans-serif;">${truncateText(textContent, maxLength)}</div>`
 }
 
@@ -1018,11 +1257,6 @@ onMounted(() => {
   background: linear-gradient(135deg, #ffffff 0%, #f8f9ff 100%);
 }
 
-.sortable-header:hover {
-  background-color: rgba(0, 0, 0, 0.04);
-}
-
-/* 모바일 최적화 */
 @media (max-width: 960px) {
   .left-panel {
     border-right: none;
@@ -1039,7 +1273,6 @@ onMounted(() => {
   }
 }
 
-/* HTML 콘텐츠 스타일링 */
 :deep(.html-content) {
   font-family: 'Noto Sans KR', Arial, sans-serif;
 }
@@ -1055,31 +1288,15 @@ onMounted(() => {
   margin: 0 0 10px 0;
 }
 
-:deep(.html-content br) {
-  line-height: 1.6;
-}
-
-:deep(.html-content span[style*="color"]) {
-  font-weight: 500;
-}
-
-/* 해시태그 스타일 보정 */
 :deep(.html-content span[style*="#1DA1F2"]) {
-  color: #1976d2 !important; /* Vuetify primary 색상으로 조정 */
+  color: #1976d2 !important;
 }
 
-/* 미리보기 카드 내 HTML 콘텐츠 스타일 */
 .preview-card :deep(.html-content) {
   font-size: 14px;
   line-height: 1.5;
 }
 
-.preview-card :deep(.html-content div[style*="background"]) {
-  border-radius: 8px;
-  overflow: hidden;
-}
-
-/* 미리보기 콘텐츠 최대 높이 제한 */
 .preview-content {
   max-height: 300px;
   overflow: hidden;
@@ -1096,14 +1313,4 @@ onMounted(() => {
   background: linear-gradient(transparent, white);
   pointer-events: none;
 }
-
-/* 다이얼로그 내 HTML 콘텐츠 스타일 */
-.v-dialog :deep(.html-content) {
-  max-width: 100%;
-  overflow-x: auto;
-}
-
-.v-dialog :deep(.html-content div[style*="max-width"]) {
-  max-width: 100% !important;
-}
 </style>
\ No newline at end of file
diff --git a/src/views/PosterCreationView.vue b/src/views/PosterCreationView.vue
new file mode 100644
index 0000000..63b1e0b
--- /dev/null
+++ b/src/views/PosterCreationView.vue
@@ -0,0 +1,235 @@
+//* src/views/PosterCreationView.vue
+<template>
+  <v-container fluid class="pa-4">
+    <!-- 헤더 -->
+    <div class="d-flex align-center mb-6">
+      <v-btn
+        icon="mdi-arrow-left"
+        variant="text"
+        @click="$router.go(-1)"
+        class="mr-2"
+      />
+      <div>
+        <h1 class="text-h4 font-weight-bold">홍보 포스터 생성</h1>
+        <p class="text-subtitle-1 text-grey-600 mt-1">AI를 활용하여 매력적인 홍보 포스터를 생성하세요</p>
+      </div>
+    </div>
+
+    <!-- 메인 컨텐츠 -->
+    <v-row>
+      <!-- 왼쪽: 입력 폼 -->
+      <v-col cols="12" md="6">
+        <v-card class="elevation-2">
+          <v-card-title class="bg-primary">
+            <v-icon class="mr-2">mdi-form-textbox</v-icon>
+            포스터 정보 입력
+          </v-card-title>
+          
+          <v-card-text class="pa-6">
+            <PosterForm
+              v-model="posterForm"
+              :loading="loading"
+              @generate="generatePoster"
+              @save="savePoster"
+            />
+          </v-card-text>
+        </v-card>
+      </v-col>
+
+      <!-- 오른쪽: 미리보기 -->
+      <v-col cols="12" md="6">
+        <v-card class="elevation-2">
+          <v-card-title class="bg-secondary">
+            <v-icon class="mr-2">mdi-image-outline</v-icon>
+            미리보기
+          </v-card-title>
+          
+          <v-card-text class="pa-6">
+            <PosterPreview
+              :poster-data="generatedPoster"
+              :loading="loading"
+            />
+          </v-card-text>
+        </v-card>
+      </v-col>
+    </v-row>
+
+    <!-- 로딩 오버레이 -->
+    <v-overlay v-model="loading" class="align-center justify-center">
+      <div class="text-center">
+        <v-progress-circular
+          indeterminate
+          size="64"
+          color="primary"
+        />
+        <div class="text-h6 mt-4">{{ loadingMessage }}</div>
+        <div class="text-body-2 text-grey-600 mt-2">{{ loadingSubMessage }}</div>
+      </div>
+    </v-overlay>
+
+    <!-- 성공/오류 스낵바 -->
+    <v-snackbar v-model="showSuccess" color="success" timeout="4000">
+      <v-icon class="mr-2">mdi-check-circle</v-icon>
+      {{ successMessage }}
+    </v-snackbar>
+    
+    <v-snackbar v-model="showError" color="error" timeout="6000">
+      <v-icon class="mr-2">mdi-alert-circle</v-icon>
+      {{ errorMessage }}
+    </v-snackbar>
+  </v-container>
+</template>
+
+<script setup>
+import { ref, onMounted } from 'vue'
+import { useRouter } from 'vue-router'
+import PosterForm from '@/components/poster/PosterForm.vue'
+import PosterPreview from '@/components/poster/PosterPreview.vue'
+import { usePosterStore } from '@/store/poster'
+import { useAuthStore } from '@/store/auth'
+
+/**
+ * 홍보 포스터 생성 페이지
+ * - 포스터 정보 입력 폼
+ * - AI 포스터 생성
+ * - 실시간 미리보기
+ * - 포스터 저장
+ */
+
+// 스토어 및 라우터
+const posterStore = usePosterStore()
+const authStore = useAuthStore()
+const router = useRouter()
+
+// 반응형 데이터
+const loading = ref(false)
+const loadingMessage = ref('')
+const loadingSubMessage = ref('')
+
+// 폼 데이터
+const posterForm = ref({
+  storeId: null,
+  title: '',
+  targetAudience: '메뉴',
+  promotionStartDate: null,
+  promotionEndDate: null,
+  eventName: '',
+  imageStyle: '모던',
+  promotionType: '할인 정보',
+  emotionIntensity: '보통',
+  images: [],
+  category: '이벤트',
+  requirement: '',
+  toneAndManner: '전문적',
+  startDate: null,
+  endDate: null,
+  photoStyle: '밝고 화사한'
+})
+
+// 생성된 포스터 데이터
+const generatedPoster = ref(null)
+
+// 메시지 상태
+const showSuccess = ref(false)
+const showError = ref(false)
+const successMessage = ref('')
+const errorMessage = ref('')
+
+/**
+ * 포스터 생성
+ */
+const generatePoster = async (formData) => {
+  try {
+    loading.value = true
+    loadingMessage.value = 'AI 포스터 생성 중...'
+    loadingSubMessage.value = '멋진 포스터를 만들고 있어요'
+
+    const result = await posterStore.generatePoster({
+      ...formData,
+      storeId: authStore.currentStore?.id || 1
+    })
+
+    if (result.success) {
+      generatedPoster.value = result.data
+      successMessage.value = '포스터가 성공적으로 생성되었습니다!'
+      showSuccess.value = true
+    } else {
+      throw new Error(result.message || '포스터 생성에 실패했습니다.')
+    }
+
+  } catch (error) {
+    console.error('포스터 생성 오류:', error)
+    errorMessage.value = error.message || '포스터 생성 중 오류가 발생했습니다.'
+    showError.value = true
+  } finally {
+    loading.value = false
+  }
+}
+
+/**
+ * 포스터 저장
+ */
+const savePoster = async () => {
+  if (!generatedPoster.value) {
+    errorMessage.value = '저장할 포스터가 없습니다. 먼저 포스터를 생성해주세요.'
+    showError.value = true
+    return
+  }
+
+  try {
+    loading.value = true
+    loadingMessage.value = '포스터 저장 중...'
+    loadingSubMessage.value = '잠시만 기다려주세요'
+
+    const result = await posterStore.savePoster({
+      contentId: generatedPoster.value.contentId,
+      storeId: authStore.currentStore?.id || 1,
+      title: posterForm.value.title,
+      content: generatedPoster.value.content,
+      images: [generatedPoster.value.posterImage],
+      status: 'PUBLISHED',
+      category: posterForm.value.category,
+      requirement: posterForm.value.requirement,
+      toneAndManner: posterForm.value.toneAndManner,
+      emotionIntensity: posterForm.value.emotionIntensity,
+      eventName: posterForm.value.eventName,
+      startDate: posterForm.value.startDate,
+      endDate: posterForm.value.endDate,
+      photoStyle: posterForm.value.photoStyle
+    })
+
+    if (result.success) {
+      successMessage.value = '포스터가 성공적으로 저장되었습니다!'
+      showSuccess.value = true
+      
+      // 3초 후 콘텐츠 관리 페이지로 이동
+      setTimeout(() => {
+        router.push('/content')
+      }, 3000)
+    } else {
+      throw new Error(result.message || '포스터 저장에 실패했습니다.')
+    }
+
+  } catch (error) {
+    console.error('포스터 저장 오류:', error)
+    errorMessage.value = error.message || '포스터 저장 중 오류가 발생했습니다.'
+    showError.value = true
+  } finally {
+    loading.value = false
+  }
+}
+
+// 컴포넌트 마운트 시 초기화
+onMounted(() => {
+  // 현재 매장 정보 설정
+  if (authStore.currentStore) {
+    posterForm.value.storeId = authStore.currentStore.id
+  }
+})
+</script>
+
+<style scoped>
+.v-card-title {
+  color: white;
+}
+</style>
\ No newline at end of file

From c80a766799a9ebad412751c0cdd29858dc2d6ba9 Mon Sep 17 00:00:00 2001
From: unknown <yyoooona@gmail.com>
Date: Thu, 19 Jun 2025 09:20:46 +0900
Subject: [PATCH 11/11] release

---
 public/index.html | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/public/index.html b/public/index.html
index d6addd7..a50b512 100644
--- a/public/index.html
+++ b/public/index.html
@@ -29,7 +29,7 @@
       rel="stylesheet"
     />
 
-    <title>AI 마케팅 - 소상공인을 위한 스마트 마케팅 솔루션</title>
+    <title>test</title>
   </head>
   <body>
     <div id="app"></div>