restart projeckt

README.md

@@ -734,6 +734,14 @@ module.exports = router
    # ✅ ПРАВИЛЬНО - debug глобальный
    log 'Сообщение'
    ```
+8. **Важно подстановка переменных в строки через конкатенацию**
+   ```coffee
+   # ❌ НЕПРАВИЛЬНО
+   `✅ Дизайн-документ создан: ${designDoc._id}`
+
+   # ✅ ПРАВИЛЬНО
+   "✅ Дизайн-документ создан: "+designDoc._id
+   ```
 
 ### ✅ **ОБЯЗАТЕЛЬНО:**
 
@@ -1040,7 +1048,7 @@ class ImportService
             .catch(reject)
           
         catch error
-          reject(new Error("Ошибка парсинга CSV: #{error.message}"))
+          reject(new Error("Ошибка парсинга CSV: "+error.message))
       
       reader.onerror = -> reject(new Error('Ошибка чтения файла'))
       reader.readAsText(file, 'UTF-8')
@@ -1121,7 +1129,7 @@ extractAllAttributes: (csvRow) ->
       if not key in ['№', 'Артикул*', 'Название товара', 'Цена, руб.*', 'Ссылка на главное фото*', 'Ссылки на дополнительные фото']
         attributes[key] = value.toString().trim()
   
-  log "Извлечено атрибутов: #{Object.keys(attributes).length}"
+  log "Извлечено атрибутов: "+Object.keys(attributes).length
   return attributes
 ```
 
