--

README.md

@@ -1,5 +1,5 @@
 # Текущая задача
-переработай design-documents.coffee с учётом изменений в структуре данных
+переработай seed-events.coffee с учётом изменений в структуре данных
 
 
 # файл с правилами

scripts/design-documents.coffee

@@ -1,438 +1,644 @@
-# Design документы для CouchDB с поддержкой иерархических категорий
-# Версия 5.0 - с иерархической структурой категорий
+# Design документы для CouchDB с поддержкой мультиязычных массивов и наследования
+# Версия 6.0 - унифицированная структура данных
 
 module.exports =
-    # Design документ для работы с иерархическими категориями
-    categories_hierarchical:
-        version: "5.0"
+    # Design документ для универсального поиска по мультиязычному контенту
+    universal_multilingual_search:
+        version: "6.0"
         views:
-            # Все категории по уровню иерархии
-            by_level:
+            # Универсальный поиск по всем типам контента с поддержкой массивов
+            content_search:
                 map: ((doc) ->
-                    if doc.type is 'category'
-                        domains = if Array.isArray(doc.domain) then doc.domain else [doc.domain or 'default']
-                        level = doc.level or 0
+                    # Пропускаем системные документы
+                    if doc._id.startsWith('_design/') or doc.type in ['domain_settings', 'user', 'order', 'setting', 'audit_log']
+                        return
+                    
+                    domains = if Array.isArray(doc.domain) then doc.domain else [doc.domain or 'default']
+                    languages = doc.language or ['ru']
+                    
+                    # Базовые поля для поиска
+                    searchFields = {}
+                    
+                    switch doc.type
+                        when 'blog_post', 'event', 'product', 'slide'
+                            if doc.status is 'published'
+                                searchFields =
+                                    titles: doc.title or []
+                                    contents: doc.content or []
+                                    excerpts: doc.excerpt or []
+                                    authors: doc.author or []
+                                    tags: doc.tags or []
+                                    type: doc.type
+                                    languages: languages
                         
+                        when 'category'
+                            searchFields =
+                                names: doc.name or []
+                                descriptions: doc.description or []
+                                type: 'category'
+                                languages: languages
+                    
+                    # Индексируем для каждого домена и языка
+                    if searchFields.titles
                         for domain in domains
-                            emit([domain, level, doc.order], {
-                                _id: doc._id
-                                name: doc.name
-                                slug: doc.slug
-                                parent_id: doc.parent_id
-                                level: level
-                                order: doc.order
-                                active: doc.active
-                                featured: doc.featured
-                                show_in_menu: doc.show_in_menu
-                            })
+                            for language, index in languages
+                                # Текст для поиска на конкретном языке
+                                searchText = (
+                                    (searchFields.titles[index] or '') + " " +
+                                    (searchFields.contents[index] or '') + " " +
+                                    (searchFields.excerpts[index] or '') + " " +
+                                    (searchFields.authors[index] or '') + " " +
+                                    (searchFields.names?[index] or '') + " " +
+                                    (searchFields.descriptions?[index] or '')
+                                ).toLowerCase()
+                                
+                                # Добавляем теги
+                                if searchFields.tags[index]
+                                    searchText += " " + searchFields.tags[index].join(" ")
+                                
+                                words = searchText.split(/\W+/).filter (word) -> word.length > 2
+                                
+                                for word in words
+                                    emit([domain, language, word], {
+                                        _id: doc._id
+                                        type: searchFields.type
+                                        title: searchFields.titles[index]
+                                        excerpt: searchFields.excerpts[index]
+                                        language: language
+                                        domain: domain
+                                        created_at: doc.created_at
+                                    })
                 ).toString()
-            
-            # Категории по родителю (для построения дерева)
-            by_parent:
+
+            # Поиск по конкретному типу контента
+            by_content_type:
                 map: ((doc) ->
-                    if doc.type is 'category'
+                    if doc.type in ['blog_post', 'event', 'product', 'slide'] and doc.status is 'published'
                         domains = if Array.isArray(doc.domain) then doc.domain else [doc.domain or 'default']
-                        parent_id = doc.parent_id or 'root'
+                        languages = doc.language or ['ru']
                         
                         for domain in domains
-                            emit([domain, parent_id, doc.order], {
-                                _id: doc._id
-                                name: doc.name
-                                slug: doc.slug
-                                level: doc.level
-                                children_count: doc.children_count
-                                order: doc.order
-                                active: doc.active
-                            })
+                            for language, index in languages
+                                emit([domain, doc.type, language, doc.created_at], {
+                                    _id: doc._id
+                                    title: doc.title?[index]
+                                    excerpt: doc.excerpt?[index]
+                                    image: doc.image?[index]
+                                    author: doc.author?[index]
+                                    language: language
+                                    featured: doc.featured or false
+                                })
                 ).toString()
