@ozdao/martyrs 0.2.604 → 0.2.605

package/src/modules/community/components/sections/Comment.vue

@@ -23,7 +23,7 @@
         </button>
         <button 
           v-if="owner" 
-          class="font-second cursor-pointer t-transp fw-medium" 
+          class="font-second cursor-pointer opacity-50 fw-medium" 
           @click="showReplyForm = true"
         > 
           Reply

package/src/modules/constructor/components/elements/ImageUpload.vue

@@ -7,7 +7,7 @@
     @dragleave.prevent
     class="w-100 radius-big bg-white image-upload-area flex-v-center flex-h-center flex t-black mn-b-small">
       <img loading="lazy" v-if="prop.content" :src="(FILE_SERVER_URL || '') + prop.content" alt="Uploaded image" class="w-100 h-30r object-fit-contain"/>
-      <span v-else class="t-transp pd-extra" >Click or drag-and-drop your image</span>
+      <span v-else class="opacity-50 pd-extra" >Click or drag-and-drop your image</span>
       <input v-if="!prop.content" type="file" ref="fileInput" tabindex="-1" @change="onFileChange" style="display: none"/>
   </div>
 </template>

package/src/modules/core/TASK.MD

@@ -1,6 +1,6 @@
 Переиименовать все в менеджеры - storeMaganer, wsManager, moduleManager и сделать одинаковый экспорт и имена ws.manager.js, store.manager.js, module.manager.js, i18n.manager.js
-/Users/magicofoz/Development/OZDAO/ozdao.dev/app/martyrs/src/modules/core 
-/Users/magicofoz/Development/OZDAO/ozdao.dev/app/martyrs/src/modules/core/core.client.js
+/Users/magicofoz/Development/OZDAO/ozdao.com/app/martyrs/src/modules/core 
+/Users/magicofoz/Development/OZDAO/ozdao.com/app/martyrs/src/modules/core/core.client.js
 
 ну и в целом в store.js все сделать как это менеджер сторов названия
 

package/src/modules/core/controllers/classes/abac/abac.core.js