@@ -1140,9 +1148,9 @@ extractAllAttributes: (csvRow) ->
 **Пример детального логгирования:**
 ```coffee
 importFromCSV: (file, domain, onProgress) ->
-  log "🚀 Начало импорта CSV файла: #{file.name}"
-  log "📊 Домен для импорта: #{domain}"
-  log "📁 Размер файла: #{file.size} байт"
+  log "🚀 Начало импорта CSV файла: "+file.name
+  log "📊 Домен для импорта: "+domain
+  log "📁 Размер файла: "+file.size+" байт"
   
   return new Promise (resolve, reject) =>
     reader = new FileReader()
@@ -1162,26 +1170,26 @@ importFromCSV: (file, domain, onProgress) ->
         validProducts = results.data.filter (row) => 
           isValid = row and row['Артикул*'] and row['Название товара'] and row['Цена, руб.*']
           if not isValid
-            log "⚠️ Пропущена строка из-за отсутствия обязательных полей: #{JSON.stringify(row)}"
+            log "⚠️ Пропущена строка из-за отсутствия обязательных полей: "+JSON.stringify(row)
           return isValid
         
-        log "✅ Валидных товаров для импорта: #{validProducts.length}"
+        log "✅ Валидных товаров для импорта: "+validProducts.length
         
         this.processProductsInBatches(validProducts, domain, onProgress)
           .then (results) =>
-            log "🎉 Импорт успешно завершен: #{results.length} товаров обработано"
+            log "🎉 Импорт успешно завершен: "+results.length+" товаров обработано"
             resolve(results)
           .catch (error) =>
-            log "❌ Ошибка в процессе импорта: #{error.message}"
+            log "❌ Ошибка в процессе импорта: "+error.message
             reject(error)
         
       catch error
-        log "💥 Критическая ошибка парсинга CSV: #{error.message}"
+        log "💥 Критическая ошибка парсинга CSV: "+error.message
         log "🔍 Stack trace:", error.stack
-        reject(new Error("Ошибка парсинга CSV: #{error.message}"))
+        reject(new Error("Ошибка парсинга CSV: "+error.message))
     
     reader.onerror = (error) ->
-      log "❌ Ошибка чтения файла: #{error}"
+      log "❌ Ошибка чтения файла: "+error
       reject(new Error('Ошибка чтения файла'))
     
     reader.readAsText(file, 'UTF-8')
@@ -1340,6 +1348,45 @@ Drag & drop интерфейс
 Индикатор прогресса загрузки
 
 Поддержка множественного выбора
+
+Настроена полная маршрутизация для админ-панели:
+
+Родительский маршрут /admin с проверкой авторизации
+
+Дочерние маршруты через children:
+
+/admin/dashboard - Дашборд
+
+/admin/products - Управление товарами
+
+/admin/categories - Управление категориями
+
+/admin/import - Импорт товаров
+
+/admin/media - Медиа-менеджер
+
+Реализована система breadcrumbs:
+
+Динамическое обновление хлебных крошек
+
+Поддержка мета-данных в маршрутах
+
+Созданы все необходимые страницы:
+
+Дашборд со статистикой и быстрыми действиями
+
+Заглушки для остальных разделов
+
+Полная навигация между разделами
+
+Улучшена безопасность:
+
+Проверка роли пользователя (только admin)
+
+Редирект при отсутствии прав доступа
+
+
+
 ### 🎯 БЛИЖАЙШИЕ ЗАДАЧИ
 
 2. **Работа с данными**
@@ -1387,39 +1434,33 @@ Drag & drop интерфейс
 напиши файлы реализующие следующую задачу.
  ⚠️ ПРИОРИТЕТ
 
-ЭТАП 1.6: РЕАЛИЗАЦИЯ СИСТЕМЫ ИМПОРТА И МЕДИА-МЕНЕДЖЕРА
-
-Страница импорта товаров:
-
-Интеграция компонента FileUpload
-
-Парсинг CSV файлов с валидацией
-
-Преобразование данных в структуру PouchDB
-
-Пакетная обработка и прогресс-бар
+ЭТАП 1.8: РЕАЛИЗАЦИЯ РЕДАКТОРА КАТЕГОРИЙ И МЕДИА-МЕНЕДЖЕРА
 
 Редактор категорий:
 
-Древовидная структура категорий
+Древовидное отображение с drag&drop
 
-Загрузка изображений для категорий
+Загрузка изображений категорий
 
-Drag & drop для изменения иерархии
-
-Редактирование метаданных
+Редактирование метаданных и SEO
 
 Медиа-менеджер:
 
-Загрузка изображений товаров
+Загрузка изображений с превью
 
 Прикрепление файлов к документам CouchDB
 
 Система кэширования и оптимизации
 
+Интеграция:
+
+Связь медиа-файлов с товарами и категориями
+
 Управление версиями файлов
 
-Приоритет: Критический 🚨 (необходимо для наполнения магазина товарами и контентом)
+Оптимизация производительности
+
+Приоритет: Критический 🚨 (завершает базовый функционал админ-панели)
 
 Приоритет: Высокий ⚠️ (необходимо для наполнения магазина товарами)
 

app/components/Admin/FileUpload/index.coffee

@@ -17,7 +17,7 @@ module.exports =
       default: false
     maxSize:
       type: Number
-      default: 10485760 # 10MB
+      default: 10485760*3 # 10MB
 
   data: ->
     {
@@ -49,11 +49,11 @@ module.exports =
     handleFiles: (files) ->
       validFiles = files.filter (file) =>
         if file.size > @maxSize
-          @$emit('error', `Файл ${file.name} слишком большой. Максимальный размер: ${@maxSize / 1048576}MB`)
+          @$emit('error', "Файл "+file.name+" слишком большой. Максимальный размер: "+@maxSize/1048576+"MB")
           return false
         
         if @accept and !@isFileTypeAccepted(file)
-          @$emit('error', `Файл ${file.name} имеет недопустимый тип`)
+          @$emit('error', "Файл "+file.name+" имеет недопустимый тип")
           return false
         
         return true

app/design/site.coffee

@@ -6,73 +6,66 @@ class SiteDesignDocuments
       categories: @getCategoriesDesignDoc()
       orders: @getOrdersDesignDoc()
       validation: @getValidationDesignDoc()
+      domains: @getDomainsDesignDoc()
     }
 
   getProductsDesignDoc: ->
     {
       _id: '_design/products'
       views:
-        by_category:
+        # Все активные товары
+        all_active:
           map: """
             function(doc) {
               if (doc.type === 'product' && doc.active !== false) {
+                emit(doc._id, null);
+              }
+            }
+          """
+        # Товары по категориям
+        by_category:
+          map: """
+            function(doc) {
+              if (doc.type === 'product' && doc.active !== false && doc.category) {
                 emit([doc.category, doc.name], {
-                  _id: doc._id,
                   name: doc.name,
                   price: doc.price,
-                  images: doc.images,
+                  brand: doc.brand,
                   inStock: doc.inStock,
-                  brand: doc.brand
+                  images: doc.images
                 });
               }
             }
           """
+        # Товары по брендам
         by_brand:
           map: """
             function(doc) {
-              if (doc.type === 'product' && doc.active !== false) {
-                emit([doc.brand, doc.category], {
-                  _id: doc._id,
-                  name: doc.name,
-                  price: doc.price,
-                  category: doc.category
-                });
+              if (doc.type === 'product' && doc.active !== false && doc.brand) {
+                emit([doc.brand, doc.name], null);
               }
             }
           """
+        # Поиск по SKU
         by_sku:
           map: """
             function(doc) {
-              if (doc.type === 'product') {
-                emit(doc.sku, {
-                  _id: doc._id,
-                  name: doc.name,
-                  price: doc.price
-                });
+              if (doc.type === 'product' && doc.sku) {
+                emit(doc.sku, null);
               }
             }
           """
-        search_index:
+        # Товары по доменам
+        by_domain:
           map: """
             function(doc) {
-              if (doc.type === 'product' && doc.active !== false) {
-                var searchable = [
-                  doc.name,
-                  doc.brand,
-                  doc.category,
-                  doc.description
-                ].join(' ').toLowerCase();
-                
-                var words = searchable.split(/\\\\s+/);
-                words.forEach(function(word) {
-                  if (word.length > 2) {
-                    emit(word, 1);
-                  }
+              if (doc.type === 'product' && doc.active !== false && doc.domains) {
+                doc.domains.forEach(function(domain) {
+                  emit(domain, null);
                 });
               }
             }
           """
-        reduce: "_sum"
       language: "javascript"
     }
 
@@ -80,42 +73,45 @@ class SiteDesignDocuments
     {
       _id: '_design/categories'
       views:
-        hierarchical:
+        # Все активные категории
+        all_active:
           map: """
             function(doc) {
-              if (doc.type === 'category') {
-                // Для построения иерархии категорий
-                var path = doc.parent ? [doc._id] : [doc.parent, doc._id];
-                emit(path, {
-                  _id: doc._id,
-                  name: doc.name,
-                  parent: doc.parent,
-                  order: doc.order,
-                  image: doc.image
-                });
+              if (doc.type === 'category' && doc.active !== false) {
+                emit(doc._id, null);
               }
             }
           """
+        # Категории по slug
         by_slug:
           map: """
             function(doc) {
-              if (doc.type === 'category') {
-                emit(doc.slug, {
-                  _id: doc._id,
-                  name: doc.name,
-                  parent: doc.parent
-                });
+              if (doc.type === 'category' && doc.slug) {
+                emit(doc.slug, null);
               }
             }
           """
-        active_categories:
+        # Иерархия категорий
+        hierarchical:
           map: """
             function(doc) {
               if (doc.type === 'category' && doc.active !== false) {
-                emit(doc.order, {
-                  _id: doc._id,
+                var path = doc.parent ? [doc.parent, doc._id] : [doc._id];
+                emit(path, {
                   name: doc.name,
-                  image: doc.image
+                  parent: doc.parent,
+                  order: doc.order
+                });
+              }
+            }
+          """
+        # Категории по доменам
+        by_domain:
+          map: """
+            function(doc) {
+              if (doc.type === 'category' && doc.active !== false && doc.domains) {
+                doc.domains.forEach(function(domain) {
+                  emit(domain, null);
                 });
               }
             }
@@ -127,28 +123,37 @@ class SiteDesignDocuments
     {
       _id: '_design/orders'
       views:
+        # Заказы по пользователю
         by_user:
           map: """
             function(doc) {
-              if (doc.type === 'order') {
-                emit([doc.userId, doc.createdAt], {
-                  _id: doc._id,
-                  total: doc.total,
-                  status: doc.status,
-                  items: doc.items.length
-                });
+              if (doc.type === 'order' && doc.userId) {
+                emit([doc.userId, doc.createdAt], null);
               }
             }
           """
+        # Заказы по статусу
         by_status:
           map: """
             function(doc) {
-              if (doc.type === 'order') {
-                emit([doc.status, doc.createdAt], {
-                  _id: doc._id,
-                  userId: doc.userId,
-                  total: doc.total
-                });
+              if (doc.type === 'order' && doc.status) {
+                emit([doc.status, doc.createdAt], null);
+              }
+            }
+          """
+      language: "javascript"
+    }
+
+  getDomainsDesignDoc: ->
+    {
+      _id: '_design/domains'
+      views:
+        # Настройки по доменам
+        settings_by_domain:
+          map: """
+            function(doc) {
+              if (doc.type === 'domain_settings' && doc.domain) {
+                emit(doc.domain, null);
               }
             }
           """
@@ -160,26 +165,27 @@ class SiteDesignDocuments
       _id: '_design/validation'
       validate_doc_update: """
         function(newDoc, oldDoc, userCtx, secObj) {
-          // Функция проверки документов при сохранении :cite[2]:cite[10]
+          // Базовые проверки для всех документов
+          if (!newDoc.type) {
+            throw({forbidden: 'Document must have a type'});
+          }
           
-          // Проверка типа документа
-          if (newDoc.type) {
-            var validTypes = [
-              'product', 'category', 'order', 'user', 
-              'domain_settings', 'hero_slide', 'blog_article'
-            ];
-            
-            if (validTypes.indexOf(newDoc.type) === -1) {
-              throw({forbidden: 'Invalid document type: ' + newDoc.type});
-            }
+          // Разрешенные типы документов
+          var validTypes = [
+            'product', 'category', 'order', 'user', 
+            'domain_settings', 'hero_slide', 'blog_article'
+          ];
+          
+          if (validTypes.indexOf(newDoc.type) === -1) {
+            throw({forbidden: 'Invalid document type: ' + newDoc.type});
           }
           
-          // Проверка обязательных полей для товаров :cite[2]
+          // Проверка товаров
           if (newDoc.type === 'product') {
-            if (!newDoc.name) {
+            if (!newDoc.name || newDoc.name.trim() === '') {
               throw({forbidden: 'Product must have a name'});
             }
-            if (!newDoc.sku) {
+            if (!newDoc.sku || newDoc.sku.trim() === '') {
               throw({forbidden: 'Product must have SKU'});
             }
             if (typeof newDoc.price !== 'number' || newDoc.price < 0) {
@@ -189,10 +195,10 @@ class SiteDesignDocuments
           
           // Проверка категорий
           if (newDoc.type === 'category') {
-            if (!newDoc.name) {
+            if (!newDoc.name || newDoc.name.trim() === '') {
               throw({forbidden: 'Category must have a name'});
             }
-            if (!newDoc.slug) {
+            if (!newDoc.slug || newDoc.slug.trim() === '') {
               throw({forbidden: 'Category must have a slug'});
             }
           }
@@ -207,44 +213,13 @@ class SiteDesignDocuments
             }
           }
           
-          // Проверка неизменяемых полей
-          if (oldDoc) {
-            if (oldDoc.type !== newDoc.type) {
-              throw({forbidden: 'Document type cannot be changed'});
-            }
-            if (oldDoc.createdAt !== newDoc.createdAt) {
-              throw({forbidden: 'Creation date cannot be changed'});
-            }
-          }
-          
-          // Проверка прав доступа :cite[2]
-          if (newDoc.type === 'order' || newDoc.type === 'user') {
-            if (userCtx.roles.indexOf('_admin') === -1 && 
-                userCtx.roles.indexOf('user') === -1) {
-              throw({unauthorized: 'You are not authorized to modify this document'});
-            }
+          // Запрет изменения типа документа
+          if (oldDoc && oldDoc.type !== newDoc.type) {
+            throw({forbidden: 'Document type cannot be changed'});
           }
         }
       """
       language: "javascript"
     }
 
-  saveDesignDocs: (pouchService) ->
-    log '💾 Сохранение дизайн-документов в базу...'
-    
-    promises = []
-    for name, doc of @designDocs
-      promises.push(
-        pouchService.saveDocument(doc)
-          .then ->
-            log "✅ Дизайн-документ сохранен: #{name}"
-          .catch (error) ->
-            if error.status == 409
-              log "⚠️ Дизайн-документ уже существует: #{name}"
-            else
-              log "❌ Ошибка сохранения дизайн-документа #{name}:", error
-      )
-    
-    return Promise.all(promises)
-
 module.exports = new SiteDesignDocuments()

app/pages/Admin/Categories/index.coffee

@@ -0,0 +1,22 @@
+# app/pages/Admin/Categories/index.coffee
+
+
+module.exports = {
+  props:
+    domainSettings:
+      type: Object
+      default: -> {}
+    language:
+      type: String
+      default: 'ru'
+
+  data: ->
+    {
+      pageTitle: 'Управление категориями'
+    }
+
+  mounted: ->
+    log '📂 Страница управления категориями загружена'
+
+  render: (new Function '_ctx', '_cache', globalThis.renderFns['app/pages/Admin/Categories/index.pug'])()
+}

app/pages/Admin/Categories/index.pug

@@ -0,0 +1,13 @@
+div(class="admin-categories")
+  h1 {{ pageTitle }}
+  p Страница управления категориями в разработке
+  div(class="page-actions")
+    ui-button(@click="$router.push('/admin/products')" type="outline") 🛍️ Управление товарамиdiv(class="admin-categories")
+  h1 {{ pageTitle }}
+  p Страница управления категориями в разработке
+  div(class="page-actions")
+    ui-button(@click="$router.push('/admin/products')" type="outline") 🛍️ Управление товарамиdiv(class="admin-categories")
+  h1 {{ pageTitle }}
+  p Страница управления категориями в разработке
+  div(class="page-actions")
+    ui-button(@click="$router.push('/admin/products')" type="outline") 🛍️ Управление товарами

app/pages/Admin/Dashboard/index.coffee

@@ -0,0 +1,55 @@
+# app/pages/Admin/Dashboard/index.coffee
+
+
+if globalThis.stylFns and globalThis.stylFns['app/pages/Admin/Dashboard/index.styl']
+  styleElement = document.createElement('style')
+  styleElement.type = 'text/css'
+  styleElement.textContent = globalThis.stylFns['app/pages/Admin/Dashboard/index.styl']
+  document.head.appendChild(styleElement)
+
+module.exports = {
+  props:
+    domainSettings:
+      type: Object
+      default: -> {}
+    language:
+      type: String
+      default: 'ru'
+
+  data: ->
+    {
+      stats: {
+        products: 0,
+        categories: 0,
+        orders: 0,
+        users: 0
+      }
+      recentActivity: []
+      loading: true
+    }
+
+  methods:
+    loadDashboardData: ->
+      @loading = true
+      # Заглушка для загрузки данных
+      setTimeout (=>
+        @stats = {
+          products: 156,
+          categories: 12,
+          orders: 24,
+          users: 89
+        }
+        @recentActivity = [
+          { type: 'product', action: 'created', name: 'Грунтовка глубокого проникновения', time: '5 мин назад' },
+          { type: 'order', action: 'placed', name: 'Заказ #00125', time: '10 мин назад' },
+          { type: 'user', action: 'registered', name: 'Новый пользователь', time: '15 мин назад' }
+        ]
+        @loading = false
+      ), 1000
+
+  mounted: ->
+    @loadDashboardData()
+    log '📊 Дашборд админ-панели загружен'
+
+  render: (new Function '_ctx', '_cache', globalThis.renderFns['app/pages/Admin/Dashboard/index.pug'])()
+}

app/pages/Admin/Dashboard/index.pug

@@ -0,0 +1,55 @@
+div(class="admin-dashboard")
+  h1 Дашборд
+  
+  div(class="dashboard-stats")
+    div(class="stat-card")
+      div(class="stat-card__icon") 🛍️
+      div(class="stat-card__content")
+        div(class="stat-card__value") {{ stats.products }}
+        div(class="stat-card__label") Товаров
+    div(class="stat-card")
+      div(class="stat-card__icon") 📂
+      div(class="stat-card__content")
+        div(class="stat-card__value") {{ stats.categories }}
+        div(class="stat-card__label") Категорий
+    div(class="stat-card")
+      div(class="stat-card__icon") 📦
+      div(class="stat-card__content")
+        div(class="stat-card__value") {{ stats.orders }}
+        div(class="stat-card__label") Заказов
+    div(class="stat-card")
+      div(class="stat-card__icon") 👥
+      div(class="stat-card__content")
+        div(class="stat-card__value") {{ stats.users }}
+        div(class="stat-card__label") Пользователей
+  
+  div(class="dashboard-actions")
+    h2 Быстрые действия
+    div(class="action-grid")
+      router-link(to="/admin/products" class="action-card")
+        div(class="action-card__icon") ➕
+        div(class="action-card__text") Добавить товар
+      router-link(to="/admin/import" class="action-card")
+        div(class="action-card__icon") 📥
+        div(class="action-card__text") Импорт товаров
+      router-link(to="/admin/categories" class="action-card")
+        div(class="action-card__icon") 📂
+        div(class="action-card__text") Управление категориями
+      router-link(to="/admin/media" class="action-card")
+        div(class="action-card__icon") 🖼️
+        div(class="action-card__text") Медиа-менеджер
+  
+  div(class="dashboard-activity")
+    h2 Последняя активность
+    div(v-if="loading" class="activity-loading") Загрузка...
+    div(v-else class="activity-list")
+      div(
+        v-for="(activity, index) in recentActivity"
+        :key="index"
+        class="activity-item"
+      )
+        span(class="activity-icon") {{ activity.type === 'product' ? '🛍️' : activity.type === 'order' ? '📦' : '👤' }}
+        div(class="activity-content")
+          strong {{ activity.name }}
+          span {{ activity.action }}
+        span(class="activity-time") {{ activity.time }}

app/pages/Admin/Dashboard/index.styl

@@ -0,0 +1,122 @@
+.admin-dashboard
+  max-width: 1200px
+
+.dashboard-stats
+  display: grid
+  grid-template-columns: repeat(auto-fit, minmax(200px, 1fr))
+  gap: var(--spacing-lg)
+  margin-bottom: var(--spacing-2xl)
+
+.stat-card
+  background: var(--color-white)
+  padding: var(--spacing-xl)
+  border-radius: var(--border-radius)
+  box-shadow: var(--shadow-sm)
+  display: flex
+  align-items: center
+  gap: var(--spacing-lg)
+  transition: var(--transition-fast)
+  
+  &:hover
+    transform: translateY(-2px)
+    box-shadow: var(--shadow-md)
+  
+  .theme-dark &
+    background: var(--color-dark)
+
+.stat-card__icon
+  font-size: 2.5rem
+
+.stat-card__value
+  font-size: var(--font-size-2xl)
+  font-weight: var(--font-weight-bold)
+  color: var(--color-primary)
+
+.stat-card__label
+  color: var(--color-secondary)
+  font-size: var(--font-size-sm)
+
+.dashboard-actions
+  margin-bottom: var(--spacing-2xl)
+
+.action-grid
+  display: grid
+  grid-template-columns: repeat(auto-fit, minmax(250px, 1fr))
+  gap: var(--spacing-lg)
+  margin-top: var(--spacing-lg)
+
+.action-card
+  background: var(--color-white)
+  padding: var(--spacing-xl)
+  border-radius: var(--border-radius)
+  box-shadow: var(--shadow-sm)
+  text-decoration: none
+  color: inherit
+  display: flex
+  align-items: center
+  gap: var(--spacing-lg)
+  transition: var(--transition-fast)
+  
+  &:hover
+    background: var(--color-primary-10)
+    transform: translateY(-2px)
+    box-shadow: var(--shadow-md)
+    color: inherit
+  
+  .theme-dark &
+    background: var(--color-dark)
+    
+    &:hover
+      background: var(--color-primary-20)
+
+.action-card__icon
+  font-size: 2rem
+
+.action-card__text
+  font-weight: var(--font-weight-medium)
+
+.dashboard-activity
+  background: var(--color-white)
+  padding: var(--spacing-xl)
+  border-radius: var(--border-radius)
+  box-shadow: var(--shadow-sm)
+  
+  .theme-dark &
+    background: var(--color-dark)
+
+.activity-loading
+  text-align: center
+  padding: var(--spacing-2xl)
+  color: var(--color-secondary)
+
+.activity-list
+  space-y: var(--spacing-md)
+
+.activity-item
+  display: flex
+  align-items: center
+  gap: var(--spacing-md)
+  padding: var(--spacing-md)
+  border-bottom: 1px solid var(--border-color)
+  
+  &:last-child
+    border-bottom: none
+
+.activity-icon
+  font-size: 1.5rem
+
+.activity-content
+  flex: 1
+  display: flex
+  flex-direction: column
+
+.activity-time
+  color: var(--color-secondary)
+  font-size: var(--font-size-sm)
+
+@media (max-width: 768px)
+  .dashboard-stats
+    grid-template-columns: 1fr 1fr
+  
+  .action-grid
+    grid-template-columns: 1fr

app/pages/Admin/Import/index.coffee

@@ -0,0 +1,597 @@
+# app/pages/Admin/Import/index.coffee
+
+ImportService = require 'app/services/ImportService'
+ProductService = require 'app/services/ProductService'
+CategoryService = require 'app/services/CategoryService'
+FileUpload = require 'app/components/Admin/FileUpload/index.coffee'
+DataTable = require 'app/components/Admin/DataTable/index.coffee'
+
+if globalThis.stylFns and globalThis.stylFns['app/pages/Admin/Import/index.styl']
+  styleElement = document.createElement('style')
+  styleElement.type = 'text/css'
+  styleElement.textContent = globalThis.stylFns['app/pages/Admin/Import/index.styl']
+  document.head.appendChild(styleElement)
+
+module.exports = {
+  components: {
+    'file-upload': FileUpload
+    'data-table': DataTable
+  }
+
+  data: ->
+    {
+      currentStep: 1
+      selectedFile: null
+      csvFields: []
+      csvData: []
+      fieldMapping: {}
+      previewData: []
+      previewLoading: false
+      importing: false
+      importProgress: 0
+      processedItems: 0
+      totalItems: 0
+      importStats: null
+      importErrors: []
+      importComplete: false
+      newCategories: []
+      servicesInitialized: false
+      initializingServices: false
+    }
+
+  computed:
+    previewColumns: ->
+      [
+        { key: 'name', title: 'Название' }
+        { key: 'sku', title: 'Артикул' }
+        { key: 'price', title: 'Цена' }
+        { key: 'brand', title: 'Бренд' }
+        { key: 'category', title: 'Категория' }
+      ]
+
+  methods:
+    onFileSelect: (files) ->
+      @selectedFile = files[0]
+      @parseCSVFile()
+
+    parseCSVFile: ->
+      return unless @selectedFile
+      
+      reader = new FileReader()
+      reader.onload = (e) =>
+        try
+          log '📊 Начало парсинга CSV файла'
+          
+          # Используем Papa Parse с настройками для русского CSV
+          results = Papa.parse(e.target.result, {
+            header: true
+            delimiter: ';'
+            skipEmptyLines: true
+            encoding: 'UTF-8'
+            quoteChar: '"'
+            escapeChar: '"'
+            dynamicTyping: false # Оставляем все как строки
+          })
+          
+          if results.errors.length > 0
+            log '⚠️ Предупреждения при парсинге CSV: ' + JSON.stringify(results.errors)
+          
+          @csvData = results.data.filter (row) -> 
+            # Фильтруем пустые строки и строки без обязательных полей
+            row and row['Артикул*'] and row['Название товара'] and row['Цена, руб.*']
+          
+          @csvFields = Object.keys(@csvData[0] || {})
+          
+          log '📊 CSV файл распарсен успешно:'
+          log 'Количество записей: ' + @csvData.length
+          log 'Поля CSV: ' + @csvFields.join(', ')
+          
+          # Выводим первую запись для отладки
+          if @csvData.length > 0
+            log 'Пример первой записи: ' + JSON.stringify(@csvData[0], null, 2)
+          
+          @initializeFieldMapping()
+          
+        catch error
+          log '❌ Ошибка парсинга CSV: ' + error.message
+          console.error('Ошибка парсинга:', error)
+          @$emit('show-notification', 'Ошибка чтения CSV файла: ' + error.message, 'error')
+      
+      reader.onerror = (error) =>
+        log '❌ Ошибка чтения файла: ' + error
+        @$emit('show-notification', 'Ошибка чтения файла', 'error')
+      
+      reader.readAsText(@selectedFile, 'UTF-8')
+
+    initializeFieldMapping: ->
+      @fieldMapping = {}
+      
+      # Автоматическое сопоставление полей по ключевым словам
+      mappingRules = [
+        { pattern: 'артикул', field: 'sku' }
+        { pattern: 'название', field: 'name' }
+        { pattern: 'цена, руб', field: 'price' }
+        { pattern: 'цена до скидки', field: 'oldPrice' }
+        { pattern: 'бренд', field: 'brand' }
+        { pattern: 'тип', field: 'category' }
+        { pattern: 'описание', field: 'description' }
+        { pattern: 'аннотация', field: 'description' }
+        { pattern: 'ссылка на главное фото', field: 'mainImage' }
+        { pattern: 'ссылки на дополнительные фото', field: 'additionalImages' }
+      ]
+      
+      @csvFields.forEach (csvField) =>
+        lowerField = csvField.toLowerCase()
+        matched = false
+        
+        for rule in mappingRules
+          if lowerField.includes(rule.pattern)
+            @fieldMapping[csvField] = rule.field
+            matched = true
+            break
+        
+        if not matched and csvField != '№'
+          @fieldMapping[csvField] = '' # Не импортировать
+      
+      log '🔄 Автоматическое сопоставление полей: ' + JSON.stringify(@fieldMapping)
+
+    nextStep: ->
+      @currentStep++
+
+    prevStep: ->
+      @currentStep--
+
+    validateMapping: ->
+      requiredFields = ['name', 'sku', 'price']
+      mappedFields = Object.values(@fieldMapping)
+      
+      missingFields = requiredFields.filter (field) -> 
+        not mappedFields.includes(field)
+      
+      if missingFields.length > 0
+        @$emit('show-notification', 'Заполните обязательные поля: ' + missingFields.join(', '), 'error')
+        return
+      
+      @generatePreview()
+      @nextStep()
+
+    generatePreview: ->
+      @previewLoading = true
+      
+      try
+        # Обрабатываем только первые 50 записей для предпросмотра
+        @previewData = @csvData.slice(0, 50).map (row, index) =>
+          @transformRowToProduct(row, index)
+        
+        # Сбор уникальных категорий
+        categorySet = new Set()
+        @previewData.forEach (item) ->
+          if item.category
+            categorySet.add(item.category)
+        @newCategories = Array.from(categorySet)
+
+        @previewLoading = false
+        log '👀 Предпросмотр сгенерирован: ' + @previewData.length + ' товаров'
+        log '📂 Новые категории: ' + @newCategories.join(', ')
+        
+      catch error
+        log '❌ Ошибка генерации предпросмотра: ' + error
+        console.error('Ошибка генерации предпросмотра:', error)
+        @$emit('show-notification', 'Ошибка обработки данных: ' + error.message, 'error')
+        @previewLoading = false
+
+    transformRowToProduct: (row, index) ->
+      # Получаем значения по маппингу
+      sku = row[@getMappedField('sku')] || ''
+      name = row[@getMappedField('name')] || ''
+      price = @parsePrice(row[@getMappedField('price')])
+      oldPrice = @parsePrice(row[@getMappedField('oldPrice')])
+      brand = row[@getMappedField('brand')] || ''
+      category = row[@getMappedField('category')] || ''
+      description = row[@getMappedField('description')] || ''
+      mainImage = row[@getMappedField('mainImage')] || ''
+      additionalImages = row[@getMappedField('additionalImages')] || ''
+
+      # Создаем базовый объект товара
+      product = {
+        _id: 'product:' + (sku || 'temp_' + index)
+        name: name
+        sku: sku
+        price: price
+        oldPrice: oldPrice
+        brand: brand
+        category: category
+        description: description
+        domains: [window.location.hostname]
+        type: 'product'
+        active: true
+        inStock: true
+        images: []
+        attributes: {}
+        createdAt: new Date().toISOString()
+        updatedAt: new Date().toISOString()
+      }
+      
+      # Обработка изображений
+      if mainImage
+        product.images.push({
+          url: mainImage.trim()
+          type: 'main'
+          order: 0
+        })
+      
+      if additionalImages
+        # Разбиваем строку с дополнительными изображениями по переносам
+        imageUrls = additionalImages.split('\n').filter (url) -> url.trim()
+        imageUrls.slice(0, 10).forEach (imgUrl, imgIndex) ->
+          if imgUrl.trim()
+            product.images.push({
+              url: imgUrl.trim()
+              type: 'additional'
+              order: imgIndex + 1
+            })
+      
+      # Обработка дополнительных полей как атрибутов
+      @csvFields.forEach (field) =>
+        if not @fieldMapping[field] and row[field] and field != '№'
+          product.attributes[field] = row[field].toString().trim()
+      
+      # Обработка Rich-контента если есть
+      if row['Rich-контент JSON']
+        try
+          richContent = JSON.parse(row['Rich-контент JSON'])
+          product.richContent = @jsonToMarkdown(richContent)
+        catch error
+          log '⚠️ Ошибка парсинга Rich-контента в строке ' + index + ': ' + error
+      
+      log '🔄 Трансформирован товар ' + index + ': ' + product.name
+      return product
+
+    parsePrice: (priceStr) ->
+      return null unless priceStr
+      try
+        # Удаляем пробелы (например, "1 056,00" -> "1056,00")
+        # Заменяем запятые на точки и удаляем все нецифровые символы кроме точки
+        cleaned = priceStr.toString()
+          .replace(/\s/g, '')          # Удаляем пробелы
+          .replace(',', '.')           # Заменяем запятые на точки
+          .replace(/[^\d.]/g, '')      # Удаляем все кроме цифр и точек
+        
+        price = parseFloat(cleaned)
+        return if isNaN(price) then null else price
+      catch
+        return null
+
+    jsonToMarkdown: (richContent) ->
+      markdown = ''
+      
+      if richContent and richContent.content
+        richContent.content.forEach (block) ->
+          if block.widgetName == 'raTextBlock' and block.text and block.text.items
+            block.text.items.forEach (item) ->
+              if item.type == 'text' and item.content
+                markdown += item.content + '\n\n'
+              else if item.type == 'br'
+                markdown += '\n'
+      
+      return markdown.trim()
+
+    getMappedField: (targetField) ->
+      for csvField, mappedField of @fieldMapping
+        return csvField if mappedField == targetField
+      return ''
+
+    initializeServices: ->
+      return Promise.resolve() if @servicesInitialized
+      
+      if @initializingServices
+        # Ждем завершения предыдущей инициализации
+        return new Promise (resolve) =>
+          checkInterval = setInterval (=>
+            if @servicesInitialized
+              clearInterval(checkInterval)
+              resolve()
+          ), 100
+      
+      @initializingServices = true
+      log '🔄 Инициализация сервисов перед импортом...'
+      
+      try
+        # Инициализируем все необходимые сервисы
+        await ProductService.init()
+        log '✅ ProductService инициализирован'
+        
+        await CategoryService.init()
+        log '✅ CategoryService инициализирован'
+        
+        #await ImportService.init()
+        log '✅ ImportService инициализирован'
+        
+        @servicesInitialized = true
+        @initializingServices = false
+        log '🎉 Все сервисы инициализированы'
+        return Promise.resolve()
+        
+      catch error
+        @initializingServices = false
+        log '❌ Ошибка инициализации сервисов: ' + error
+        throw error
+
+    startImport: ->
+      try
+        # Сначала инициализируем сервисы
+        @currentStep = 4
+        @importing = true
+        @importProgress = 0
+        @processedItems = 0
+        @totalItems = @csvData.length
+        @importErrors = []
+        @importStats = {
+          success: 0
+          errors: 0
+          newCategories: 0
+        }
+        
+        log '🔄 Инициализация сервисов перед импортом...'
+        await @initializeServices()
+        
+        log '🚀 Начало импорта ' + @totalItems + ' товаров'
+        @processImportBatch()
+        
+      catch error
+        log '❌ Ошибка инициализации перед импортом: ' + error
+        @importing = false
+        @$emit('show-notification', 'Ошибка инициализации: ' + error.message, 'error')
+
+    processImportBatch: (batchSize = 10, batchIndex = 0) ->
+      batches = []
+      for i in [0...@csvData.length] by batchSize
+        batches.push(@csvData.slice(i, i + batchSize))
+      
+      processBatch = (currentBatchIndex) =>
+        batch = batches[currentBatchIndex]
+        return unless batch
+
+        try
+          log '🔄 Обработка пакета ' + (currentBatchIndex + 1) + ' из ' + batches.length
+          
+          # Трансформация данных
+          products = batch.map (row, index) =>
+            globalIndex = currentBatchIndex * batchSize + index
+            product = @transformRowToProduct(row, globalIndex)
+            log '📦 Трансформирован товар: ' + product.name + ' (SKU: ' + product.sku + ')'
+            return product
+          
+          # Создание категорий
+          await @createMissingCategories(products)
+          
+          # Сохранение товаров
+          log '💾 Сохранение пакета товаров в базу...'
+          results = await ProductService.bulkSaveProducts(products)
+          
+          # Логируем результат сохранения
+          log '✅ Результат сохранения пакета:'
+          log 'Успешно: ' + results.success.length
+          log 'Ошибок: ' + results.errors.length
+          
+          if results.errors.length > 0
+            results.errors.forEach (error) ->
+              log '❌ Ошибка сохранения товара: ' + error.error
+          
+          # Обновление прогресса
+          @processedItems += batch.length
+          @importProgress = Math.round((@processedItems / @totalItems) * 100)
+          @importStats.success += results.success.length
+          @importStats.errors += results.errors.length
+          
+          # Сохранение ошибок
+          results.errors.forEach (error) =>
+            @importErrors.push({
+              row: currentBatchIndex * batchSize + error.index
+              message: error.error
+            })
+          
+          log '📊 Прогресс импорта: ' + @importProgress + '% (' + @processedItems + ' из ' + @totalItems + ')'
+          
+          # Следующий пакет или завершение
+          if currentBatchIndex < batches.length - 1
+            setTimeout (=>
+              @processImportBatch(batchSize, currentBatchIndex + 1)
+            ), 500
+          else
+            @finishImport()
+            
+        catch error
+          log '❌ Ошибка обработки пакета ' + currentBatchIndex + ': ' + error
+          console.error('Ошибка пакета:', error)
+          @importErrors.push({
+            row: currentBatchIndex * batchSize
+            message: 'Ошибка пакета: ' + error.message
+          })
+          @finishImport()
+      
+      processBatch(batchIndex)
+
+    createMissingCategories: (products) ->
+      # Собираем уникальные категории из товаров
+      categories = []
+      products.forEach (product) ->
+        if product.category and product.category.trim() and not categories.includes(product.category)
+          categories.push(product.category.trim())
+      
+      log '📂 Категории для создания: ' + categories.join(', ')
+      
+      createdCount = 0
+      pouchService = require 'app/utils/pouch'
+      
+      for categoryName in categories
+        try
+          # Создаем простой slug
+          slug = @simpleSlugify(categoryName)
+          categoryId = 'category:' + slug
+          
+          log '🔍 Проверка категории: ' + categoryName
+          
+          # Проверка 1: По ID (slug)
+          categoryExists = false
+          
+          try
+            existingCategory = await pouchService.getDocument(categoryId)
+            categoryExists = true
+            log '⚠️ Категория существует по ID: ' + categoryName
+          catch error
+            if error.status != 404
+              log '❌ Ошибка проверки по ID: ' + error.message
+          
+          # Проверка 2: По имени (если не нашли по ID)
+          if not categoryExists
+            try
+              # Ищем категории с таким же именем
+              categoriesResult = await pouchService.allDocs({
+                startkey: 'category:'
+                endkey: 'category:\ufff0'
+                include_docs: true
+              })
+              
+              sameNameCategory = categoriesResult.rows.find (row) ->
+                row.doc.name.toLowerCase().trim() == categoryName.toLowerCase().trim()
+              
+              if sameNameCategory
+                categoryExists = true
+                log '⚠️ Категория существует по имени: ' + categoryName + ' (ID: ' + sameNameCategory.doc._id + ')'
+            catch error
+              log '❌ Ошибка проверки по имени: ' + error.message
+          
+          # Если категория существует, пропускаем создание
+          if categoryExists
+            continue
+          
+          # Создаем новую категорию
+          log '🆕 Создание категории: ' + categoryName + ' (ID: ' + categoryId + ')'
+          
+          categoryDoc = {
+            _id: categoryId
+            type: 'category'
+            name: categoryName
+            slug: slug
+            domains: [window.location.hostname]
+            active: true
+            order: 0
+            description: ''
+            createdAt: new Date().toISOString()
+            updatedAt: new Date().toISOString()
+          }
+          
+          result = await pouchService.saveDocument(categoryDoc)
+          
+          if result and result.ok
+            createdCount++
+            @importStats.newCategories++
+            log '✅ Создана категория: ' + categoryName
+          else
+            log '❌ Ошибка сохранения категории'
+            
+        catch error
+          if error.status == 409
+            log '⚠️ Категория уже существует (конфликт): ' + categoryName
+          else
+            log '❌ Ошибка создания категории ' + categoryName + ': ' + error.message
+      
+      log '📊 Создано категорий: ' + createdCount
+      return createdCount
+
+
+    simpleSlugify: (text) ->
+      return 'cat-' + Date.now() unless text
+      
+      # Простейшая транслитерация
+      text = text.toString().trim().toLowerCase()
+      slug = text.replace(/\s+/g, '-').replace(/[^a-z0-9\-]/g, '')
+      
+      if slug.length == 0
+        slug = 'cat-' + Date.now()
+      
+      return slug
+
+
+
+     slugify: (text) ->
+      # Базовая проверка
+      return 'category-' + Date.now() + '-' + Math.random().toString(36).substr(2, 5) unless text
+      
+      text = text.toString().trim()
+      return 'category-' + Date.now() + '-' + Math.random().toString(36).substr(2, 5) if text.length == 0
+      
+      # Простая транслитерация кириллицы
+      translitMap = {
+        'а': 'a', 'б': 'b', 'в': 'v', 'г': 'g', 'д': 'd', 'е': 'e', 'ё': 'yo', 'ж': 'zh',
+        'з': 'z', 'и': 'i', 'й': 'y', 'к': 'k', 'л': 'l', 'м': 'm', 'н': 'n', 'о': 'o',
+        'п': 'p', 'р': 'r', 'с': 's', 'т': 't', 'у': 'u', 'ф': 'f', 'х': 'h', 'ц': 'ts',
+        'ч': 'ch', 'ш': 'sh', 'щ': 'sch', 'ъ': '', 'ы': 'y', 'ь': '', 'э': 'e', 'ю': 'yu',
+        'я': 'ya'
+      }
+      
+      # Транслитерация
+      slug = ''
+      for char in text.toLowerCase()
+        if translitMap[char]
+          slug += translitMap[char]
+        else if char.match(/[a-z0-9]/)
+          slug += char
+        else if char == ' ' or char == '-'
+          slug += '-'
+      
+      # Очистка slug
+      slug = slug
+        .replace(/\-\-+/g, '-')
+        .replace(/^-+/, '')
+        .replace(/-+$/, '')
+      
+      # Если slug пустой, создаем уникальный
+      if not slug or slug.length == 0
+        slug = 'category-' + Date.now() + '-' + Math.random().toString(36).substr(2, 5)
+      
+      log '🔧 Создан slug: ' + text + ' -> ' + slug
+      return slug
+
+    finishImport: ->
+      @importing = false
+      @importComplete = true
+      
+      log '🎉 Импорт завершен!'
+      log '📊 Итоговая статистика:'
+      log 'Успешно: ' + @importStats.success
+      log 'Ошибок: ' + @importStats.errors
+      log 'Новых категорий: ' + @importStats.newCategories
+      
+      if @importStats.errors == 0
+        message = 'Импорт завершен успешно! Обработано ' + @importStats.success + ' товаров'
+        @$emit('show-notification', message, 'success')
+      else
+        message = 'Импорт завершен с ошибками. Успешно: ' + @importStats.success + ', Ошибок: ' + @importStats.errors
+        @$emit('show-notification', message, 'warning')
+
+    cancelImport: ->
+      @importing = false
+      @importComplete = true
+      @$emit('show-notification', 'Импорт отменен', 'info')
+
+    resetImport: ->
+      @currentStep = 1
+      @selectedFile = null
+      @csvFields = []
+      @csvData = []
+      @fieldMapping = {}
+      @previewData = []
+      @importStats = null
+      @importErrors = []
+      @importComplete = false
+
+  mounted: ->
+    log '📥 Компонент импорта загружен'
+    # Предварительная инициализация сервисов при загрузке компонента
+    @initializeServices().catch (error) ->
+      log '⚠️ Предварительная инициализация сервисов не удалась: ' + error
+
+  render: (new Function '_ctx', '_cache', globalThis.renderFns['app/pages/Admin/Import/index.pug'])()
+}

app/pages/Admin/Import/index.pug

@@ -0,0 +1,119 @@
+div(class="import-page")
+  h1 Импорт товаров
+  
+  div(class="import-steps")
+    div(class="import-step" :class="{'import-step--active': currentStep === 1}")
+      span(class="import-step__number") 1
+      span Загрузка файла
+    div(class="import-step" :class="{'import-step--active': currentStep === 2}")
+      span(class="import-step__number") 2
+      span Настройка полей
+    div(class="import-step" :class="{'import-step--active': currentStep === 3}")
+      span(class="import-step__number") 3
+      span Предпросмотр
+    div(class="import-step" :class="{'import-step--active': currentStep === 4}")
+      span(class="import-step__number") 4
+      span Импорт
+  
+  div(class="import-content")
+    //- Шаг 1: Загрузка файла
+    div(v-if="currentStep === 1" class="import-step-content")
+      file-upload(
+        accept=".csv,.xlsx"
+        :multiple="false"
+        @select="onFileSelect"
+        @upload="startProcessing"
+      )
+      div(v-if="selectedFile" class="file-info")
+        h3 Выбранный файл: {{ selectedFile.name }}
+        p Размер: {{ (selectedFile.size / 1024 / 1024).toFixed(2) }} MB
+        ui-button(@click="nextStep" type="primary") Далее
+    
+    //- Шаг 2: Настройка полей
+    div(v-if="currentStep === 2" class="import-step-content")
+      h3 Настройка соответствия полей
+      div(class="field-mapping")
+        div(
+          v-for="(csvField, index) in csvFields"
+          :key="index"
+          class="field-mapping__row"
+        )
+          span(class="field-mapping__csv-field") {{ csvField }}
+          select(v-model="fieldMapping[csvField]" class="field-mapping__select")
+            option(value="") Не импортировать
+            option(value="name") Название товара
+            option(value="sku") Артикул
+            option(value="price") Цена
+            option(value="oldPrice") Цена до скидки
+            option(value="brand") Бренд
+            option(value="category") Категория
+            option(value="description") Описание
+            option(value="weight") Вес
+            option(value="volume") Объем
+      
+      div(class="import-actions")
+        ui-button(@click="prevStep" type="outline") Назад
+        ui-button(@click="validateMapping" type="primary") Далее
+    
+    //- Шаг 3: Предпросмотр
+    div(v-if="currentStep === 3" class="import-step-content")
+      h3 Предпросмотр данных
+      div(class="preview-info")
+        p Найдено товаров: {{ previewData.length }}
+        p Будут созданы категории: {{ newCategories.length }}
+      
+      data-table(
+        :data="previewData.slice(0, 10)"
+        :columns="previewColumns"
+        :loading="previewLoading"
+      )
+      
+      div(class="import-actions")
+        ui-button(@click="prevStep" type="outline") Назад
+        ui-button(@click="startImport" type="primary") Начать импорт
+    
+    //- Шаг 4: Импорт
+    div(v-if="currentStep === 4" class="import-step-content")
+      h3 Процесс импорта
+      div(class="import-progress")
+        div(class="import-progress__bar")
+          div(
+            class="import-progress__fill"
+            :style="{ width: importProgress + '%' }"
+          )
+        div(class="import-progress__text")
+          | {{ importProgress }}% ({{ processedItems }} из {{ totalItems }})
+        
+        div(v-if="importStats" class="import-stats")
+          div(class="import-stat")
+            span Успешно: 
+            strong {{ importStats.success }}
+          div(class="import-stat")
+            span С ошибками: 
+            strong {{ importStats.errors }}
+          div(class="import-stat")
+            span Новые категории: 
+            strong {{ importStats.newCategories }}
+      
+      div(v-if="importErrors.length > 0" class="import-errors")
+        h4 Ошибки импорта:
+        div(
+          v-for="(error, index) in importErrors"
+          :key="index"
+          class="import-error"
+        )
+          strong Строка {{ error.row }}: 
+          span {{ error.message }}
+      
+      div(class="import-actions")
+        ui-button(
+          v-if="importComplete"
+          @click="resetImport"
+          type="primary"
+        ) Новый импорт
+        ui-button(
+          v-else
+          @click="cancelImport"
+          type="danger"
+          :disabled="importing"
+        ) Отменить

app/pages/Admin/Import/index.styl

@@ -0,0 +1,184 @@
+.import-page
+  max-width: 1200px
+  margin: 0 auto
+
+.import-steps
+  display: flex
+  justify-content: space-between
+  margin-bottom: var(--spacing-2xl)
+  position: relative
+  
+  &::before
+    content: ''
+    position: absolute
+    top: 20px
+    left: 0
+    right: 0
+    height: 2px
+    background: var(--border-color)
+    z-index: 1
+
+.import-step
+  display: flex
+  flex-direction: column
+  align-items: center
+  position: relative
+  z-index: 2
+  flex: 1
+
+.import-step__number
+  width: 40px
+  height: 40px
+  border-radius: 50%
+  background: var(--color-light)
+  border: 2px solid var(--border-color)
+  display: flex
+  align-items: center
+  justify-content: center
+  font-weight: var(--font-weight-bold)
+  margin-bottom: var(--spacing-sm)
+  transition: var(--transition-normal)
+  
+  .import-step--active &
+    background: var(--color-primary)
+    border-color: var(--color-primary)
+    color: var(--color-white)
+
+.import-step-content
+  background: var(--color-white)
+  padding: var(--spacing-2xl)
+  border-radius: var(--border-radius)
+  box-shadow: var(--shadow-sm)
+  
+  .theme-dark &
+    background: var(--color-dark)
+
+.field-mapping
+  margin: var(--spacing-xl) 0
+
+.field-mapping__row
+  display: flex
+  align-items: center
+  padding: var(--spacing-md)
+  border-bottom: 1px solid var(--border-color)
+  
+  &:last-child
+    border-bottom: none
+
+.field-mapping__csv-field
+  flex: 1
+  font-weight: var(--font-weight-medium)
+
+.field-mapping__select
+  flex: 2
+  padding: var(--spacing-sm)
+  border: 1px solid var(--border-color)
+  border-radius: var(--border-radius)
+  background: var(--color-white)
+  
+  .theme-dark &
+    background: var(--color-dark-50)
+    color: var(--color-light)
+
+.preview-info
+  background: var(--color-light-10)
+  padding: var(--spacing-lg)
+  border-radius: var(--border-radius)
+  margin-bottom: var(--spacing-xl)
+  
+  .theme-dark &
+    background: var(--color-dark-50)
+
+.import-progress
+  margin: var(--spacing-2xl) 0
+
+.import-progress__bar
+  height: 20px
+  background: var(--color-light-10)
+  border-radius: 10px
+  overflow: hidden
+  margin-bottom: var(--spacing-md)
+  
+  .theme-dark &
+    background: var(--color-dark-50)
+
+.import-progress__fill
+  height: 100%
+  background: var(--color-primary)
+  transition: width 0.3s ease
+  border-radius: 10px
+
+.import-progress__text
+  text-align: center
+  font-weight: var(--font-weight-medium)
+  color: var(--color-secondary)
+
+.import-stats
+  display: flex
+  gap: var(--spacing-xl)
+  justify-content: center
+  margin: var(--spacing-xl) 0
+
+.import-stat
+  padding: var(--spacing-md)
+  background: var(--color-light-10)
+  border-radius: var(--border-radius)
+  text-align: center
+  
+  .theme-dark &
+    background: var(--color-dark-50)
+
+.import-errors
+  margin-top: var(--spacing-xl)
+  max-height: 300px
+  overflow-y: auto
+
+.import-error
+  padding: var(--spacing-md)
+  background: var(--color-danger-10)
+  border-left: 4px solid var(--color-danger)
+  margin-bottom: var(--spacing-sm)
+  border-radius: var(--border-radius-sm)
+
+.import-actions
+  display: flex
+  gap: var(--spacing-md)
+  justify-content: flex-end
+  margin-top: var(--spacing-2xl)
+
+.file-info
+  background: var(--color-light-10)
+  padding: var(--spacing-lg)
+  border-radius: var(--border-radius)
+  margin-top: var(--spacing-xl)
+  
+  .theme-dark &
+    background: var(--color-dark-50)
+
+// Адаптивность
+@media (max-width: 768px)
+  .import-steps
+    flex-direction: column
+    gap: var(--spacing-lg)
+    
+    &::before
+      display: none
+  
+  .import-step
+    flex-direction: row
+    gap: var(--spacing-md)
+  
+  .import-step__number
+    margin-bottom: 0
+  
+  .field-mapping__row
+    flex-direction: column
+    align-items: flex-start
+    gap: var(--spacing-sm)
+  
+  .import-stats
+    flex-direction: column
+    gap: var(--spacing-md)
+  
+  .import-actions
+    flex-direction: column

app/pages/Admin/Media/index.coffee

@@ -0,0 +1,22 @@
+# app/pages/Admin/Media/index.coffee
+
+
+module.exports = {
+  props:
+    domainSettings:
+      type: Object
+      default: -> {}
+    language:
+      type: String
+      default: 'ru'
+
+  data: ->
+    {
+      pageTitle: 'Медиа-менеджер'
+    }
+
+  mounted: ->
+    log '🖼️ Медиа-менеджер загружен'
+
+  render: (new Function '_ctx', '_cache', globalThis.renderFns['app/pages/Admin/Media/index.pug'])()
+}

app/pages/Admin/Media/index.pug

@@ -0,0 +1,5 @@
+div(class="admin-media")
+  h1 {{ pageTitle }}
+  p Медиа-менеджер в разработке
+  div(class="page-actions")
+    ui-button(@click="$router.push('/admin/import')" type="outline") 📥 Импорт товаров

app/pages/Admin/Products/index.coffee

@@ -1,535 +1,22 @@
-document.head.insertAdjacentHTML('beforeend','<style type="text/css">'+stylFns['app/pages/Admin/Products/index.styl']+'</style>')
+# app/pages/Admin/Products/index.coffee
 
-PouchDB = require 'app/utils/pouch'
 
+module.exports = {
+  props:
+    domainSettings:
+      type: Object
+      default: -> {}
+    language:
+      type: String
+      default: 'ru'
 
-module.exports =
-  name: 'AdminProducts'
-  render: (new Function '_ctx', '_cache', renderFns['app/pages/Admin/Products/index.pug'])()
-  
   data: ->
-    return {
-      products: []
-      categories: []
-      showProductModal: false
-      showImportModal: false
-      selectedFile: null
-      importing: false
-      importProgress: 0
-      importResults: null
-      currentProduct: {
-        _id: ''
-        type: 'product'
-        name: ''
-        sku: ''
-        price: 0
-        oldPrice: 0
-        category: ''
-        description: ''
-        active: true
-        domains: []
-        attributes: {}
-        images: []
-        createdAt: ''
-        updatedAt: ''
-      }
-      searchQuery: ''
-      selectedCategory: ''
-      bulkActions: []
-      selectedProducts: []
+    {
+      pageTitle: 'Управление товарами'
     }
-  
-  computed:
-    filteredProducts: ->
-      products = @products
-      
-      if @searchQuery
-        query = @searchQuery.toLowerCase()
-        products = products.filter (product) =>
-          product.name?.toLowerCase().includes(query) or
-          product.sku?.toLowerCase().includes(query)
-      
-      if @selectedCategory
-        products = products.filter (product) =>
-          product.category == @selectedCategory
-      
-      return products
-    
-    availableDomains: ->
-      @$root.currentDomainSettings?.domains or [@$root.currentDomain]
-  
+
   mounted: ->
-    @loadProducts()
-    @loadCategories()
-  
-  methods:
-    loadProducts: ->
-      debug.log '📥 Загрузка товаров...'
-      PouchDB.queryView('admin', 'products', { include_docs: true })
-      .then (result) =>
-        @products = result.rows.map (row) -> row.doc
-        debug.log "✅ Загружено #{@products.length} товаров"
-      .catch (error) =>
-        debug.log '❌ Ошибка загрузки товаров:', error
-        @showNotification 'Ошибка загрузки товаров', 'error'
-    
-    loadCategories: ->
-      debug.log '📥 Загрузка категорий...'
-      PouchDB.queryView('admin', 'categories', { include_docs: true })
-      .then (result) =>
-        @categories = result.rows.map (row) -> row.doc
-        debug.log "✅ Загружено #{@categories.length} категорий"
-      .catch (error) =>
-        debug.log '❌ Ошибка загрузки категорий:', error
-    
-    createCategory: (categoryName) ->
-      categorySlug = categoryName.toLowerCase().replace(/[^a-z0-9а-яё]/g, '-').replace(/-+/g, '-')
-      
-      categoryData = {
-        _id: "category:#{categorySlug}"
-        type: 'category'
-        name: categoryName
-        slug: categorySlug
-        active: true
-        order: @categories.length
-        domains: @availableDomains
-        createdAt: new Date().toISOString()
-        updatedAt: new Date().toISOString()
-      }
-      
-      PouchDB.saveToRemote(categoryData)
-      .then (result) =>
-        debug.log "✅ Создана категория: #{categoryName}"
-        @loadCategories()
-        return categorySlug
-      .catch (error) =>
-        debug.log '❌ Ошибка создания категории:', error
-        throw error
-    
-    transformProductData: (csvData, index) ->
-      debug.log "🔄 Преобразование данных товара #{index + 1}: #{csvData['Артикул*']}"
-      
-      sku = csvData['Артикул*']?.toString().trim()
-      return null unless sku
-      
-      # Определяем категорию
-      categoryName = csvData['Тип*']?.trim() or 'Другое'
-      debug.log "🔍 Поиск категории: #{categoryName}"
-      
-      # Ищем существующую категорию
-      existingCategory = @categories.find (cat) -> cat.name == categoryName
-      
-      if existingCategory
-        categorySlug = existingCategory.slug
-        debug.log "✅ Использована существующая категория: #{categoryName}"
-      else
-        debug.log "🆕 Создание новой категории: #{categoryName}"
-        categorySlug = categoryName.toLowerCase().replace(/[^a-z0-9а-яё]/g, '-').replace(/-+/g, '-')
-        # Категория будет создана позже в процессе импорта
-      
-      # Базовые данные товара
-      productData = {
-        _id: "product:#{sku}"
-        type: 'product'
-        name: csvData['Название товара']?.trim() or "Товар #{sku}"
-        sku: sku
-        price: parseFloat(csvData['Цена, руб.*']?.replace(/\s/g, '')?.replace(',', '.') or 0)
-        oldPrice: parseFloat(csvData['Цена до скидки, руб.']?.replace(/\s/g, '')?.replace(',', '.') or 0)
-        category: categorySlug
-        brand: csvData['Бренд*']?.trim()
-        description: csvData['Аннотация']?.trim() or ''
-        active: true
-        domains: @availableDomains
-        attributes: {}
-        images: []
-        createdAt: new Date().toISOString()
-        updatedAt: new Date().toISOString()
-      }
-      
-      # Дополнительные атрибуты
-      additionalAttributes = {}
-      for key, value of csvData
-        if value and not key in ['Артикул*', 'Название товара', 'Цена, руб.*', 'Цена до скидки, руб.', 'Тип*', 'Бренд*', 'Аннотация', 'Rich-контент JSON', 'Ссылка на главное фото', 'Ссылки на дополнительные фото']
-          additionalAttributes[key] = value
-      
-      productData.attributes = additionalAttributes
-      
-      # Rich-контент
-      if csvData['Rich-контент JSON']
-        try
-          richContent = JSON.parse(csvData['Rich-контент JSON'])
-          productData.richContent = richContent
-        catch error
-          debug.log '⚠️ Ошибка парсинга Rich-контента:', error
-      
-      debug.log "✅ Данные товара полностью преобразованы: #{sku}"
-      return productData
-    
-    downloadAndStoreImage: (imageUrl, docId, filename) ->
-      return new Promise (resolve, reject) =>
-        debug.log "🔄 Начало загрузки изображения: #{imageUrl}"
-        
-        # Проверяем валидность URL
-        unless imageUrl and imageUrl.startsWith('http')
-          debug.log '⚠️ Невалидный URL изображения:', imageUrl
-          return resolve(null)
-        
-        # Создаем уникальное имя файла
-        fileExtension = imageUrl.split('.').pop()?.split('?')[0] or 'jpg'
-        uniqueFilename = "#{filename}.#{fileExtension}"
-        
-        debug.log "📁 Документ: #{docId}, Файл: #{uniqueFilename}"
-        
-        # Используем fetch вместо XMLHttpRequest для лучшей обработки ошибок
-        fetch(imageUrl)
-        .then (response) =>
-          unless response.ok
-            throw new Error("HTTP #{response.status}: #{response.statusText}")
-          return response.blob()
-        .then (blob) =>
-          debug.log "✅ Blob получен, размер: #{blob.size} байт"
-          
-          if blob.size == 0
-            throw new Error('Пустой blob')
-          
-          # Читаем blob как ArrayBuffer
-          reader = new FileReader()
-          reader.onload = (event) =>
-            try
-              arrayBuffer = event.target.result
-              debug.log "✅ ArrayBuffer успешно прочитан, размер: #{arrayBuffer.byteLength} байт"
-              
-              # Сохраняем attachment в PouchDB
-              PouchDB.localDb.putAttachment(
-                docId,
-                uniqueFilename,
-                @currentProduct._rev,
-                blob,
-                blob.type
-              )
-              .then (result) =>
-                debug.log "✅ Attachment сохранен: #{uniqueFilename}"
-                resolve({
-                  filename: uniqueFilename
-                  contentType: blob.type
-                  size: blob.size
-                })
-              .catch (attachmentError) =>
-                debug.log "❌ Ошибка сохранения attachment:", attachmentError
-                reject(attachmentError)
-            catch readError
-              debug.log "❌ Ошибка чтения blob:", readError
-              reject(readError)
-          
-          reader.onerror = (error) =>
-            debug.log "❌ Ошибка FileReader:", error
-            reject(error)
-          
-          reader.readAsArrayBuffer(blob)
-        .catch (fetchError) =>
-          debug.log "❌ Ошибка загрузки изображения:", fetchError
-          reject(fetchError)
-    
-    processProductImages: (productData, csvData) ->
-      debug.log "🖼️ Начало обработки изображений для товара: #{productData.sku}"
-      
-      imagePromises = []
-      
-      # Основное изображение
-      mainImageUrl = csvData['Ссылка на главное фото']?.trim()
-      if mainImageUrl
-        imagePromises.push(
-          @downloadAndStoreImage(mainImageUrl, productData._id, 'main')
-          .then (imageInfo) =>
-            if imageInfo
-              productData.mainImage = imageInfo.filename
-              return imageInfo
-            return null
-          .catch (error) =>
-            debug.log "⚠️ Не удалось загрузить основное изображение:", error
-            return null
-        )
-      
-      # Дополнительные изображения
-      additionalImages = csvData['Ссылки на дополнительные фото']
-      if additionalImages
-        # Разделяем строку по переносам и фильтруем пустые значения
-        imageUrls = additionalImages.split('\n')
-          .map((url) -> url.trim())
-          .filter((url) -> url and url.startsWith('http'))
-          .slice(0, 5) # Ограничиваем 5 изображениями
-        
-        imageUrls.forEach (imageUrl, index) =>
-          imagePromises.push(
-            @downloadAndStoreImage(imageUrl, productData._id, "additional-#{index + 1}")
-            .then (imageInfo) =>
-              if imageInfo
-                return imageInfo.filename
-              return null
-            .catch (error) =>
-              debug.log "⚠️ Не удалось загрузить дополнительное изображение:", error
-              return null
-          )
-      
-      return Promise.allSettled(imagePromises)
-      .then (results) =>
-        # Фильтруем успешно загруженные изображения
-        successfulResults = results.filter (r) -> r.status == 'fulfilled' and r.value
-        additionalFilenames = successfulResults.slice(1).map (r) -> r.value?.filename
-        productData.additionalImages = additionalFilenames.filter (filename) -> filename
-        debug.log "✅ Обработано изображений: #{successfulResults.length}"
-        return productData
-      .catch (error) =>
-        debug.log "❌ Ошибка обработки изображений:", error
-        return productData
-    
-    saveProduct: (productData) ->
-      debug.log "💾 Попытка сохранения товара: #{productData.sku}"
-      
-      return new Promise (resolve, reject) =>
-        # Сначала пытаемся получить существующий документ для получения _rev
-        PouchDB.getDocument(productData._id)
-        .then (existingDoc) =>
-          debug.log "🔄 Обновление существующего товара: #{productData.sku}"
-          productData._rev = existingDoc._rev
-          productData.updatedAt = new Date().toISOString()
-          
-          # Сохраняем в удаленную БД
-          PouchDB.saveToRemote(productData)
-          .then (result) =>
-            debug.log "✅ Товар сохранен, получение обновленной версии: #{productData.sku}"
-            # Получаем обновленный документ
-            PouchDB.getDocument(productData._id)
-            .then (updatedDoc) =>
-              debug.log "✅ Документ получен с актуальным _rev: #{updatedDoc._rev?.substring(0, 10)}..."
-              resolve(updatedDoc)
-            .catch (getError) =>
-              debug.log "⚠️ Не удалось получить обновленный документ:", getError
-              resolve(result)
-          .catch (saveError) =>
-            debug.log "❌ Ошибка сохранения товара:", saveError
-            reject(saveError)
-        .catch (getError) =>
-          if getError.status == 404
-            debug.log "🆕 Создание нового товара: #{productData.sku}"
-            productData.createdAt = new Date().toISOString()
-            productData.updatedAt = productData.createdAt
-            
-            PouchDB.saveToRemote(productData)
-            .then (result) =>
-              debug.log "✅ Товар сохранен в БД: #{productData.sku}"
-              resolve(result)
-            .catch (saveError) =>
-              debug.log "❌ Ошибка создания товара:", saveError
-              reject(saveError)
-          else
-            debug.log "❌ Ошибка при получении документа:", getError
-            reject(getError)
-    
-    readFile: (file) ->
-      return new Promise (resolve, reject) =>
-        reader = new FileReader()
-        reader.onload = (event) -> resolve(event.target.result)
-        reader.onerror = (error) -> reject(error)
-        reader.readAsText(file, 'UTF-8')
-    
-    importProducts: ->
-      unless @selectedFile
-        @showNotification 'Выберите файл для импорта', 'error'
-        return
-      
-      @importing = true
-      @importProgress = 0
-      @importResults = null
-      
-      debug.log '📦 Начало импорта товаров...'
-      
-      @readFile(@selectedFile)
-      .then (text) =>
-        # Парсим CSV
-        results = Papa.parse(text, {
-          header: true
-          delimiter: ';'
-          skipEmptyLines: true
-          encoding: 'UTF-8'
-        })
-        
-        # Фильтруем валидные строки
-        validProducts = results.data.filter (row, index) =>
-          row and row['Артикул*'] and row['Название товара'] and row['Цена, руб.*']
-        
-        debug.log "📊 Найдено валидных товаров: #{validProducts.length}"
-        
-        if validProducts.length == 0
-          throw new Error('Не найдено валидных товаров для импорта')
-        
-        # Создаем массив для обещаний
-        importPromises = []
-        processedCount = 0
-        errors = []
-        
-        # Обрабатываем каждый товар
-        validProducts.forEach (product, index) =>
-          promise = =>
-            debug.log "🔧 Обработка товара #{index + 1}/#{validProducts.length}: #{product['Название товара']?.substring(0, 50)}..."
-            
-            try
-              # Преобразуем данные CSV в объект товара
-              productData = @transformProductData(product, index)
-              return Promise.resolve(null) unless productData
-              
-              # Обрабатываем категорию
-              categoryName = product['Тип*']?.trim() or 'Другое'
-              existingCategory = @categories.find (cat) -> cat.name == categoryName
-              
-              if not existingCategory
-                debug.log "🏷️ Создание категории: #{categoryName}"
-                return @createCategory(categoryName)
-                .then (categorySlug) =>
-                  productData.category = categorySlug
-                  # Перезагружаем категории
-                  @loadCategories()
-                  return productData
-                .catch (categoryError) =>
-                  debug.log "⚠️ Не удалось создать категорию, используется 'Другое'"
-                  productData.category = 'drugoe'
-                  return productData
-              else
-                return Promise.resolve(productData)
-            catch transformError
-              debug.log "❌ Ошибка преобразования товара:", transformError
-              errors.push("Товар #{index + 1}: #{transformError.message}")
-              return Promise.resolve(null)
-          .then (productData) =>
-            return null unless productData
-            
-            # Обрабатываем изображения
-            return @processProductImages(productData, product)
-            .then (productWithImages) =>
-              # Сохраняем товар
-              return @saveProduct(productWithImages)
-            .then (savedProduct) =>
-              processedCount++
-              @importProgress = Math.round((processedCount / validProducts.length) * 100)
-              debug.log "✅ Обработан товар #{processedCount}/#{validProducts.length}: #{savedProduct.sku}"
-              return savedProduct
-            .catch (saveError) =>
-              errorMsg = "Товар #{index + 1} (#{productData.sku}): #{saveError.message}"
-              debug.log "❌ Ошибка обработки товара #{index + 1}:", saveError
-              errors.push(errorMsg)
-              return null
-        
-          importPromises.push(promise())
-        
-        # Ожидаем завершения всех операций
-        return Promise.allSettled(importPromises)
-        .then (results) =>
-          successfulImports = results.filter((r) -> r.status == 'fulfilled' and r.value).length
-          failedImports = results.filter((r) -> r.status == 'rejected').length
-          
-          @importResults = {
-            success: true
-            processed: validProducts.length
-            successful: successfulImports
-            failed: failedImports
-            errors: errors
-          }
-          
-          debug.log "🎉 Импорт завершен: #{successfulImports} успешно, #{failedImports} с ошибками"
-          
-          if successfulImports > 0
-            @showNotification "Импортировано #{successfulImports} товаров"
-            @loadProducts() # Перезагружаем список
-          else
-            @showNotification 'Не удалось импортировать ни одного товара', 'error'
-      .catch (error) =>
-        debug.log '❌ Ошибка импорта:', error
-        @importResults = {
-          success: false
-          error: error.message
-          processed: 0
-          successful: 0
-          failed: 0
-          errors: [error.message]
-        }
-        @showNotification "Ошибка импорта: #{error.message}", 'error'
-      .finally =>
-        @importing = false
-        @selectedFile = null
-    
-    editProduct: (product) ->
-      @currentProduct = Object.assign({}, product)
-      @showProductModal = true
-    
-    deleteProduct: (product) ->
-      if confirm("Удалить товар \"#{product.name}\"?")
-        PouchDB.localDb.remove(product)
-        .then =>
-          PouchDB.saveToRemote(product) # Удаляем из удаленной БД
-          .then =>
-            @showNotification 'Товар удален'
-            @loadProducts()
-          .catch (error) =>
-            debug.log '❌ Ошибка удаления товара из удаленной БД:', error
-            @showNotification 'Ошибка удаления товара', 'error'
-        .catch (error) =>
-          debug.log '❌ Ошибка удаления товара:', error
-          @showNotification 'Ошибка удаления товара', 'error'
-    
-    saveProductForm: ->
-      unless @currentProduct.name and @currentProduct.sku and @currentProduct.price
-        @showNotification 'Заполните обязательные поля', 'error'
-        return
-      
-      productData = Object.assign({}, @currentProduct)
-      
-      if productData._id
-        # Обновление существующего товара
-        productData.updatedAt = new Date().toISOString()
-      else
-        # Создание нового товара
-        productData._id = "product:#{productData.sku}"
-        productData.type = 'product'
-        productData.createdAt = new Date().toISOString()
-        productData.updatedAt = productData.createdAt
-      
-      @saveProduct(productData)
-      .then (result) =>
-        @showProductModal = false
-        @resetCurrentProduct()
-        @showNotification 'Товар сохранен'
-        @loadProducts()
-      .catch (error) =>
-        debug.log '❌ Ошибка сохранения товара:', error
-        @showNotification 'Ошибка сохранения товара', 'error'
-    
-    resetCurrentProduct: ->
-      @currentProduct = {
-        _id: ''
-        type: 'product'
-        name: ''
-        sku: ''
-        price: 0
-        oldPrice: 0
-        category: ''
-        description: ''
-        active: true
-        domains: @availableDomains
-        attributes: {}
-        images: []
-        createdAt: ''
-        updatedAt: ''
-      }
-    
-    showNotification: (message, type = 'success') ->
-      @$root.showNotification(message, type)
-    
-    handleFileSelect: (event) ->
-      @selectedFile = event.target.files[0]
-      debug.log "📁 Выбран файл: #{@selectedFile?.name}"
-    
-    toggleAllProducts: (event) ->
-      if event.target.checked
-        @selectedProducts = @filteredProducts.map (product) -> product._id
-      else
-        @selectedProducts = []
+    log '🛍️ Страница управления товарами загружена'
+
+  render: (new Function '_ctx', '_cache', globalThis.renderFns['app/pages/Admin/Products/index.pug'])()
+}

app/pages/Admin/Products/index.pug

@@ -1,215 +1,6 @@
-.admin-products
-  .admin-products__header
-    h1.admin-products__title Управление товарами
-    .admin-products__actions
-      button.admin-products__btn.admin-products__btn--primary(
-        @click="showProductModal = true"
-      ) Добавить товар
-      button.admin-products__btn.admin-products__btn--secondary(
-        @click="showImportModal = true"
-      ) Импорт из CSV
-
-  .admin-products__filters
-    .admin-products__search
-      input.admin-products__search-input(
-        type="text"
-        placeholder="Поиск по названию или артикулу..."
-        v-model="searchQuery"
-      )
-    .admin-products__category-filter
-      select.admin-products__category-select(v-model="selectedCategory")
-        option(value="") Все категории
-        option(
-          v-for="category in categories"
-          :value="category.slug"
-        ) {{ category.name }}
-
-  .admin-products__content
-    .admin-products__table-container
-      table.admin-products__table
-        thead
-          tr
-            th.admin-products__th-checkbox
-              input(
-                type="checkbox"
-                @change="toggleAllProducts"
-                :checked="selectedProducts.length === filteredProducts.length"
-              )
-            th.admin-products__th Название
-            th.admin-products__th Артикул
-            th.admin-products__th Категория
-            th.admin-products__th Цена
-            th.admin-products__th Статус
-            th.admin-products__th Действия
-        tbody
-          tr.admin-products__tr(
-            v-for="product in filteredProducts"
-            :key="product._id"
-          )
-            td.admin-products__td-checkbox
-              input(
-                type="checkbox"
-                :value="product._id"
-                v-model="selectedProducts"
-              )
-            td.admin-products__td {{ product.name }}
-            td.admin-products__td {{ product.sku }}
-            td.admin-products__td {{ product.category }}
-            td.admin-products__td {{ product.price }} ₽
-            td.admin-products__td
-              span.admin-products__status(
-                :class="{'admin-products__status--active': product.active, 'admin-products__status--inactive': !product.active}"
-              ) {{ product.active ? 'Активен' : 'Неактивен' }}
-            td.admin-products__td
-              .admin-products__actions
-                button.admin-products__action-btn.admin-products__action-btn--edit(
-                  @click="editProduct(product)"
-                ) Редактировать
-                button.admin-products__action-btn.admin-products__action-btn--delete(
-                  @click="deleteProduct(product)"
-                ) Удалить
-
-    .admin-products__empty(v-if="filteredProducts.length === 0")
-      p.admin-products__empty-text Товары не найдены
-
-  //- Модальное окно товара
-  .admin-modal(v-if="showProductModal")
-    .admin-modal__overlay(@click="showProductModal = false")
-    .admin-modal__content
-      .admin-modal__header
-        h2.admin-modal__title {{ currentProduct._id ? 'Редактировать товар' : 'Добавить товар' }}
-        button.admin-modal__close(@click="showProductModal = false") ×
-      
-      .admin-modal__body
-        .admin-form
-          .admin-form__group
-            label.admin-form__label Название товара *
-            input.admin-form__input(
-              type="text"
-              v-model="currentProduct.name"
-              placeholder="Введите название товара"
-            )
-          
-          .admin-form__group
-            label.admin-form__label Артикул *
-            input.admin-form__input(
-              type="text"
-              v-model="currentProduct.sku"
-              placeholder="Введите артикул"
-            )
-          
-          .admin-form__group
-            label.admin-form__label Категория
-            select.admin-form__select(v-model="currentProduct.category")
-              option(value="") Выберите категорию
-              option(
-                v-for="category in categories"
-                :value="category.slug"
-              ) {{ category.name }}
-          
-          .admin-form__row
-            .admin-form__group
-              label.admin-form__label Цена *
-              input.admin-form__input(
-                type="number"
-                v-model.number="currentProduct.price"
-                placeholder="0.00"
-                step="0.01"
-              )
-            
-            .admin-form__group
-              label.admin-form__label Старая цена
-              input.admin-form__input(
-                type="number"
-                v-model.number="currentProduct.oldPrice"
-                placeholder="0.00"
-                step="0.01"
-              )
-          
-          .admin-form__group
-            label.admin-form__label Описание
-            textarea.admin-form__textarea(
-              v-model="currentProduct.description"
-              placeholder="Введите описание товара"
-              rows="4"
-            )
-          
-          .admin-form__group
-            label.admin-form__label
-              input.admin-form__checkbox(
-                type="checkbox"
-                v-model="currentProduct.active"
-              )
-              span Активный товар
-      
-      .admin-modal__footer
-        button.admin-modal__btn.admin-modal__btn--secondary(
-          @click="showProductModal = false"
-        ) Отмена
-        button.admin-modal__btn.admin-modal__btn--primary(
-          @click="saveProductForm"
-        ) Сохранить
-
-  //- Модальное окно импорта
-  .admin-modal(v-if="showImportModal")
-    .admin-modal__overlay(@click="showImportModal = false")
-    .admin-modal__content
-      .admin-modal__header
-        h2.admin-modal__title Импорт товаров из CSV
-        button.admin-modal__close(@click="showImportModal = false") ×
-      
-      .admin-modal__body
-        .admin-import
-          .admin-import__upload
-            input.admin-import__file-input(
-              type="file"
-              accept=".csv"
-              @change="handleFileSelect"
-            )
-            .admin-import__upload-area(
-              :class="{'admin-import__upload-area--dragover': dragOver}"
-              @drop="handleDrop"
-              @dragover="handleDragOver"
-              @dragleave="dragOver = false"
-            )
-              p.admin-import__upload-text
-                span Выберите CSV файл
-                | или перетащите его сюда
-          
-          .admin-import__info(v-if="selectedFile")
-            .admin-import__file-info
-              span.admin-import__file-name {{ selectedFile.name }}
-              span.admin-import__file-size ({{ (selectedFile.size / 1024).toFixed(2) }} KB)
-          
-          .admin-import__progress(v-if="importing")
-            .admin-import__progress-bar
-              .admin-import__progress-fill(:style="{width: importProgress + '%'}")
-            .admin-import__progress-text {{ importProgress }}%
-          
-          .admin-import__results(v-if="importResults")
-            .admin-import__result(
-              :class="{'admin-import__result--success': importResults.success, 'admin-import__result--error': !importResults.success}"
-            )
-              h4.admin-import__result-title {{ importResults.success ? 'Импорт завершен' : 'Ошибка импорта' }}
-              p.admin-import__result-text
-                | Обработано: {{ importResults.processed }},
-                | Успешно: {{ importResults.successful }},
-                | С ошибками: {{ importResults.failed }}
-              
-              .admin-import__errors(v-if="importResults.errors && importResults.errors.length > 0")
-                h5.admin-import__errors-title Ошибки:
-                ul.admin-import__errors-list
-                  li.admin-import__error(
-                    v-for="error in importResults.errors"
-                    :key="error"
-                  ) {{ error }}
-      
-      .admin-modal__footer
-        button.admin-modal__btn.admin-modal__btn--secondary(
-          @click="showImportModal = false"
-          :disabled="importing"
-        ) Отмена
-        button.admin-modal__btn.admin-modal__btn--primary(
-          @click="importProducts"
-          :disabled="!selectedFile || importing"
-        ) {{ importing ? 'Импорт...' : 'Начать импорт' }}
+div(class="admin-products")
+  h1 {{ pageTitle }}
+  p Страница управления товарами в разработке
+  div(class="page-actions")
+    ui-button(@click="$router.push('/admin/import')" type="primary") 📥 Импорт товаров
+    ui-button(@click="$router.push('/admin/categories')" type="outline") 📂 Управление категориями

app/pages/Admin/index.coffee

@@ -1,3 +1,5 @@
+# app/pages/Admin/index.coffee
+
 
 if globalThis.stylFns and globalThis.stylFns['app/pages/Admin/index.styl']
   styleElement = document.createElement('style')
@@ -30,23 +32,26 @@ module.exports = {
       @$emit('show-notification', 'Вы вышли из админ-панели', 'info')
 
     updateBreadcrumbs: ->
-      crumbs = []
-      pathArray = @$route.path.split('/').filter (x) -> x
+      crumbs = [{ path: '/admin', name: 'Админ-панель' }]
       
-      pathArray.forEach (path, index) =>
-        path = "/#{pathArray.slice(0, index + 1).join('/')}"
-        name = @getBreadcrumbName(path, pathArray[index])
-        crumbs.push({ path, name })
+      if @$route.matched.length > 1
+        @$route.matched.slice(1).forEach (route) =>
+          if route.meta?.breadcrumb
+            crumbs.push({
+              path: route.path,
+              name: route.meta.breadcrumb
+            })
       
       @breadcrumbs = crumbs
 
     getBreadcrumbName: (path, segment) ->
       names =
-        '/admin': 'Дашборд'
+        '/admin': 'Админ-панель'
+        '/admin/dashboard': 'Дашборд'
         '/admin/products': 'Товары'
         '/admin/categories': 'Категории'
         '/admin/import': 'Импорт'
-        '/admin/media': 'Медиафайлы'
+        '/admin/media': 'Медиа'
       
       return names[path] || segment.charAt(0).toUpperCase() + segment.slice(1)
 

app/router/index.coffee

@@ -1,6 +1,21 @@
 # app/router/index.coffee
+
 config = require 'app/config'
 
+# Импорт компонентов страниц
+HomePage = require 'app/pages/Home/index.coffee'
+NotFoundPage = require 'app/pages/NotFound/index.coffee'
+CatalogPage = require 'app/pages/Catalog/index.coffee'
+ProductPage = require 'app/pages/Product/index.coffee'
+CartPage = require 'app/pages/Cart/index.coffee'
+AdminPage = require 'app/pages/Admin/index.coffee'
+
+# Импорт дочерних страниц админ-панели
+AdminDashboard = require 'app/pages/Admin/Dashboard/index.coffee'
+AdminProducts = require 'app/pages/Admin/Products/index.coffee'
+AdminCategories = require 'app/pages/Admin/Categories/index.coffee'
+AdminImport = require 'app/pages/Admin/Import/index.coffee'
+AdminMedia = require 'app/pages/Admin/Media/index.coffee'
 
 # Middleware для проверки прав доступа
 authGuard = (to, from, next) ->
@@ -8,7 +23,22 @@ authGuard = (to, from, next) ->
   # Здесь будет логика проверки пользователя из глобального состояния
   if to.matched.some (record) -> record.meta.requiresAuth
     # Проверка авторизации
-    next() # Временная заглушка - всегда разрешаем доступ
+    userData = localStorage.getItem('user')
+    if userData
+      try
+        user = JSON.parse(userData)
+        user.role = 'admin'
+        if user.role == 'admin'
+          next()
+        else
+          log '🚫 Доступ запрещен: недостаточно прав'
+          next('/')
+      catch
+        log '🚫 Ошибка проверки пользователя'
+        next('/')
+    else
+      log '🚫 Пользователь не авторизован'
+      next()
   else
     next()
 
@@ -23,44 +53,101 @@ router = VueRouter.createRouter({
     {
       path: '/'
       name: 'Home'
-      component: require 'app/pages/Home/index.coffee'
+      component: HomePage
       beforeEnter: [domainMiddleware]
     }
     {
       path: '/catalog'
       name: 'Catalog'
-      component: require 'app/pages/Catalog/index.coffee'
+      component: CatalogPage
       beforeEnter: [domainMiddleware]
     }
     {
       path: '/catalog/:category?'
       name: 'CatalogCategory'
-      component: require 'app/pages/Catalog/index.coffee'
+      component: CatalogPage
       beforeEnter: [domainMiddleware]
     }
     {
       path: '/product/:id'
       name: 'Product'
-      component: require 'app/pages/Product/index.coffee'
+      component: ProductPage
       beforeEnter: [domainMiddleware]
     }
     {
       path: '/cart'
       name: 'Cart'
-      component: require 'app/pages/Cart/index.coffee'
+      component: CartPage
       beforeEnter: [domainMiddleware]
     }
     {
       path: '/admin'
       name: 'Admin'
-      component: require 'app/pages/Admin/index.coffee'
+      component: AdminPage
       meta: { requiresAuth: true }
       beforeEnter: [domainMiddleware, authGuard]
+      redirect: '/admin/dashboard'
+      children: [
+        {
+          path: 'dashboard'
+          name: 'AdminDashboard'
+          component: AdminDashboard
+          meta: { 
+            title: 'Дашборд',
+            breadcrumb: 'Дашборд'
+          }
+        }
+        {
+          path: 'products'
+          name: 'AdminProducts'
+          component: AdminProducts
+          meta: { 
+            title: 'Управление товарами',
+            breadcrumb: 'Товары'
+          }
+        }
+        {
+          path: 'categories'
+          name: 'AdminCategories'
+          component: AdminCategories
+          meta: { 
+            title: 'Управление категориями', 
+            breadcrumb: 'Категории'
+          }
+        }
+        {
+          path: 'import'
+          name: 'AdminImport'
+          component: AdminImport
+          meta: { 
+            title: 'Импорт товаров',
+            breadcrumb: 'Импорт'
+          }
+        }
+        {
+          path: 'media'
+          name: 'AdminMedia'
+          component: AdminMedia
+          meta: { 
+            title: 'Медиа-менеджер',
+            breadcrumb: 'Медиа'
+          }
+        }
+        {
+          path: 'import/:step?'
+          name: 'AdminImportStep'
+          component: AdminImport
+          meta: { 
+            title: 'Импорт товаров',
+            breadcrumb: 'Импорт'
+          }
+        }
+      ]
     }
     {
       path: '/:pathMatch(.*)*'
       name: 'NotFound'
-      component: require 'app/pages/NotFound/index.coffee'
+      component: NotFoundPage
       beforeEnter: [domainMiddleware]
     }
   ]
@@ -68,10 +155,22 @@ router = VueRouter.createRouter({
 
 # Глобальные обработчики роутера
 router.beforeEach (to, from, next) ->
-  #log "Переход с "+ from.fullPath +" на "+to.fullPath+""
+  #log "Переход с \"#{from.path}\" на \"#{to.path}\""
+  
+  # Установка заголовка страницы
+  if to.meta?.title
+    document.title = "#{to.meta.title} - Браер-Колор"
+  else if to.name
+    document.title = "#{to.name} - Браер-Колор"
+  
   next()
 
 router.afterEach (to, from) ->
-  #log "Навигация завершена на "+to.fullPath+""
+  #log "Навигация завершена на \"#{to.path}\""
+
+# Глобальный обработчик ошибок навигации
+router.onError (error) ->
+  log '💥 Ошибка навигации:', error
+  console.error('Ошибка навигации:', error)
 
 module.exports = router

app/services/CategoryService.coffee

@@ -15,14 +15,14 @@ class CategoryService
       log '✅ CategoryService инициализирован'
       return Promise.resolve()
     catch error
-      log '❌ Ошибка инициализации CategoryService:', error
+      log '❌ Ошибка инициализации CategoryService: ' + error
       return Promise.reject(error)
 
   getAllCategories: ->
     await @ensureInit()
     
     try
-      result = await @pouchService.queryView('categories', 'active_categories', {
+      result = await @pouchService.queryView('categories', 'all_active', {
         include_docs: true
       })
       
@@ -32,10 +32,10 @@ class CategoryService
       # Сортировка по порядку
       categories.sort (a, b) -> a.order - b.order
       
-      log '📂 Загружены категории:', categories.length
+      log '📂 Загружены категории: ' + categories.length
       return categories
     catch error
-      log '❌ Ошибка загрузки категорий:', error
+      log '❌ Ошибка загрузки категорий: ' + error
       throw error
 
   getCategoryBySlug: (slug) ->
@@ -49,15 +49,31 @@ class CategoryService
       
       if result.rows.length > 0
         category = new Category(result.rows[0].doc)
-        log "📂 Загружена категория по slug: #{slug}"
+        log '📂 Загружена категория по slug: ' + slug
         return category
       else
-        log "⚠️ Категория не найдена по slug: #{slug}"
+        log '⚠️ Категория не найдена по slug: ' + slug
         return null
     catch error
-      log "❌ Ошибка поиска категории по slug #{slug}:", error
+      log '❌ Ошибка поиска категории по slug ' + slug + ': ' + error
       throw error
 
+  getCategoryById: (id) ->
+    await @ensureInit()
+    
+    try
+      doc = await @pouchService.getDocument(id)
+      category = new Category(doc)
+      log '📂 Загружена категория по ID: ' + id
+      return category
+    catch error
+      if error.status == 404
+        log '⚠️ Категория не найдена по ID: ' + id
+        return null
+      else
+        log '❌ Ошибка загрузки категории по ID ' + id + ': ' + error
+        throw error
+
   getHierarchicalCategories: ->
     await @ensureInit()
     
@@ -75,7 +91,7 @@ class CategoryService
       log '🌳 Построена иерархия категорий'
       return hierarchical
     catch error
-      log '❌ Ошибка построения иерархии категорий:', error
+      log '❌ Ошибка построения иерархии категорий: ' + error
       throw error
 
   buildHierarchy: (categories, parentId = null) ->
@@ -96,17 +112,77 @@ class CategoryService
     await @ensureInit()
     
     try
-      category = new Category(categoryData)
+      # Если переданы данные, создаем объект Category
+      if categoryData instanceof Category
+        category = categoryData
+      else
+        category = new Category(categoryData)
       
       # Генерация ID если не установлен
       if not category._id
-        category._id = "category:#{Date.now()}"
+        category._id = 'category:' + category.slug
+      
+      # Убедимся, что есть все обязательные поля
+      category.type = 'category'
+      category.active = category.active != false
+      category.domains = category.domains || [window.location.hostname]
+      category.order = category.order || 0
+      category.createdAt = category.createdAt || new Date().toISOString()
+      category.updatedAt = new Date().toISOString()
       
       result = await @pouchService.saveDocument(category)
-      log "💾 Категория сохранена: #{category.name}"
+      log '💾 Категория сохранена: ' + category.name + ' (ID: ' + category._id + ')'
       return result
     catch error
-      log "❌ Ошибка сохранения категории:", error
+      log '❌ Ошибка сохранения категории: ' + error
+      throw error
+
+  bulkSaveCategories: (categories) ->
+    await @ensureInit()
+    
+    try
+      # Преобразуем категории в документы для PouchDB
+      docs = categories.map (category) =>
+        if category._id and category._rev
+          return category
+        else
+          # Новая категория
+          return {
+            _id: category._id || 'category:' + category.slug
+            type: 'category'
+            name: category.name
+            slug: category.slug
+            parent: category.parent || null
+            order: category.order || 0
+            image: category.image || ''
+            description: category.description || ''
+            domains: category.domains || [window.location.hostname]
+            active: category.active != false
+            seo: category.seo || {}
+            createdAt: category.createdAt || new Date().toISOString()
+            updatedAt: new Date().toISOString()
+          }
+      
+      result = await @pouchService.bulkDocs(docs)
+      
+      success = []
+      errors = []
+      
+      result.forEach (item, index) =>
+        if item.ok
+          success.push(categories[index])
+        else
+          errors.push({
+            category: categories[index]
+            error: item.error || 'Unknown error'
+            index: index
+          })
+      
+      log '📦 Пакетное сохранение категорий: успешно ' + success.length + ', ошибок ' + errors.length
+      return { success, errors }
+      
+    catch error
+      log '❌ Ошибка пакетного сохранения категорий: ' + error
       throw error
 
   ensureInit: ->

app/services/ImportService.coffee

@@ -0,0 +1,212 @@
+# app/services/ImportService.coffee
+{ Product, Category } = require 'app/types/data'
+ProductService = require 'app/services/ProductService'
+CategoryService = require 'app/services/CategoryService'
+
+class ImportService
+  constructor: ->
+    @batchSize = 50
+    @maxImages = 5
+
+  importCSVData: (csvData, fieldMapping, domain, onProgress) ->
+    log '🚀 Начало импорта CSV данных'
+    
+    try
+      # Трансформация данных
+      products = csvData.map (row, index) =>
+        @transformRowToProduct(row, fieldMapping, domain, index)
+      
+      # Фильтрация валидных товаров
+      validProducts = products.filter (product) =>
+        product.name and product.sku and product.price > 0
+      
+      log "✅ Валидных товаров: " + validProducts.length + " из " + products.length
+      
+      # Пакетная обработка
+      return await @processProductsInBatches(validProducts, domain, onProgress)
+      
+    catch error
+      log '❌ Ошибка импорта CSV данных:', error
+      throw error
+
+  transformRowToProduct: (row, fieldMapping, domain, index) ->
+    product = new Product()
+    
+    # Базовые поля
+    skuValue = row[@getFieldByMapping(row, fieldMapping, 'sku')] or "temp_" + index
+    product._id = "product:" + skuValue
+    product.name = @getFieldByMapping(row, fieldMapping, 'name') || ''
+    product.sku = skuValue
+    product.price = @parsePrice(@getFieldByMapping(row, fieldMapping, 'price'))
+    product.oldPrice = @parsePrice(@getFieldByMapping(row, fieldMapping, 'oldPrice'))
+    product.brand = @getFieldByMapping(row, fieldMapping, 'brand') || ''
+    product.category = @getFieldByMapping(row, fieldMapping, 'category') || ''
+    product.description = @getFieldByMapping(row, fieldMapping, 'description') || ''
+    product.domains = [domain]
+    
+    # Обработка изображений
+    product.images = @processProductImages(row, product._id)
+    
+    # Rich-контент
+    richContentField = @getFieldByMapping(row, fieldMapping, 'richContent')
+    if richContentField
+      try
+        product.richContent = @jsonToMarkdown(JSON.parse(richContentField))
+      catch error
+        log '⚠️ Ошибка парсинга rich-контента:', error
+    
+    # Атрибуты
+    product.attributes = @extractProductAttributes(row, fieldMapping)
+    
+    return product
+
+  getFieldByMapping: (row, fieldMapping, targetField) ->
+    for csvField, mappedField of fieldMapping
+      if mappedField == targetField and row[csvField]
+        return row[csvField]
+    return ''
+
+  parsePrice: (priceStr) ->
+    return null unless priceStr
+    price = parseFloat(priceStr.toString().replace(',', '.').replace(/\s/g, ''))
+    return if isNaN(price) then null else price
+
+  processProductImages: (row, docId) ->
+    images = []
+    
+    # Главное изображение
+    mainImage = @getFieldByMapping(row, @fieldMapping, 'mainImage')
+    if mainImage
+      images.push {
+        url: mainImage
+        type: 'main'
+        order: 0
+        filename: "main-" + Date.now() + ".jpg"
+      }
+    
+    # Дополнительные изображения
+    additionalImages = @getFieldByMapping(row, @fieldMapping, 'additionalImages')
+    if additionalImages
+      imageUrls = additionalImages.split('\n').slice(0, @maxImages)
+      imageUrls.forEach (imgUrl, index) ->
+        if imgUrl.trim()
+          images.push {
+            url: imgUrl.trim()
+            type: 'additional'
+            order: index + 1
+            filename: "additional-" + index + "-" + Date.now() + ".jpg"
+          }
+    
+    return images
+
+  extractProductAttributes: (row, fieldMapping) ->
+    attributes = {}
+    
+    # Все поля, не попавшие в маппинг, становятся атрибутами
+    for field, value of row
+      if value and not fieldMapping[field]
+        attributes[field] = value.toString().trim()
+    
+    return attributes
+
+  processProductsInBatches: (products, domain, onProgress) ->
+    batches = []
+    for i in [0...products.length] by @batchSize
+      batches.push(products.slice(i, i + @batchSize))
+    
+    processed = 0
+    results = {
+      success: []
+      errors: []
+    }
+    
+    processBatch = async (batch) =>
+      try
+        # Создание отсутствующих категорий
+        await @ensureCategoriesExist(batch, domain)
+        
+        # Сохранение товаров
+        batchResults = await ProductService.bulkSaveProducts(batch)
+        
+        results.success = results.success.concat(batchResults.success)
+        results.errors = results.errors.concat(batchResults.errors)
+        
+        processed += batch.length
+        
+        # Прогресс
+        if onProgress
+          onProgress({
+            processed: processed
+            total: products.length
+            percentage: Math.round((processed / products.length) * 100)
+            results: results
+          })
+          
+        return batchResults
+        
+      catch error
+        log '❌ Ошибка обработки пакета:', error
+        batchErrors = batch.map (product, index) =>
+          { product: product, error: error.message, index: index }
+        
+        results.errors = results.errors.concat(batchErrors)
+        return { success: [], errors: batchErrors }
+
+    # Последовательная обработка пакетов
+    for batch, index in batches
+      await processBatch(batch, index)
+    
+    log "✅ Импорт завершен: Успешно " + results.success.length + ", Ошибок " + results.errors.length
+    return results
+
+  ensureCategoriesExist: (products, domain) ->
+    categories = []
+    products.forEach (product) ->
+      if product.category and categories.indexOf(product.category) == -1
+        categories.push(product.category)
+    
+    for categoryName in categories
+      try
+        slug = @slugify(categoryName)
+        existingCategory = await CategoryService.getCategoryBySlug(slug)
+        
+        if not existingCategory
+          category = new Category()
+          category._id = "category:" + slug
+          category.name = categoryName
+          category.slug = slug
+          category.domains = [domain]
+          category.type = 'category'
+          category.active = true
+          category.order = 0
+          
+          await CategoryService.saveCategory(category)
+          log "✅ Создана категория: " + categoryName
+      catch error
+        log "❌ Ошибка создания категории " + categoryName + ":", error
+
+  slugify: (text) ->
+    return '' unless text
+    text.toString().toLowerCase()
+      .replace(/\s+/g, '-')
+      .replace(/[^\w\-]+/g, '')
+      .replace(/\-\-+/g, '-')
+      .replace(/^-+/, '')
+      .replace(/-+$/, '')
+
+  jsonToMarkdown: (richContent) ->
+    # Преобразование JSON rich-контента в Markdown
+    markdown = ''
+    
+    if richContent and richContent.content
+      richContent.content.forEach (block) ->
+        if block.widgetName == 'raTextBlock' and block.text and block.text.items
+          block.text.items.forEach (item) ->
+            if item.type == 'text' and item.content
+              markdown += item.content + '\n\n'
+            else if item.type == 'br'
+              markdown += '\n'
+    
+    return markdown.trim()
+
+module.exports = new ImportService()

app/services/ProductService.coffee

@@ -22,17 +22,14 @@ class ProductService
     await @ensureInit()
     
     try
-      opts = 
+      result = await @pouchService.queryView('products', 'all_active', {
         include_docs: true
-        startkey: ['product']
-        endkey: ['product', {}]
-      
-      result = await @pouchService.queryView('products', 'by_category', opts)
+      })
       
       products = result.rows.map (row) ->
         new Product(row.doc)
       
-      log '📦 Загружены товары:', products.length
+      log '📦 Загружены товары: ' + products.length
       return products
     catch error
       log '❌ Ошибка загрузки товаров:', error
@@ -42,19 +39,19 @@ class ProductService
     await @ensureInit()
     
     try
-      opts = 
+      result = await @pouchService.queryView('products', 'by_category', {
+        startkey: [category]
+        endkey: [category, {}]
         include_docs: true
-        key: [category]
-      
-      result = await @pouchService.queryView('products', 'by_category', opts)
+      })
       
       products = result.rows.map (row) ->
         new Product(row.doc)
       
-      log "📦 Загружены товары категории #{category}:", products.length
+      log "📦 Загружены товары категории " + category + ": " + products.length
       return products
     catch error
-      log "❌ Ошибка загрузки товаров категории #{category}:", error
+      log "❌ Ошибка загрузки товаров категории " + category + ":", error
       throw error
 
   getProductBySku: (sku) ->
@@ -68,60 +65,64 @@ class ProductService
       
       if result.rows.length > 0
         product = new Product(result.rows[0].doc)
-        log "📦 Загружен товар по SKU: #{sku}"
+        log "📦 Загружен товар по SKU: " + sku
         return product
       else
-        log "⚠️ Товар не найден по SKU: #{sku}"
+        log "⚠️ Товар не найден по SKU: " + sku
         return null
     catch error
-      log "❌ Ошибка поиска товара по SKU #{sku}:", error
+      log "❌ Ошибка поиска товара по SKU " + sku + ":", error
       throw error
 
-  searchProducts: (query, options = {}) ->
+  bulkSaveProducts: (products) ->
     await @ensureInit()
     
     try
-      # Простой поиск по индексу
-      searchTerms = query.toLowerCase().split(/\s+/).filter (term) -> term.length > 2
-      
-      if searchTerms.length == 0
-        return []
+      # Преобразуем товары в документы для PouchDB
+      docs = products.map (product) =>
+        if product._id and product._rev
+          return product
+        else
+          # Новый товар
+          return {
+            _id: product._id
+            type: 'product'
+            name: product.name
+            sku: product.sku
+            price: product.price
+            oldPrice: product.oldPrice
+            brand: product.brand
+            category: product.category
+            description: product.description
+            domains: product.domains || [window.location.hostname]
+            active: product.active != false
+            inStock: product.inStock != false
+            attributes: product.attributes || {}
+            images: product.images || []
+            createdAt: product.createdAt || new Date().toISOString()
+            updatedAt: new Date().toISOString()
+          }
       
-      # Здесь будет реализация полнотекстового поиска
-      # Временная реализация - поиск по всем товарам и фильтрация
-      allProducts = await @getAllProducts()
+      result = await @pouchService.bulkDocs(docs)
       
-      filteredProducts = allProducts.filter (product) ->
-        searchable = [
-          product.name
-          product.brand
-          product.category
-          product.description
-        ].join(' ').toLowerCase()
-        
-        searchTerms.every (term) -> searchable.includes(term)
+      success = []
+      errors = []
       
-      log "🔍 Результаты поиска '#{query}':", filteredProducts.length
-      return filteredProducts
-    catch error
-      log "❌ Ошибка поиска товаров '#{query}':", error
-      throw error
-
-  saveProduct: (productData) ->
-    await @ensureInit()
-    
-    try
-      product = new Product(productData)
+      result.forEach (item, index) =>
+        if item.ok
+          success.push(products[index])
+        else
+          errors.push({
+            product: products[index]
+            error: item.error || 'Unknown error'
+            index: index
+          })
       
-      # Генерация ID если не установлен
-      if not product._id
-        product._id = "product:#{product.sku}"
+      log "📦 Пакетное сохранение: успешно " + success.length + ", ошибок " + errors.length
+      return { success, errors }
       
-      result = await @pouchService.saveDocument(product)
-      log "💾 Товар сохранен: #{product.name}"
-      return result
     catch error
-      log "❌ Ошибка сохранения товара:", error
+      log '❌ Ошибка пакетного сохранения товаров:', error
       throw error
 
   ensureInit: ->

app/utils/pouch.coffee

@@ -7,6 +7,7 @@ class PouchDBService
     @syncHandler = null
     @initialized = false
     @syncStatus = 'disconnected'
+    @useLocalDB = false # Отключаем локальную БД временно
 
   init: ->
     return Promise.resolve() if @initialized
@@ -14,35 +15,122 @@ class PouchDBService
     try
       log '🔄 Инициализация PouchDB сервиса'
       
-      # Инициализация локальной базы
-      @localDb = new PouchDB(@localDbName or 'braer_color_cache')
-      log '✅ Локальная PouchDB инициализирована'
+      # Отключаем локальную базу в браузере
+      if @useLocalDB
+        @localDb = new PouchDB(@localDbName or 'braer_color_cache')
+        log '✅ Локальная PouchDB инициализирована'
+      else
+        log '⚠️ Локальная PouchDB отключена'
       
       # Инициализация удаленной базы
       @remoteDb = new PouchDB(@remoteDbUrl, {
-        skip_setup: false
+        skip_setup: true # Не создавать автоматически
         fetch: (url, opts) =>
           opts.credentials = 'include'
-          # Добавляем заголовки аутентификации
           opts.headers ?= {}
-          # Здесь будут добавляться токены аутентификации
+          # Добавляем базовую аутентификацию если нужно
           PouchDB.fetch(url, opts)
       })
       
+      # Проверяем и создаем базу если нужно
+      await @ensureDatabaseExists()
       log '✅ Удаленная CouchDB подключена'
       
-      # Настройка непрерывной синхронизации
-      @setupSync()
+      # Создаем дизайн-документы
+      await @ensureDesignDocuments()
+      log '✅ Дизайн-документы проверены/созданы'
+      
+      # Настройка синхронизации (если локальная БД включена)
+      if @useLocalDB
+        @setupSync()
       
       @initialized = true
       log '🎉 PouchDB сервис полностью инициализирован'
       return Promise.resolve()
       
     catch error
-      log '❌ Критическая ошибка инициализации PouchDB:', error
+      log '❌ Критическая ошибка инициализации PouchDB: ' + error
       return Promise.reject(error)
 
+  ensureDatabaseExists: ->
+    try
+      # Пробуем получить информацию о базе
+      info = await @remoteDb.info()
+      log '📊 Информация о базе: ' + JSON.stringify(info)
+      return true
+    catch error
+      if error.status == 404
+        log '📦 База данных не найдена, создаем новую...'
+        # Создаем базу через отдельный запрос
+        await @createDatabase()
+        return true
+      else
+        log '❌ Ошибка подключения к базе: ' + error
+        throw error
+
+  createDatabase: ->
+    try
+      # Создаем базу через PUT запрос
+      response = await fetch(@remoteDbUrl, {
+        method: 'PUT'
+        headers: {
+          'Content-Type': 'application/json'
+        }
+      })
+      
+      if response.ok
+        log '✅ База данных успешно создана'
+        # Переинициализируем подключение
+        @remoteDb = new PouchDB(@remoteDbUrl, {
+          skip_setup: false
+        })
+      else
+        throw new Error('Не удалось создать базу: ' + response.status)
+    catch error
+      log '❌ Ошибка создания базы данных: ' + error
+      throw error
+
+  ensureDesignDocuments: ->
+    designDocs = require 'app/design/site'
+    promises = []
+    
+    for name, doc of designDocs.designDocs
+      promises.push(@ensureDesignDocument(doc))
+    
+    await Promise.all(promises)
+    log '✅ Все дизайн-документы проверены'
+
+  ensureDesignDocument: (designDoc) ->
+    try
+      # Пробуем получить существующий дизайн-документ
+      existingDoc = await @remoteDb.get(designDoc._id)
+      
+      # Сравниваем версии или хеши для определения необходимости обновления
+      if @needsDesignDocUpdate(existingDoc, designDoc)
+        designDoc._rev = existingDoc._rev
+        await @remoteDb.put(designDoc)
+        log '✅ Дизайн-документ обновлен: ' + designDoc._id
+      else
+        log '⚠️ Дизайн-документ уже актуален: ' + designDoc._id
+        
+    catch error
+      if error.status == 404
+        # Дизайн-документ не существует, создаем новый
+        await @remoteDb.put(designDoc)
+        log '✅ Дизайн-документ создан: ' + designDoc._id
+      else
+        log '❌ Ошибка работы с дизайн-документом ' + designDoc._id + ': ' + error
+        throw error
+
+  needsDesignDocUpdate: (existingDoc, newDoc) ->
+    # Простая проверка: сравниваем хеш views
+    existingViewsHash = JSON.stringify(existingDoc.views)
+    newViewsHash = JSON.stringify(newDoc.views)
+    return existingViewsHash != newViewsHash
+
   setupSync: ->
+    return unless @useLocalDB and @localDb and @remoteDb
+    
     @syncHandler = PouchDB.sync(@localDb, @remoteDb, {
       live: true,
       retry: true,
@@ -51,39 +139,35 @@ class PouchDBService
       filter: (doc) => @shouldSyncDocument(doc)
     })
     .on 'change', (info) =>
-      log '📡 Синхронизация: данные изменены', info
+      log '📡 Синхронизация: данные изменены'
       @syncStatus = 'syncing'
     .on 'paused', (err) =>
       log '⏸️ Синхронизация приостановлена'
       @syncStatus = 'paused'
-    .on 'active', ->
+    .on 'active', =>
       log '🔄 Синхронизация активна'
       @syncStatus = 'active'
     .on 'denied', (err) =>
-      log '🚫 Доступ запрещен:', err
+      log '🚫 Доступ запрещен: ' + err
       @syncStatus = 'denied'
     .on 'complete', (info) =>
-      log '✅ Синхронизация завершена', info
+      log '✅ Синхронизация завершена'
       @syncStatus = 'complete'
     .on 'error', (err) =>
-      log '❌ Ошибка синхронизации:', err
+      log '❌ Ошибка синхронизации: ' + err
       @syncStatus = 'error'
       @handleSyncError(err)
 
   shouldSyncDocument: (doc) ->
-    # Фильтрация по доменам и типам документов
     return true if doc.type in ['product', 'category', 'domain_settings', 'hero_slide']
     return true if doc.type in ['blog_article', 'route', 'user_settings']
     
-    # Для заказов и пользовательских данных проверяем принадлежность
     if doc.type in ['order', 'user_data', 'cart']
       return doc.userId == @getCurrentUserId()
     
-    # По умолчанию не синхронизируем
     return false
 
   getCurrentUserId: ->
-    # Получение ID текущего пользователя
     userData = localStorage.getItem('user')
     if userData
       try
@@ -94,9 +178,8 @@ class PouchDBService
     return 'anonymous'
 
   handleSyncError: (error) ->
-    log '🔄 Обработка ошибки синхронизации:', error
+    log '🔄 Обработка ошибки синхронизации: ' + error
     
-    # Автоматический повтор при временных ошибках
     if error.status in [408, 429, 500, 502, 503, 504]
       log '⏳ Временная ошибка, повтор через 5 секунд...'
       setTimeout (=>
@@ -104,7 +187,6 @@ class PouchDBService
       ), 5000
     else if error.status == 401
       log '🔐 Ошибка аутентификации, требуется перелогин'
-      # Триггер события для приложения
       document.dispatchEvent(new CustomEvent('auth-required'))
 
   # Основные методы работы с данными
@@ -112,59 +194,233 @@ class PouchDBService
     @ensureInit()
     
     try
-      # Пробуем получить из локальной базы
-      doc = await @localDb.get(docId)
-      log '📄 Документ получен из локальной базы:', docId
-      return doc
-    catch localError
-      if localError.status == 404
-        try
-          # Получаем из удаленной базы и сохраняем локально
-          doc = await @remoteDb.get(docId)
-          await @localDb.put(doc)
-          log '📄 Документ получен из удаленной базы и сохранен локально:', docId
-          return doc
-        catch remoteError
-          log '❌ Документ не найден в удаленной базе:', docId
-          throw remoteError
+      if @useLocalDB and @localDb
+        doc = await @localDb.get(docId)
+        log '📄 Документ получен из локальной базы: ' + docId
+        return doc
       else
-        log '❌ Ошибка получения документа из локальной базы:', localError
-        throw localError
+        doc = await @remoteDb.get(docId)
+        log '📄 Документ получен из удаленной базы: ' + docId
+        return doc
+    catch error
+      log '❌ Ошибка получения документа: ' + error
+      throw error
 
   saveDocument: (doc) ->
     @ensureInit()
     
     try
-      # Сохраняем в локальную базу
-      result = await @localDb.put(doc)
-      log '💾 Документ сохранен локально:', doc._id
-      return result
+      if @useLocalDB and @localDb
+        result = await @localDb.put(doc)
+        log '💾 Документ сохранен локально: ' + doc._id
+        return result
+      else
+        result = await @remoteDb.put(doc)
+        log '💾 Документ сохранен в удаленной базе: ' + doc._id
+        return result
     catch error
-      log '❌ Ошибка сохранения документа:', error
+      log '❌ Ошибка сохранения документа: ' + error
       throw error
 
   bulkDocs: (docs) ->
     @ensureInit()
     
     try
-      result = await @localDb.bulkDocs(docs)
-      log '📦 Пакетное сохранение документов:', docs.length
-      return result
+      if @useLocalDB and @localDb
+        result = await @localDb.bulkDocs(docs)
+        log '📦 Пакетное сохранение документов в локальную базу: ' + docs.length
+        return result
+      else
+        result = await @remoteDb.bulkDocs(docs)
+        log '📦 Пакетное сохранение документов в удаленную базу: ' + docs.length
+        return result
     catch error
-      log '❌ Ошибка пакетного сохранения:', error
+      log '❌ Ошибка пакетного сохранения: ' + error
       throw error
 
   queryView: (designDoc, viewName, options = {}) ->
     @ensureInit()
     
     try
-      result = await @localDb.query("#{designDoc}/#{viewName}", options)
-      log '🔍 Выполнен запрос к view:', "#{designDoc}/#{viewName}"
-      return result
+      if @useLocalDB and @localDb
+        result = await @localDb.query(designDoc + '/' + viewName, options)
+        log '🔍 Выполнен запрос к локальной view: ' + designDoc + '/' + viewName
+        return result
+      else
+        result = await @remoteDb.query(designDoc + '/' + viewName, options)
+        log '🔍 Выполнен запрос к удаленной view: ' + designDoc + '/' + viewName
+        return result
     catch error
-      log '❌ Ошибка запроса к view:', error
+      log '❌ Ошибка запроса к view: ' + error
       throw error
 
+  allDocs: (options = {}) ->
+    @ensureInit()
+    
+    try
+      if @useLocalDB and @localDb
+        return await @localDb.allDocs(options)
+      else
+        return await @remoteDb.allDocs(options)
+    catch error
+      log '❌ Ошибка allDocs: ' + error
+      throw error
+
+  putAttachment: (docId, attachmentId, attachment, type) ->
+    @ensureInit()
+    
+    try
+      if @useLocalDB and @localDb
+        result = await @localDb.putAttachment(docId, attachmentId, attachment, type)
+        log '📎 Вложение добавлено в локальную базу: ' + docId + '/' + attachmentId
+        return result
+      else
+        result = await @remoteDb.putAttachment(docId, attachmentId, attachment, type)
+        log '📎 Вложение добавлено в удаленную базу: ' + docId + '/' + attachmentId
+        return result
+    catch error
+      log '❌ Ошибка добавления вложения: ' + error
+      throw error
+
+  getAttachment: (docId, attachmentId) ->
+    @ensureInit()
+    
+    try
+      if @useLocalDB and @localDb
+        attachment = await @localDb.getAttachment(docId, attachmentId)
+        log '📎 Вложение получено из локальной базы: ' + docId + '/' + attachmentId
+        return attachment
+      else
+        attachment = await @remoteDb.getAttachment(docId, attachmentId)
+        log '📎 Вложение получено из удаленной базы: ' + docId + '/' + attachmentId
+        return attachment
+    catch error
+      log '❌ Ошибка получения вложения: ' + error
+      throw error
+
+  removeDocument: (docId) ->
+    @ensureInit()
+    
+    try
+      # Сначала получаем документ чтобы получить _rev
+      doc = await @getDocument(docId)
+      
+      if @useLocalDB and @localDb
+        result = await @localDb.remove(doc)
+        log '🗑️ Документ удален из локальной базы: ' + docId
+        return result
+      else
+        result = await @remoteDb.remove(doc)
+        log '🗑️ Документ удален из удаленной базы: ' + docId
+        return result
+    catch error
+      log '❌ Ошибка удаления документа: ' + error
+      throw error
+
+  find: (selector, options = {}) ->
+    @ensureInit()
+    
+    try
+      if @useLocalDB and @localDb
+        result = await @localDb.find(selector, options)
+        log '🔍 Выполнен поиск в локальной базе: ' + JSON.stringify(selector)
+        return result
+      else
+        result = await @remoteDb.find(selector, options)
+        log '🔍 Выполнен поиск в удаленной базе: ' + JSON.stringify(selector)
+        return result
+    catch error
+      log '❌ Ошибка поиска: ' + error
+      throw error
+
+  # Получение статистики базы данных
+  getDatabaseInfo: ->
+    @ensureInit()
+    
+    try
+      if @useLocalDB and @localDb
+        info = await @localDb.info()
+        log '📊 Информация о локальной базе получена'
+        return info
+      else
+        info = await @remoteDb.info()
+        log '📊 Информация об удаленной базе получена'
+        return info
+    catch error
+      log '❌ Ошибка получения информации о базе: ' + error
+      throw error
+
+  # Очистка локальной базы (только для разработки)
+  clearLocalDatabase: ->
+    return unless @useLocalDB and @localDb
+    
+    try
+      await @localDb.destroy()
+      log '🗑️ Локальная база данных очищена'
+      
+      # Пересоздаем локальную базу
+      @localDb = new PouchDB(@localDbName or 'braer_color_cache')
+      log '✅ Локальная база данных пересоздана'
+      
+      return true
+    catch error
+      log '❌ Ошибка очистки локальной базы: ' + error
+      throw error
+
+  # Проверка подключения к удаленной базе
+  checkRemoteConnection: ->
+    @ensureInit()
+    
+    try
+      startTime = Date.now()
+      info = await @remoteDb.info()
+      endTime = Date.now()
+      responseTime = endTime - startTime
+      
+      log '🌐 Проверка подключения к удаленной базе: ' + responseTime + 'мс'
+      return {
+        connected: true
+        responseTime: responseTime
+        info: info
+      }
+    catch error
+      log '❌ Нет подключения к удаленной базе: ' + error
+      return {
+        connected: false
+        error: error.message
+      }
+
+  # Получение статуса синхронизации
+  getSyncStatus: ->
+    return {
+      initialized: @initialized
+      syncStatus: @syncStatus
+      useLocalDB: @useLocalDB
+      localDb: if @localDb then 'connected' else 'disconnected'
+      remoteDb: if @remoteDb then 'connected' else 'disconnected'
+    }
+
+  # Включение/выключение локальной базы
+  setLocalDBEnabled: (enabled) ->
+    if enabled != @useLocalDB
+      @useLocalDB = enabled
+      
+      if enabled and not @localDb
+        @localDb = new PouchDB(@localDbName or 'braer_color_cache')
+        log '✅ Локальная PouchDB включена и инициализирована'
+        
+        # Запускаем синхронизацию
+        if @remoteDb
+          @setupSync()
+      else if not enabled and @localDb
+        if @syncHandler
+          @syncHandler.cancel()
+        await @localDb.close()
+        @localDb = null
+        log '⚠️ Локальная PouchDB отключена'
+      
+      return true
+
   ensureInit: ->
     unless @initialized
       throw new Error('PouchDB сервис не инициализирован. Вызовите init() сначала.')
@@ -179,6 +435,7 @@ class PouchDBService
     @initialized = false
     log '🔚 PouchDB сервис остановлен'
 
+
 module.exports = new PouchDBService({
   localDbName: 'braer_color_cache',
   remoteDbUrl: 'https://oleg:631074@couchdb.favt.ru.net/braer_color_shop',