-            
-            # Полное дерево категорий с путями
-            by_path:
+
+    # Design документ для работы с мультиязычными блог постами и наследниками
+    multilingual_content:
+        version: "6.0"
+        views:
+            # Все опубликованные документы контента по доменам и языкам
+            published_by_domain_language:
                 map: ((doc) ->
-                    if doc.type is 'category'
+                    if doc.type in ['blog_post', 'event', 'product', 'slide'] and doc.status is 'published'
                         domains = if Array.isArray(doc.domain) then doc.domain else [doc.domain or 'default']
-                        parent_path = doc.parent_path or []
+                        languages = doc.language or ['ru']
                         
                         for domain in domains
-                            # Эмитим каждый сегмент пути для быстрого поиска
-                            for path_segment, index in parent_path
-                                emit([domain, path_segment, doc.level, doc.order], doc)
-                            
-                            # Эмитим саму категорию
-                            emit([domain, doc._id, doc.level, doc.order], doc)
+                            for language, index in languages
+                                contentData = {
+                                    _id: doc._id
+                                    type: doc.type
+                                    title: doc.title?[index]
+                                    excerpt: doc.excerpt?[index]
+                                    image: doc.image?[index]
+                                    author: doc.author?[index]
+                                    created_at: doc.created_at
+                                    published_at: doc.published_at
+                                    featured: doc.featured or false
+                                    views: doc.views or 0
+                                    language: language
+                                    domain: domain
+                                }
+                                
+                                # Добавляем специфичные поля для наследников
+                                switch doc.type
+                                    when 'event'
+                                        contentData.event_date = doc.event_data?.event_date
+                                        contentData.location = doc.event_data?.location?[index]
+                                        contentData.price = doc.event_data?.price?[index]
+                                        contentData.status = doc.event_data?.status
+                                    
+                                    when 'product'
+                                        contentData.price = doc.product_data?.price?[index]
+                                        contentData.status = doc.product_data?.status
+                                        contentData.inventory = doc.product_data?.inventory
+                                    
+                                    when 'slide'
+                                        contentData.order = doc.slide_data?.order
+                                        contentData.active = doc.slide_data?.active
+                                
+                                emit([domain, language, doc.created_at], contentData)
                 ).toString()
-            
-            # Корневые категории
-            root_categories:
+
+            # Избранный контент с приоритетом
+            featured_content:
                 map: ((doc) ->
-                    if doc.type is 'category' and (not doc.parent_id or doc.parent_id is null)
+                    if doc.type in ['blog_post', 'event', 'product', 'slide'] and doc.status is 'published' and doc.featured is true
                         domains = if Array.isArray(doc.domain) then doc.domain else [doc.domain or 'default']
+                        languages = doc.language or ['ru']
                         
                         for domain in domains
-                            emit([domain, doc.order], {
-                                _id: doc._id
-                                name: doc.name
-                                slug: doc.slug
-                                level: 0
-                                children_count: doc.children_count
-                                order: doc.order
-                                active: doc.active
-                                featured: doc.featured
-                            })
+                            for language, index in languages
+                                emit([domain, language, doc.featured, doc.created_at], {
+                                    _id: doc._id
+                                    type: doc.type
+                                    title: doc.title?[index]
+                                    excerpt: doc.excerpt?[index]
+                                    image: doc.image?[index]
+                                    language: language
+                                })
                 ).toString()