@@ -27,6 +27,7 @@ export default class ABACCore {
     if (input.req) {
       // Express context - НЕ смешиваем body и query!
       context.user = input.user || input.req.userId;
+      context.isServiceRequest = input.isServiceRequest || input.req.isServiceRequest || false;
       context.data = {
         body: input.req.body || {},
         query: input.req.query || {},

package/src/modules/core/controllers/classes/core.websocket.js

@@ -125,11 +125,9 @@ class WebSocketManager {
             // Обработка подписки и отписки на модуль
             if (msg.type === 'subscribe' && msg.module && this.modules.has(msg.module)) {
               ws.subscriptions.add(msg.module);
-              console.log(`[WebSocket Server] Client ${ws.userId || 'anonymous'} subscribed to module: ${msg.module}`);
               return;
             } else if (msg.type === 'unsubscribe' && msg.module) {
               ws.subscriptions.delete(msg.module);
-              console.log(`[WebSocket Server] Client ${ws.userId || 'anonymous'} unsubscribed from module: ${msg.module}`);
               return;
             }
             // Обработка RPC вызова

package/src/modules/core/controllers/classes/crud/crud.core.js

@@ -22,6 +22,9 @@ class CRUDCore {
       delete: true    // Требует авторизацию
     };
     
+    // Конфигурация из CRUD конструктора
+    this.config = {};
+
     // Опции
     this.options = {
       enableEvents: true,
@@ -77,6 +80,9 @@ class CRUDCore {
       }
     }
     
+    // Сохраняем конфигурацию
+    if (options.searchFields) this.config.searchFields = options.searchFields;
+
     // Инициализация из опций
     if (options.verifiers) this.initVerifiers(options.verifiers);
     if (options.hooks) this.initHooks(options.hooks);

package/src/modules/core/controllers/classes/crud/crud.service.js

@@ -206,6 +206,12 @@ export default class CRUDService {
     stages.push(...coreQuery.getBasicOptions(query));
     stages.push(...coreQuery.getFilterDate(query.dateStart, query.dateEnd));
 
+    // Поиск по тексту
+    if (query.search) {
+      const searchFields = this.crud.core.config?.searchFields || ['name'];
+      stages.push(...coreQuery.getSearchOptions(query.search, { fields: searchFields }));
+    }
+
     // Middle extension
     if (extensions.middle) {
       stages.push(...await extensions.middle(query, context));

package/src/modules/core/controllers/utils/mailing.js

@@ -60,35 +60,44 @@ async function sendSms(phone, message) {
     return false;
   }
 }
-async function sendChatMessageTelegram(chatIds, text) {
+async function sendChatMessageTelegram(chatIds, text, options = {}, retries = 3) {
   const telegramToken = process.env.TELEGRAM_BOT_TOKEN; // Токен Telegram Bot хранится в переменных окружения
   const telegramUrl = `https://api.telegram.org/bot${telegramToken}/sendMessage`;
+
+  const sendWithRetry = async (chatId) => {
+    const payload = {
+      chat_id: chatId,
+      text: text,
+    };
+    if (options.parse_mode) payload.parse_mode = options.parse_mode;
+    if (options.disable_web_page_preview) payload.disable_web_page_preview = true;
+    if (options.reply_markup) payload.reply_markup = options.reply_markup;
+
+    for (let attempt = 1; attempt <= retries; attempt++) {
+      try {
+        const res = await axios.post(telegramUrl, payload);
+        return { chatId, success: true, data: res.data };
+      } catch (error) {
+        const status = error.response?.status;
+        const desc = error.response?.data?.description || error.message;
+        console.log(`[Telegram] Attempt ${attempt}/${retries} failed for chat ${chatId}: ${status} ${desc}`);
+        // 400 — невалидный запрос (плохой HTML и т.д.), ретраить бесполезно
+        if (status === 400 || status === 403 || status === 404) break;
+        // Ждём перед следующей попыткой (1s, 2s, ...)
+        if (attempt < retries) await new Promise(r => setTimeout(r, attempt * 1000));
+      }
+    }
+    return { chatId, success: false };
+  };
+
   // Используем Promise.all для параллельной отправки сообщений
-  const sendPromises = chatIds.map(chatId => {
-    return axios
-      .post(telegramUrl, {
-        chat_id: chatId,
-        text: text,
-        // reply_markup: inlineKeyboard
-      })
-      .catch(error => {
-        // Логируем ошибку для конкретного чата, но не прерываем процесс
-        console.log(`Failed to send message to chat ${chatId}:`, error.message);
-        // Возвращаем false или null, чтобы Promise.all мог продолжить
-        return false;
-      });
-  });
-  try {
-    // Ждем завершения всех промисов, но ошибки не прерывают выполнение
-    const results = await Promise.all(sendPromises);
-    console.log('Telegram messages processing completed');
-    // Возвращаем true, даже если некоторые сообщения не были отправлены
-    return true;
-  } catch (error) {
-    // Логируем общую ошибку, но не прерываем выполнение
-    console.log('Error in sending Telegram messages:', error.message);
-    return false;
-  }
+  const results = await Promise.all(chatIds.map(sendWithRetry));
+  const failed = results.filter(r => !r.success);
+  const succeeded = results.filter(r => r.success);
+  console.log(`[Telegram] Sent: ${succeeded.length}/${results.length}`);
+  if (failed.length) console.log(`[Telegram] Failed chats: ${failed.map(r => r.chatId).join(', ')}`);
+  // Возвращаем true только если хотя бы одно сообщение отправлено
+  return succeeded.length > 0;
 }
 export { sendChatMessageTelegram, sendEmail, sendSms };
 export default {

package/src/modules/core/controllers/utils/queryProcessor.js

@@ -196,13 +196,15 @@ function getCreatorCustomerLookupStage() {
       pipeline: [
         {
           $match: {
-            $expr: { $eq: ['_id', '$$creatorId'] },
+            $expr: { $eq: ['$_id', '$$creatorId'] },
           },
         },
         {
           $project: {
-            username: 1, // если есть, можно заменить на нужные поля у customer
+            username: 1,
             profile: 1,
+            phone: 1,
+            email: 1,
             _id: 1,
           },
         },

package/src/modules/core/core.client.js

@@ -112,6 +112,7 @@ const ModuleCore = {
 export { default as layoutApp } from './views/components/layouts/App.vue';
 export { default as layoutClient } from './views/components/layouts/Client.vue';
 export { default as BlockSearch } from '@martyrs/src/modules/core/views/components/blocks/BlockSearch.vue';
+export { default as BlockSlider } from '@martyrs/src/modules/core/views/components/blocks/BlockSlider.vue';
 export { default as BottomNavigationBar } from '@martyrs/src/modules/core/views/components/partials/BottomNavigationBar.vue';
 export { default as Header } from '@martyrs/src/modules/core/views/components/partials/Header.vue';
 export { default as Navigation } from '@martyrs/src/modules/core/views/components/partials/Navigation.vue';

package/src/modules/core/models/schemas/embedding.schema.js

@@ -0,0 +1,8 @@
+export default (function applyEmbeddingSchema(schema, db) {
+  schema.add({
+    embedding: {
+      type: [Number],
+      default: undefined,
+    },
+  });
+});

package/src/modules/core/models/schemas/socials.schema.js

@@ -17,6 +17,10 @@ export default (function applySocialsSchema(schema, db) {
         type: String,
         default: '',
       },
+      whatsapp: {
+        type: String,
+        default: '',
+      },
     },
   });
 });

package/src/modules/core/sw.js

@@ -0,0 +1,448 @@
+// Service Worker Template — @ozdao/martyrs core module
+// Версии и имена инжектятся при билде через DefinePlugin
+const SW_VERSION = __SW_VERSION__;
+const CACHE_PREFIX = __CACHE_PREFIX__;
+const CACHE_NAME = `${CACHE_PREFIX}-v${SW_VERSION}`;
+const STATIC_CACHE = `${CACHE_PREFIX}-static-v${SW_VERSION}`;
+const RUNTIME_CACHE = `${CACHE_PREFIX}-runtime-v${SW_VERSION}`;
+
+// Определяем режим работы
+const isDev = self.location.hostname === 'localhost' ||
+               self.location.hostname === '127.0.0.1' ||
+               self.location.hostname.includes('.local');
+
+// Стратегии кеширования для разных типов файлов
+const CACHE_STRATEGIES = {
+  // Изображения, шрифты - кешируем надолго (30 дней)
+  static: {
+    pattern: /\.(png|jpg|jpeg|gif|webp|svg|ico|woff|woff2|ttf|eot|otf)$/i,
+    cacheName: STATIC_CACHE,
+    maxAge: 30 * 24 * 60 * 60 // 30 дней
+  },
+  // CSS - кешируем на средний срок (7 дней)
+  styles: {
+    pattern: /\.(css)$/i,
+    cacheName: STATIC_CACHE,
+    maxAge: 7 * 24 * 60 * 60 // 7 дней
+  },
+  // JS файлы с хешами - кешируем надолго
+  hashedJs: {
+    pattern: /\.[a-f0-9]{8,}\.(js|mjs)$/i,
+    cacheName: STATIC_CACHE,
+    maxAge: 365 * 24 * 60 * 60 // 1 год
+  },
+  // JS файлы без хешей - кешируем кратко
+  plainJs: {
+    pattern: /^(?!.*\.[a-f0-9]{8,}\.).*\.(js|mjs)$/i,
+    cacheName: RUNTIME_CACHE,
+    maxAge: 2 * 60 * 60 // 2 часа
+  },
+  // API запросы - не кешируем
+  api: {
+    pattern: /\/api\//,
+    strategy: 'network-only'
+  }
+};
+
+// Push уведомления работают всегда
+self.addEventListener('push', (event) => {
+  console.log('web push is', event);
+
+  let data;
+  try {
+    data = event.data.json();
+    console.log('data push is', data);
+  } catch (e) {
+    console.error('Failed to parse push data:', e);
+    data = {
+      title: 'Новое уведомление',
+      body: 'Получено новое уведомление'
+    };
+  }
+
+  const title = data?.title || 'Новое уведомление';
+  const options = {
+    body: data.body,
+    icon: data.icon || '/favicon.ico',
+    badge: data.badge || '/favicon.ico',
+    data: data.data || {}
+  };
+
+  event.waitUntil(
+    self.registration.showNotification(title, options)
+      .then(() => console.log('Уведомление успешно показано'))
+      .catch(err => console.error('Ошибка в showNotification:', err))
+  );
+});
+
+self.addEventListener('notificationclick', (event) => {
+  event.notification.close();
+
+  const data = event.notification.data || {};
+  const type = data.type;
+  const context = data.context || 'organization';
+  console.log('not data', data);
+
+  let targetUrl = '/';
+
+  // Роутинг по типам уведомлений
+  switch(type) {
+    case 'order_created':
+    case 'order_status':
+      targetUrl = buildOrderUrl(data.orderId, 'backoffice', data.organization);
+      break;
+    // Добавить другие типы уведомлений здесь
+    default:
+      targetUrl = '/';
+  }
+
+  event.waitUntil(openOrFocusWindow(targetUrl));
+});
+
+// Handle subscription rotation (Apple may change endpoint at any time)
+self.addEventListener('pushsubscriptionchange', (event) => {
+  console.log('[SW] pushsubscriptionchange event fired');
+  event.waitUntil(
+    (async () => {
+      try {
+        const newSubscription = await self.registration.pushManager.subscribe({
+          userVisibleOnly: true,
+          applicationServerKey: __VAPID_PUBLIC_KEY__,
+        });
+        // Notify server about new subscription
+        await fetch('/api/notifications/devices/update-subscription', {
+          method: 'POST',
+          headers: { 'Content-Type': 'application/json' },
+          body: JSON.stringify({
+            oldEndpoint: event.oldSubscription?.endpoint,
+            newSubscription: newSubscription.toJSON(),
+          }),
+        });
+        console.log('[SW] Subscription rotated and synced with server');
+      } catch (err) {
+        console.error('[SW] Failed to handle subscription change:', err);
+      }
+    })()
+  );
+});
+
+// Построение URL для заказов в зависимости от контекста
+function buildOrderUrl(orderId, context, organizationId) {
+  const routes = {
+    'root': `/orders/${orderId}`,
+    'backoffice': `/backoffice/orders/${orderId}`,
+    'user': `/user/orders/${orderId}`,
+    'organization': `/organizations/${organizationId}/orders/${orderId}`
+  };
+  return routes[context] || routes['organization'];
+}
+
+// Открытие или фокусировка окна
+function openOrFocusWindow(url) {
+  return clients.matchAll({
+    type: 'window',
+    includeUncontrolled: true
+  }).then(windowClients => {
+    // Поиск существующего окна с этим URL
+    for (let client of windowClients) {
+      if (client.url.includes(url.split('?')[0]) && 'focus' in client) {
+        return client.focus();
+      }
+    }
+    // Открыть новое окно
+    return clients.openWindow(url);
+  });
+}
+
+// Функция для добавления заголовков кеширования
+function addCacheHeaders(response, maxAge) {
+  const headers = new Headers(response.headers);
+  headers.set('Cache-Control', `public, max-age=${maxAge}`);
+  headers.set('X-SW-Cache', 'true');
+  headers.set('X-SW-Version', SW_VERSION);
+
+  return new Response(response.body, {
+    status: response.status,
+    statusText: response.statusText,
+    headers: headers
+  });
+}
+
+// В dev режиме минимальная функциональность
+if (isDev) {
+  // Install - сразу активируем
+  self.addEventListener('install', (event) => {
+    console.log('[DEV] SW installing...');
+    self.skipWaiting();
+  });
+
+  // Activate - берём контроль
+  self.addEventListener('activate', (event) => {
+    console.log('[DEV] SW activated');
+    event.waitUntil(
+      self.clients.claim()
+    );
+  });
+
+  // Fetch - НЕ перехватываем запросы в dev режиме
+  // Service Worker будет работать только для push уведомлений
+
+} else {
+  // PRODUCTION режим - полная функциональность
+
+  // Workbox инжектит манифест прекэшированных файлов
+  const precacheManifest = self.__WB_MANIFEST || [];
+
+  // Install - прекэшируем файлы
+  self.addEventListener('install', (event) => {
+    console.log('SW installing... Version:', SW_VERSION);
+    event.waitUntil(
+      caches.open(CACHE_NAME).then((cache) => {
+        // Прекэшируем только критические файлы
+        const criticalFiles = [
+          '/',
+          '/manifest.json',
+          '/favicon.ico'
+        ];
+
+        // Добавляем файлы из манифеста если они есть
+        const filesToCache = precacheManifest.length > 0
+          ? precacheManifest.map(entry => typeof entry === 'string' ? entry : entry.url)
+          : criticalFiles;
+
+        // Кешируем поштучно — пропускаем недоступные файлы
+        return Promise.allSettled(
+          filesToCache.map(url => cache.add(url).catch(err => console.warn('Precache skip:', url, err.message)))
+        );
+      }).then(() => {
+        console.log('Precached files, version:', SW_VERSION);
+        // ВАЖНО: skipWaiting заставляет новый SW сразу активироваться
+        self.skipWaiting();
+      })
+    );
+  });
+
+  // Activate - очищаем старые кэши
+  self.addEventListener('activate', (event) => {
+    console.log('SW activated, version:', SW_VERSION);
+    event.waitUntil(
+      caches.keys().then((cacheNames) => {
+        return Promise.all(
+          cacheNames.map((cacheName) => {
+            // Удаляем все кеши которые не относятся к текущей версии
+            if (cacheName.startsWith(CACHE_PREFIX) &&
+                cacheName !== CACHE_NAME &&
+                cacheName !== STATIC_CACHE &&
+                cacheName !== RUNTIME_CACHE) {
+              console.log('Deleting old cache:', cacheName);
+              return caches.delete(cacheName);
+            }
+          })
+        );
+      }).then(() => {
+        // Обновляем все открытые вкладки
+        return self.clients.matchAll({ type: 'window' }).then(clients => {
+          clients.forEach(client => {
+            // Отправляем сообщение о необходимости обновления
+            client.postMessage({
+              type: 'SW_UPDATE',
+              version: SW_VERSION
+            });
+          });
+        });
+      }).then(() => {
+        // Берём контроль над всеми клиентами
+        return self.clients.claim();
+      })
+    );
+  });
+
+  // Fetch - умное кэширование
+  self.addEventListener('fetch', (event) => {
+    const { request } = event;
+    const url = new URL(request.url);
+
+    // Пропускаем не-GET запросы
+    if (request.method !== 'GET') return;
+
+    // Пропускаем WebSocket и SSE
+    if (url.protocol === 'ws:' || url.protocol === 'wss:') return;
+    if (url.pathname === '/api/ws') return;
+
+    // HTML страницы - Network First с fallback
+    if (request.mode === 'navigate' || request.headers.get('accept')?.includes('text/html')) {
+      event.respondWith(
+        fetch(request)
+          .then(response => {
+            // Клонируем ответ для кеша
+            const responseToCache = response.clone();
+
+            // Кешируем HTML только если статус 200
+            if (response.status === 200) {
+              caches.open(RUNTIME_CACHE).then(cache => {
+                cache.put(request, responseToCache);
+              });
+            }
+
+            return response;
+          })
+          .catch(() => {
+            // Пробуем взять из кеша
+            return caches.match(request).then(cachedResponse => {
+              if (cachedResponse) {
+                return cachedResponse;
+              }
+
+              // Если нет в кеше - показываем offline страницу
+              return new Response(`
+                <!DOCTYPE html>
+                <html>
+                  <head>
+                    <meta charset="UTF-8">
+                    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+                    <title>Offline - ${__APP_NAME__}</title>
+                    <style>
+                      body {
+                        font-family: -apple-system, BlinkMacSystemFont, sans-serif;
+                        display: flex; align-items: center; justify-content: center;
+                        height: 100vh; margin: 0; background: #f5f5f5;
+                      }
+                      .offline { text-align: center; padding: 2rem; }
+                      h1 { color: #333; margin-bottom: 1rem; }
+                      p { color: #666; }
+                      button {
+                        margin-top: 1rem;
+                        padding: 0.5rem 1rem;
+                        background: #007AFF;
+                        color: white;
+                        border: none;
+                        border-radius: 4px;
+                        cursor: pointer;
+                      }
+                    </style>
+                  </head>
+                  <body>
+                    <div class="offline">
+                      <h1>You are offline</h1>
+                      <p>Check your internet connection and try again.</p>
+                      <button onclick="location.reload()">Retry</button>
+                    </div>
+                  </body>
+                </html>
+              `, {
+                status: 200,
+                headers: { 'Content-Type': 'text/html; charset=utf-8' }
+              });
+            });
+          })
+      );
+      return;
+    }
+
+    // Определяем стратегию кеширования
+    let cacheStrategy = null;
+    let maxAge = 3600; // По умолчанию 1 час
+
+    // JS файлы
+    if (/\.(js|mjs)$/i.test(url.pathname)) {
+      // Проверяем, есть ли хеш в имени файла
+      if (/\.[a-f0-9]{8,}\.(js|mjs)$/i.test(url.pathname)) {
+        // Файлы с хешами - кешируем надолго
+        cacheStrategy = CACHE_STRATEGIES.hashedJs;
+        maxAge = cacheStrategy.maxAge;
+      } else {
+        // Файлы без хешей - кешируем кратко
+        cacheStrategy = CACHE_STRATEGIES.plainJs;
+        maxAge = cacheStrategy.maxAge;
+      }
+    }
+    // CSS файлы
+    else if (CACHE_STRATEGIES.styles.pattern.test(url.pathname)) {
+      cacheStrategy = CACHE_STRATEGIES.styles;
+      maxAge = cacheStrategy.maxAge;
+    }
+    // Статические ресурсы
+    else if (CACHE_STRATEGIES.static.pattern.test(url.pathname)) {
+      cacheStrategy = CACHE_STRATEGIES.static;
+      maxAge = cacheStrategy.maxAge;
+    }
+    // API запросы
+    else if (CACHE_STRATEGIES.api.pattern.test(url.pathname)) {
+      // API запросы всегда идут в сеть
+      return;
+    }
+
+    // Внешние ресурсы (YouTube, CDN)
+    if (url.hostname !== self.location.hostname) {
+      // YouTube превью - кешируем на 7 дней
+      if (url.hostname.includes('ytimg.com') || url.hostname.includes('youtube.com')) {
+        maxAge = 7 * 24 * 60 * 60;
+        cacheStrategy = { cacheName: STATIC_CACHE };
+      }
+      // Google Fonts - кешируем на 365 дней
+      else if (url.hostname.includes('fonts.googleapis.com') || url.hostname.includes('fonts.gstatic.com')) {
+        maxAge = 365 * 24 * 60 * 60;
+        cacheStrategy = { cacheName: STATIC_CACHE };
+      }
+    }
+
+    // Применяем стратегию Cache First для статики
+    if (cacheStrategy) {
+      event.respondWith(
+        caches.open(cacheStrategy.cacheName).then((cache) => {
+          return cache.match(request).then((cachedResponse) => {
+            if (cachedResponse) {
+              // Проверяем свежесть кеша
+              const cachedDate = cachedResponse.headers.get('date');
+              if (cachedDate) {
+                const age = (Date.now() - new Date(cachedDate).getTime()) / 1000;
+                if (age < maxAge) {
+                  // Кеш еще свежий
+                  return cachedResponse;
+                }
+              }
+            }
+
+            // Запрашиваем из сети
+            return fetch(request).then((fetchResponse) => {
+              // Кешируем только успешные ответы
+              if (fetchResponse.status === 200) {
+                const responseWithHeaders = addCacheHeaders(fetchResponse.clone(), maxAge);
+                cache.put(request, responseWithHeaders.clone());
+                return responseWithHeaders;
+              }
+              return fetchResponse;
+            }).catch(() => {
+              // Если сеть недоступна и есть кеш - возвращаем его
+              if (cachedResponse) {
+                return cachedResponse;
+              }
+              throw new Error('Network error');
+            });
+          });
+        })
+      );
+      return;
+    }
+
+    // Для всех остальных запросов - Network First
+    event.respondWith(
+      fetch(request).catch(() => {
+        return caches.match(request).then(cached => {
+          return cached || new Response('', { status: 503, statusText: 'Offline' });
+        });
+      })
+    );
+  });
+
+  // Слушаем сообщения от клиентов
+  self.addEventListener('message', (event) => {
+    if (event.data && event.data.type === 'SKIP_WAITING') {
+      self.skipWaiting();
+    }
+
+    if (event.data && event.data.type === 'GET_VERSION') {
+      event.ports[0].postMessage({ version: SW_VERSION });
+    }
+  });
+}