-            
-            # Категории для меню
-            menu_categories:
+
+            # Контент по категориям с поддержкой иерархии
+            by_category_path:
                 map: ((doc) ->
-                    if doc.type is 'category' and doc.show_in_menu is true
+                    if doc.type in ['blog_post', 'event', 'product', 'slide'] and doc.status is 'published' and doc.category_path
                         domains = if Array.isArray(doc.domain) then doc.domain else [doc.domain or 'default']
-                        level = doc.level or 0
+                        languages = doc.language or ['ru']
                         
                         for domain in domains
-                            emit([domain, level, doc.menu_order or doc.order], {
-                                _id: doc._id
-                                name: doc.name
-                                slug: doc.slug
-                                parent_id: doc.parent_id
-                                level: level
-                                menu_order: doc.menu_order
-                                icon: doc.icon
-                                color: doc.color
-                            })
+                            for language, index in languages
+                                # Эмитим для каждой категории в пути
+                                for category_id in doc.category_path
+                                    emit([domain, language, category_id, doc.created_at], {
+                                        _id: doc._id
+                                        type: doc.type
+                                        title: doc.title?[index]
+                                        category_id: doc.category_id
+                                        language: language
+                                    })
                 ).toString()
 
-    # Design документ для контента с иерархическими категориями
-    content_with_hierarchical_categories:
-        version: "5.0"
+    # Design документ для событий (events) с мультиязычными данными
+    events_multilingual:
+        version: "6.0"
         views:
-            # Контент по полному пути категории
-            by_category_path:
+            # События по дате с мультиязычной информацией
+            by_date_multilingual:
                 map: ((doc) ->
-                    if (doc.type is 'blog_post' or doc.type is 'event') and doc.category_path
+                    if doc.type is 'event' and doc.status is 'published'
                         domains = if Array.isArray(doc.domain) then doc.domain else [doc.domain or 'default']
+                        languages = doc.language or ['ru']
+                        event_date = doc.event_data?.event_date
                         
-                        for domain in domains
-                            # Эмитим для каждого сегмента пути категории
-                            for category_id in doc.category_path
-                                emit([domain, category_id, doc.created_at], {
-                                    _id: doc._id
-                                    type: doc.type
-                                    title: doc.title
-                                    category_id: doc.category_id
-                                    category_path: doc.category_path
-                                    created_at: doc.created_at
-                                    status: doc.status
-                                    featured: doc.featured
-                                })
+                        if event_date
+                            for domain in domains
+                                for language, index in languages
+                                    emit([domain, language, event_date], {
+                                        _id: doc._id
+                                        title: doc.title?[index]
+                                        excerpt: doc.excerpt?[index]
+                                        location: doc.event_data?.location?[index]
+                                        price: doc.event_data?.price?[index]
+                                        available_tickets: doc.event_data?.available_tickets
+                                        status: doc.event_data?.status
+                                        image: doc.image?[index]
+                                        language: language
+                                    })
                 ).toString()
-            
-            # Контент по конечной категории (самой глубокой)
-            by_leaf_category:
+
+            # Предстоящие события
+            upcoming_events:
                 map: ((doc) ->
-                    if (doc.type is 'blog_post' or doc.type is 'event') and doc.category_path
+                    if doc.type is 'event' and doc.event_data?.status is 'upcoming'
                         domains = if Array.isArray(doc.domain) then doc.domain else [doc.domain or 'default']
-                        leaf_category = doc.category_path[doc.category_path.length - 1]
+                        languages = doc.language or ['ru']
+                        event_date = doc.event_data?.event_date
                         
-                        for domain in domains
-                            emit([domain, leaf_category, doc.created_at], {
-                                _id: doc._id
-                                type: doc.type
-                                title: doc.title
-                                category_id: doc.category_id
-                                created_at: doc.created_at
-                                status: doc.status
-                            })
+                        if event_date
+                            for domain in domains
+                                for language, index in languages
+                                    emit([domain, language, event_date], {
+                                        _id: doc._id
+                                        title: doc.title?[index]
+                                        location: doc.event_data?.location?[index]
+                                        price: doc.event_data?.price?[index]
+                                        available_tickets: doc.event_data?.available_tickets
+                                        image: doc.image?[index]
+                                        language: language
+                                    })
                 ).toString()
-            
-            # Контент по корневой категории
-            by_root_category:
+
+            # События по местоположению
+            by_location_multilingual:
                 map: ((doc) ->
-                    if (doc.type is 'blog_post' or doc.type is 'event') and doc.category_path
+                    if doc.type is 'event' and doc.status is 'published'
                         domains = if Array.isArray(doc.domain) then doc.domain else [doc.domain or 'default']
-                        root_category = doc.category_path[0]
+                        languages = doc.language or ['ru']
+                        locations = doc.event_data?.location or []
                         
                         for domain in domains
-                            emit([domain, root_category, doc.created_at], {
-                                _id: doc._id
-                                type: doc.type
-                                title: doc.title
-                                root_category: root_category
-                                created_at: doc.created_at
-                                status: doc.status
-                            })
+                            for language, index in languages
+                                location = locations[index]
+                                if location
+                                    emit([domain, language, location, doc.event_data?.event_date], {
+                                        _id: doc._id
+                                        title: doc.title?[index]
+                                        event_date: doc.event_data?.event_date
+                                        price: doc.event_data?.price?[index]
+                                        language: language
+                                    })
                 ).toString()
 
-    # Design документ для поиска с учетом иерархии категорий
-    search_with_category_hierarchy:
-        version: "5.0"
+    # Design документ для товаров (products) с мультиязычными данными
+    products_multilingual:
+        version: "6.0"
         views:
-            # Поиск по контенту с информацией о категории
-            content_with_category_info:
+            # Товары по статусу и доступности
+            by_status_multilingual:
                 map: ((doc) ->
-                    if (doc.type is 'blog_post' and doc.status is 'published') or doc.type is 'event'
+                    if doc.type is 'product' and doc.status is 'published'
                         domains = if Array.isArray(doc.domain) then doc.domain else [doc.domain or 'default']
-                        
-                        search_text = (doc.title + " " + (doc.content or "") + " " + (doc.excerpt or "")).toLowerCase()
-                        words = search_text.split(/\W+/).filter (word) -> word.length > 2
+                        languages = doc.language or ['ru']
+                        product_status = doc.product_data?.status
                         
                         for domain in domains
-                            for word in words
-                                emit([domain, word], {
+                            for language, index in languages
+                                emit([domain, language, product_status, doc.created_at], {
                                     _id: doc._id
-                                    type: doc.type
-                                    title: doc.title
-                                    excerpt: doc.excerpt
-                                    category_id: doc.category_id
-                                    category_path: doc.category_path
-                                    created_at: doc.created_at
-                                    domain: domain
+                                    title: doc.title?[index]
+                                    price: doc.product_data?.price?[index]
+                                    compare_price: doc.product_data?.compare_price?[index]
+                                    inventory: doc.product_data?.inventory
+                                    sku: doc.product_data?.sku
+                                    image: doc.image?[index]
+                                    language: language
                                 })
                 ).toString()
-            
-            # Поиск по категориям и тегам
-            by_category_and_tags:
+
+            # Товары по цене
+            by_price_range:
                 map: ((doc) ->
-                    if (doc.type is 'blog_post' and doc.status is 'published') or doc.type is 'event'
+                    if doc.type is 'product' and doc.status is 'published' and doc.product_data?.status is 'available'
                         domains = if Array.isArray(doc.domain) then doc.domain else [doc.domain or 'default']
+                        languages = doc.language or ['ru']
+                        prices = doc.product_data?.price or []
                         
                         for domain in domains
-                            # По категории
-                            if doc.category_id
-                                emit([domain, 'category', doc.category_id, doc.created_at], {
-                                    _id: doc._id
-                                    type: doc.type
-                                    title: doc.title
-                                })
-                            
-                            # По тегам
-                            if doc.tags
-                                for tag in doc.tags
-                                    emit([domain, 'tag', tag, doc.created_at], {
+                            for language, index in languages
+                                price = prices[index]
+                                if price
+                                    # Группируем по ценовым диапазонам
+                                    price_range = Math.floor(price / 100) * 100
+                                    emit([domain, language, price_range, doc.created_at], {
                                         _id: doc._id
-                                        type: doc.type
-                                        title: doc.title
+                                        title: doc.title?[index]
+                                        price: price
+                                        inventory: doc.product_data?.inventory
+                                        image: doc.image?[index]
+                                        language: language
                                     })
                 ).toString()
 
-    # Design документ для статистики иерархических категорий
-    category_statistics:
-        version: "5.0"
-        views:
-            # Статистика контента по категориям
-            content_count_by_category:
+            # Товары по тегам
+            by_tags_multilingual:
                 map: ((doc) ->
-                    if (doc.type is 'blog_post' or doc.type is 'event') and doc.category_id
+                    if doc.type is 'product' and doc.status is 'published'
                         domains = if Array.isArray(doc.domain) then doc.domain else [doc.domain or 'default']
+                        languages = doc.language or ['ru']
+                        tagsArrays = doc.tags or []
                         
                         for domain in domains
-                            # По конечной категории
-                            emit([domain, 'leaf_category', doc.category_id, doc.type], 1)
-                            
-                            # По всем категориям в пути
-                            if doc.category_path
-                                for category_id in doc.category_path
-                                    emit([domain, 'path_category', category_id, doc.type], 1)
-                ).toString()
-                reduce: ((keys, values) ->
-                    sum values
+                            for language, index in languages
+                                tags = tagsArrays[index] or []
+                                for tag in tags
+                                    emit([domain, language, tag, doc.created_at], {
+                                        _id: doc._id
+                                        title: doc.title?[index]
+                                        price: doc.product_data?.price?[index]
+                                        image: doc.image?[index]
+                                        language: language
+                                    })
                 ).toString()
-            
-            # Статистика популярности категорий
-            category_popularity:
+
+    # Design документ для слайдеров (slides) с мультиязычными данными
+    slides_multilingual:
+        version: "6.0"
+        views:
+            # Активные слайды по порядку
+            active_ordered_multilingual:
                 map: ((doc) ->
-                    if doc.type is 'blog_post'
+                    if doc.type is 'slide' and doc.slide_data?.active is true
                         domains = if Array.isArray(doc.domain) then doc.domain else [doc.domain or 'default']
-                        views = doc.views or 0
+                        languages = doc.language or ['ru']
+                        order = doc.slide_data?.order or 0
                         
                         for domain in domains
-                            if doc.category_id
-                                emit([domain, doc.category_id], views)
-                            
-                            if doc.category_path
-                                for category_id in doc.category_path
-                                    emit([domain, category_id], views)
-                    else if doc.type is 'event'
+                            for language, index in languages
+                                emit([domain, language, order], {
+                                    _id: doc._id
+                                    title: doc.title?[index]
+                                    content: doc.content?[index]
+                                    image: doc.image?[index]
+                                    button_text: doc.slide_data?.button_text?[index]
+                                    button_link: doc.slide_data?.button_link?[index]
+                                    language: language
+                                })
+                ).toString()
+
+            # Слайды по датам активности
+            by_active_dates:
+                map: ((doc) ->
+                    if doc.type is 'slide' and doc.slide_data?.active is true
                         domains = if Array.isArray(doc.domain) then doc.domain else [doc.domain or 'default']
-                        tickets_sold = (doc.total_tickets or 0) - (doc.available_tickets or 0)
+                        start_date = doc.slide_data?.start_date
+                        end_date = doc.slide_data?.end_date
                         
-                        for domain in domains
-                            if doc.category_id
-                                emit([domain, doc.category_id], tickets_sold)
-                ).toString()
-                reduce: ((keys, values) ->
-                    sum values
+                        if start_date and end_date
+                            for domain in domains
+                                emit([domain, start_date, end_date], {
+                                    _id: doc._id
+                                    title: doc.title?[0]  # Берем первый язык для ключа
+                                    order: doc.slide_data?.order
+                                })
                 ).toString()
 
-    # Design документ для навигации по иерархии
-    category_navigation:
-        version: "5.0"
+    # Design документ для иерархических категорий с мультиязычностью
+    categories_hierarchical_multilingual:
+        version: "6.0"
         views:
-            # Соседние категории (одного уровня)
-            siblings_categories:
+            # Категории по уровню иерархии
+            by_level_multilingual:
                 map: ((doc) ->
                     if doc.type is 'category'
                         domains = if Array.isArray(doc.domain) then doc.domain else [doc.domain or 'default']
-                        parent_id = doc.parent_id or 'root'
+                        languages = doc.language or ['ru']
+                        level = doc.level or 0
                         
                         for domain in domains
-                            emit([domain, parent_id, doc.order], {
-                                _id: doc._id
-                                name: doc.name
-                                slug: doc.slug
-                                order: doc.order
-                                level: doc.level
-                            })
+                            for language, index in languages
+                                emit([domain, language, level, doc.order], {
+                                    _id: doc._id
+                                    name: doc.name?[index]
+                                    slug: doc.slug?[index]
+                                    description: doc.description?[index]
+                                    parent_id: doc.parent_id
+                                    level: level
+                                    order: doc.order
+                                    active: doc.active
+                                    featured: doc.featured
+                                    show_in_menu: doc.show_in_menu
+                                    language: language
+                                })
                 ).toString()
-            
-            # Дочерние категории
-            children_categories:
+
+            # Категории по родителю для построения дерева
+            by_parent_multilingual:
                 map: ((doc) ->
                     if doc.type is 'category'
                         domains = if Array.isArray(doc.domain) then doc.domain else [doc.domain or 'default']
+                        languages = doc.language or ['ru']
+                        parent_id = doc.parent_id or 'root'
                         
                         for domain in domains
-                            emit([domain, doc._id, 'children'], {
-                                _id: doc._id
-                                name: doc.name
-                                children_count: doc.children_count
-                                has_children: doc.children_count > 0
-                            })
+                            for language, index in languages
+                                emit([domain, language, parent_id, doc.order], {
+                                    _id: doc._id
+                                    name: doc.name?[index]
+                                    slug: doc.slug?[index]
+                                    level: doc.level
+                                    children_count: doc.children_count
+                                    order: doc.order
+                                    active: doc.active
+                                    language: language
+                                })
                 ).toString()
-            
-            # Хлебные крошки для категорий
-            breadcrumbs:
+
+            # Корневые категории
+            root_categories_multilingual:
                 map: ((doc) ->
-                    if doc.type is 'category' and doc.parent_path
+                    if doc.type is 'category' and (not doc.parent_id or doc.parent_id is null)
                         domains = if Array.isArray(doc.domain) then doc.domain else [doc.domain or 'default']
+                        languages = doc.language or ['ru']
                         
                         for domain in domains
-                            # Эмитим для каждого родителя в пути
-                            for parent_id, index in doc.parent_path
-                                emit([domain, doc._id, 'parent', index], {
-                                    parent_id: parent_id
-                                    position: index
-                                    current_category: doc._id
+                            for language, index in languages
+                                emit([domain, language, doc.order], {
+                                    _id: doc._id
+                                    name: doc.name?[index]
+                                    slug: doc.slug?[index]
+                                    level: 0
+                                    children_count: doc.children_count
+                                    order: doc.order
+                                    active: doc.active
+                                    featured: doc.featured
+                                    language: language
                                 })
                 ).toString()
 
-    # Design документ для мультидоменного поиска (обновленный)
-    multi_domain_search:
-        version: "5.0"
+    # Design документ для статистики и аналитики мультиязычного контента
+    multilingual_statistics:
+        version: "6.0"
         views:
-            # Универсальный поиск с учетом иерархии категорий
-            universal_search_with_categories:
+            # Статистика по типам контента и языкам
+            content_stats_by_language:
                 map: ((doc) ->
-                    if doc._id.startsWith('_design/') or doc.type is 'domain_settings'
-                        return
-                    
-                    domain = doc.domain or 'default'
-                    domains = if Array.isArray(domain) then domain else [domain]
-                    language = doc.language or 'ru'
-                    
-                    searchFields = {}
-                    searchText = ""
-                    
-                    switch doc.type
-                        when 'blog_post'
-                            if doc.status is 'published'
-                                searchFields =
-                                    title: doc.title
-                                    content: doc.content
-                                    excerpt: doc.excerpt
-                                    author: doc.author
-                                    tags: doc.tags
-                                    category_path: doc.category_path
-                                    type: 'blog_post'
+                    if doc.type in ['blog_post', 'event', 'product', 'slide'] and doc.status is 'published'
+                        domains = if Array.isArray(doc.domain) then doc.domain else [doc.domain or 'default']
+                        languages = doc.language or ['ru']
                         
-                        when 'event'
-                            searchFields =
-                                title: doc.title
-                                content: doc.content
-                                location: doc.location
-                                tags: doc.tags
-                                category_path: doc.category_path
-                                type: 'event'
-                    
-                    if searchFields.title
-                        text = (
-                            searchFields.title + " " + 
-                            (searchFields.content or "") + " " +
-                            (searchFields.excerpt or "") + " " +
-                            (searchFields.author or "") + " " +
-                            (searchFields.location or "")
-                        ).toLowerCase()
+                        for domain in domains
+                            for language in languages
+                                # Статистика по типам
+                                emit([domain, 'type_count', doc.type, language], 1)
+                                
+                                # Статистика по датам
+                                if doc.created_at
+                                    date = doc.created_at.split('T')[0]
+                                    emit([domain, 'creation_date', date, language], 1)
+                                
+                                # Статистика просмотров
+                                if doc.views
+                                    emit([domain, 'views', doc.type, language], doc.views)
+                ).toString()
+                reduce: ((keys, values) ->
+                    sum values
+                ).toString()
+
+            # Статистика популярности контента
+            content_popularity_multilingual:
+                map: ((doc) ->
+                    if doc.type is 'blog_post'
+                        domains = if Array.isArray(doc.domain) then doc.domain else [doc.domain or 'default']
+                        languages = doc.language or ['ru']
+                        views = doc.views or 0
+                        likes = doc.likes or 0
+                        shares = doc.shares or 0
                         
-                        if searchFields.tags
-                            text += " " + searchFields.tags.join(" ")
+                        popularity = views + (likes * 2) + (shares * 3)
                         
-                        words = text.split(/\W+/).filter (word) -> word.length > 2
+                        for domain in domains
+                            for language in languages
+                                emit([domain, language, popularity], {
+                                    _id: doc._id
+                                    type: doc.type
+                                    title: doc.title?[0]  # Первый язык для ключа
+                                    views: views
+                                    likes: likes
+                                    shares: shares
+                                    popularity: popularity
+                                })
+                    
+                    else if doc.type is 'event'
+                        domains = if Array.isArray(doc.domain) then doc.domain else [doc.domain or 'default']
+                        languages = doc.language or ['ru']
+                        tickets_sold = (doc.event_data?.total_tickets or 0) - (doc.event_data?.available_tickets or 0)
                         
                         for domain in domains
-                            for word in words
-                                emit([domain, language, word], {
+                            for language in languages
+                                emit([domain, language, tickets_sold], {
                                     _id: doc._id
-                                    type: searchFields.type
-                                    title: searchFields.title
-                                    excerpt: searchFields.excerpt
-                                    category_path: searchFields.category_path
-                                    created_at: doc.created_at
-                                    domain: domain
-                                    language: language
+                                    type: doc.type
+                                    title: doc.title?[0]
+                                    tickets_sold: tickets_sold
+                                    total_tickets: doc.event_data?.total_tickets
                                 })
                 ).toString()
 
-    # Design документ для блог постов (обновленный)
-    blog_posts:
-        version: "5.0"
+    # Design документ для работы с заказами
+    orders_management:
+        version: "6.0"
         views:
-            # Блог посты с информацией о категориях
-            published_with_categories:
+            # Заказы по статусу и домену
+            by_status_and_domain:
                 map: ((doc) ->
-                    if doc.type is 'blog_post' and doc.status is 'published'
-                        domains = if Array.isArray(doc.domain) then doc.domain else [doc.domain or 'default']
-                        language = doc.language or 'ru'
+                    if doc.type is 'order'
+                        domain = doc.domain or 'default'
+                        languages = doc.language or ['ru']
                         
-                        for domain in domains
-                            emit([domain, language, doc.created_at], {
+                        for language in languages
+                            emit([domain, language, doc.status, doc.created_at], {
                                 _id: doc._id
-                                title: doc.title
-                                excerpt: doc.excerpt
-                                image: doc.image
-                                author: doc.author
-                                category_id: doc.category_id
-                                category_path: doc.category_path
+                                total: doc.total
+                                currency: doc.currency
+                                customer_name: doc.customer_info?.name?[0]  # Первый язык
                                 created_at: doc.created_at
-                                domain: domain
-                                language: language
-                                featured: doc.featured or false
-                                views: doc.views or 0
+                                items_count: doc.items?.length or 0
                             })
                 ).toString()
 
-    # Design документ для мероприятий (обновленный)
-    events:
-        version: "5.0"
-        views:
-            # Мероприятия с информацией о категориях
-            by_date_with_categories:
+            # Статистика продаж по доменам и языкам
+            sales_statistics_multilingual:
                 map: ((doc) ->
-                    if doc.type is 'event'
-                        domains = if Array.isArray(doc.domain) then doc.domain else [doc.domain or 'default']
-                        language = doc.language or 'ru'
+                    if doc.type is 'order' and doc.status is 'completed'
+                        domain = doc.domain or 'default'
+                        languages = doc.language or ['ru']
+                        date = doc.created_at.split('T')[0]
                         
+                        for language in languages
+                            # Общая сумма за день
+                            emit([domain, language, 'daily_sales', date], doc.total)
+                            
+                            # Количество заказов за день
+                            emit([domain, language, 'daily_orders', date], 1)
+                            
+                            # Статистика по товарам
+                            if doc.items
+                                for item in doc.items
+                                    emit([domain, language, 'product_sales', item.product_id], item.quantity)
+                                    emit([domain, language, 'product_revenue', item.product_id], item.total)
+                ).toString()
+                reduce: ((keys, values) ->
+                    sum values
+                ).toString()
+
+    # Design документ для пользователей и управления доступом
+    users_management:
+        version: "6.0"
+        views:
+            # Пользователи по email и роли
+            by_email_and_role:
+                map: ((doc) ->
+                    if doc.type is 'user'
+                        emit([doc.email, doc.role], {
+                            _id: doc._id
+                            name: doc.name?[0]  # Первый язык
+                            active: doc.active
+                            last_login: doc.last_login
+                            domains_access: doc.domains_access
+                        })
+                ).toString()
+
+            # Активные пользователи по доменам
+            active_users_by_domain:
+                map: ((doc) ->
+                    if doc.type is 'user' and doc.active is true
+                        domains = doc.domains_access or []
                         for domain in domains
-                            emit([domain, language, doc.event_date], {
+                            emit([domain, doc.role, doc.email], {
                                 _id: doc._id
-                                title: doc.title
-                                event_date: doc.event_date
-                                location: doc.location
-                                price: doc.price
-                                status: doc.status
-                                image: doc.image
-                                category_id: doc.category_id
-                                category_path: doc.category_path
-                                domain: domain
-                                language: language
-                                available_tickets: doc.available_tickets
+                                name: doc.name?[0]
+                                email: doc.email
+                                last_login: doc.last_login
                             })
                 ).toString()
+
+    # Design документ для системы уведомлений с мультиязычностью
+    multilingual_notifications:
+        version: "6.0"
+        views:
+            # Уведомления о предстоящих событиях
+            event_reminders_multilingual:
+                map: ((doc) ->
+                    if doc.type is 'event' and doc.event_data?.status is 'upcoming'
+                        domains = if Array.isArray(doc.domain) then doc.domain else [doc.domain or 'default']
+                        languages = doc.language or ['ru']
+                        event_date = new Date(doc.event_data.event_date)
+                        now = new Date()
+                        
+                        # Уведомление за 7 дней до события
+                        sevenDaysBefore = new Date(event_date.getTime() - 7 * 24 * 60 * 60 * 1000)
+                        if now >= sevenDaysBefore and now < event_date
+                            for domain in domains
+                                for language, index in languages
+                                    emit([domain, language, 'event_reminder_7d', doc.event_data.event_date], {
+                                        _id: doc._id
+                                        title: doc.title?[index]
+                                        event_date: doc.event_data.event_date
+                                        domain: domain
+                                        language: language
+                                        notification_type: 'event_reminder_7d'
+                                    })
+                        
+                        # Уведомление за 1 день до события
+                        oneDayBefore = new Date(event_date.getTime() - 24 * 60 * 60 * 1000)
+                        if now >= oneDayBefore and now < event_date
+                            for domain in domains
+                                for language, index in languages
+                                    emit([domain, language, 'event_reminder_1d', doc.event_data.event_date], {
+                                        _id: doc._id
+                                        title: doc.title?[index]
+                                        event_date: doc.event_data.event_date
+                                        domain: domain
+                                        language: language
+                                        notification_type: 'event_reminder_1d'
+                                    })
+                ).toString()
+
+            # Уведомления о низком количестве товаров
+            low_inventory_alerts:
+                map: ((doc) ->
+                    if doc.type is 'product' and doc.product_data?.inventory < 10
+                        domains = if Array.isArray(doc.domain) then doc.domain else [doc.domain or 'default']
+                        languages = doc.language or ['ru']
+                        
+                        for domain in domains
+                            for language, index in languages
+                                emit([domain, language, 'low_inventory', doc.product_data.inventory], {
+                                    _id: doc._id
+                                    title: doc.title?[index]
+                                    inventory: doc.product_data.inventory
+                                    sku: doc.product_data.sku
+                                    domain: domain
+                                    language: language
+                                    notification_type: 'low_inventory'
+                                })
+                ).toString()