@ozdao/martyrs 0.2.604 → 0.2.605

package/src/modules/music/components/player/TrackProgress.vue

@@ -1,7 +1,7 @@
 <!-- components/player/TrackProgress.vue -->
 <template>
   <div class="progress-section">
-    <span class="time-current t-transp">{{ formatTime(currentTime) }}</span>
+    <span class="time-current opacity-50">{{ formatTime(currentTime) }}</span>
     <div 
       ref="progressBarContainer"
       class="progress-bar"

package/src/modules/notifications/components/sections/NotificationPreferences.vue

@@ -1,35 +1,37 @@
 <template>
   <div>
-    <!-- Push Permission Toggle -->
+    <!-- Push Permission Banner -->
     <div class="bg-light radius-small pd-small mn-b-small">
       <div class="flex flex-v-center flex-between">
-        <div class="flex flex-v-center gap-small">
+        <div class="w-100 flex flex-v-center gap-small">
           <div class="h4">🔔</div>
           <div class="flex-column flex gap-micro">
-            <p class="fw-medium">Push Notifications</p>
+            <p class="fw-medium">Push on This Device</p>
             <p class="p-small" :class="pushStatusClass">{{ pushStatusText }}</p>
           </div>
         </div>
         <Checkbox
           mode="switch"
           :radio="pushEnabled"
-          :disabled="pushPermission === 'denied'"
+          :disabled="!pushSupported"
           @update:radio="togglePush"
           class="flex-shrink-0"
         />
       </div>
     </div>
 
-    <template v-if="pushEnabled && pushPermission === 'granted'">
-      <p class="t-transp mn-b-small">Choose how you want to receive notifications</p>
+    <!-- Channel preferences — always visible -->
+    <p class="opacity-50 mn-b-small">Choose how you want to receive notifications</p>
 
-      <div v-if="loading" class="pd-large t-center t-transp">
-        <Loader />
-      </div>
+    <div v-if="loading" class="pd-large t-center opacity-50">
+      <Loader />
+    </div>
 
-      <div v-else class="gap-thin flex-column flex">
+    <div v-else class="flex-column flex gap-small">
+      <!-- Standard channels -->
+      <div class="gap-thin flex-column flex">
         <div
-          v-for="(enabled, channelType) in preferences"
+          v-for="channelType in standardChannels"
           :key="channelType"
           class="flex flex-v-center flex-between bg-light radius-small pd-small"
         >
@@ -37,42 +39,86 @@
             <div class="h4">{{ getChannelIcon(channelType) }}</div>
             <div class="flex-column flex gap-micro">
               <p class="fw-medium">{{ getChannelName(channelType) }}</p>
-              <p class="p-small t-transp">{{ getChannelDescription(channelType) }}</p>
+              <p class="p-small opacity-50">{{ getChannelDescription(channelType) }}</p>
             </div>
           </div>
           <Checkbox
             mode="switch"
-            :radio="enabled"
+            :radio="preferences[channelType]"
             @update:radio="updatePreference(channelType, $event)"
             class="flex-shrink-0"
           />
         </div>
+      </div>
 
-        <div class="flex flex-end gap-small mn-t-thin">
-          <Button
-            v-if="hasChanges"
-            :submit="resetChanges"
-            :showLoader="false"
-            :showSucces="false"
-            class="bg-white t-dark"
-          >
-            Cancel
-          </Button>
-          <Button
-            :submit="savePreferences"
-            :validation="!hasChanges || saving"
-            class="bg-main t-white"
-          >
-            {{ saving ? 'Saving...' : 'Save Changes' }}
-          </Button>
+      <!-- Messengers -->
+      <div>
+        <p class="fw-medium opacity-50 mn-b-thin">Messengers</p>
+        <div class="gap-thin flex-column flex">
+          <!-- Telegram -->
+          <div class="flex flex-v-center flex-between bg-light radius-small pd-small">
+            <div class="flex w-100 flex-v-center gap-small mn-r-small">
+              <div class="h4">📬</div>
+              <div class="flex-column flex gap-micro">
+                <p class="fw-medium">Telegram</p>
+                <p class="p-small opacity-50">Receive notifications via Telegram bot</p>
+              </div>
+            </div>
+            <div class="flex flex-v-center gap-small flex-shrink-0">
+              <template v-if="telegramConnected">
+                <Button
+                  :submit="handleDisconnectTelegram"
+                  class="bg-white t-dark pd-thin pd-h-small p-small"
+                >Disconnect</Button>
+              </template>
+              <template v-else>
+                <Button
+                  :submit="handleConnectTelegram"
+                  :loading="telegramLinking"
+                  class="bg-main t-white pd-thin pd-h-small p-small"
+                >Connect</Button>
+              </template>
+            </div>
+          </div>
+
+          <!-- WhatsApp -->
+          <div class="flex flex-v-center flex-between bg-light radius-small pd-small opacity-50">
+            <div class="flex w-100 flex-v-center gap-small mn-r-small">
+              <div class="h4">💬</div>
+              <div class="flex-column flex gap-micro">
+                <p class="fw-medium">WhatsApp</p>
+                <p class="p-small opacity-50">Coming soon</p>
+              </div>
+            </div>
+          </div>
         </div>
       </div>
-    </template>
+
+      <!-- Save / Cancel -->
+      <div class="flex flex-end gap-small mn-t-thin">
+        <Button
+          v-if="hasChanges"
+          :submit="resetChanges"
+          :showLoader="false"
+          :showSucces="false"
+          class="bg-white t-dark"
+        >
+          Cancel
+        </Button>
+        <Button
+          :submit="savePreferences"
+          :validation="!hasChanges || saving"
+          class="bg-main t-white w-100"
+        >
+          {{ saving ? 'Saving...' : 'Save Changes' }}
+        </Button>
+      </div>
+    </div>
   </div>
 </template>
 
 <script setup>
-import { ref, reactive, computed, onMounted, inject } from 'vue';
+import { ref, reactive, computed, onMounted, inject, watch } from 'vue';
 import Checkbox from '@martyrs/src/components/Checkbox/Checkbox.vue';
 import Button from '@martyrs/src/components/Button/Button.vue';
 import Loader from '@martyrs/src/components/Loader/Loader.vue';
@@ -84,6 +130,12 @@ const {
   getPreferences,
   updatePreferences,
   registerWebPush,
+  unregisterWebPush,
+  getSubscriptionState,
+  telegramConnected: storeTelegramConnected,
+  generateTelegramLink,
+  getTelegramStatus,
+  disconnectTelegram,
 } = inject('useNotifications')();
 
 // Local reactive state for form
@@ -92,45 +144,70 @@ const originalPreferences = ref({});
 const saving = ref(false);
 
 // Push permission state
-const pushPermission = ref(typeof window !== 'undefined' && 'Notification' in window ? Notification.permission : 'default');
-const pushEnabled = ref(pushPermission.value === 'granted');
+const pushSupported = ref(typeof window !== 'undefined' && 'serviceWorker' in navigator && 'PushManager' in window);
+const pushPermission = ref('default');
+const pushEnabled = ref(false);
+
+// Telegram state
+const telegramConnected = ref(false);
+const telegramLinking = ref(false);
+
+// Watch for WS-driven telegram connection updates
+watch(storeTelegramConnected, (val) => {
+  if (val) telegramConnected.value = true;
+});
 
 const pushStatusText = computed(() => {
-  if (pushPermission.value === 'denied') return 'Blocked by browser. Allow in site settings';
-  if (pushEnabled.value && pushPermission.value === 'granted') return 'Notifications are enabled';
-  return 'Enable to receive push notifications';
+  if (!pushSupported.value) return 'Not supported in this browser';
+  if (pushEnabled.value) return 'Notifications enabled on this device';
+  // НЕ показываем "Blocked" только по permission === 'denied' — на iOS это ненадёжно
+  // Показываем "Blocked" только если permission denied И подписки нет
+  if (pushPermission.value === 'denied' && !pushEnabled.value) return 'Blocked by browser. Allow in site settings';
+  return 'Allow notifications on this device';
 });
 
 const pushStatusClass = computed(() => {
+  if (!pushSupported.value) return 'opacity-50';
+  if (pushEnabled.value) return 't-green';
   if (pushPermission.value === 'denied') return 't-red';
-  if (pushEnabled.value && pushPermission.value === 'granted') return 't-green';
-  return 't-transp';
+  return 'opacity-50';
 });
 
 const togglePush = async (value) => {
+  // Переключаем свитч сразу — optimistic UI
+  pushEnabled.value = value;
+
   if (value) {
-    // Turning ON → request browser permission DIRECTLY in click handler
     try {
-      const permission = await Notification.requestPermission();
-      pushPermission.value = permission;
-      if (permission === 'granted') {
-        pushEnabled.value = true;
-        // Now register subscription in background
-        registerWebPush().catch(err => console.error('Web push registration error:', err));
-      } else {
-        pushEnabled.value = false;
+      // 1. Запрашиваем permission в контексте user gesture (ОБЯЗАТЕЛЬНО для Safari)
+      //    НО результат НЕ проверяем — на iOS он может врать "denied"
+      if ('Notification' in window) {
+        await Notification.requestPermission();
       }
+      // 2. Пробуем subscribe — если реально нет разрешения, выкинет NotAllowedError
+      //    Если iOS вернул "denied" но реально granted — subscribe сработает
+      await registerWebPush();
+      // 3. Перечитываем реальный state через надёжные API
+      const { permission } = await getSubscriptionState();
+      pushPermission.value = permission;
     } catch (error) {
-      console.error('Push permission error:', error);
-      pushPermission.value = Notification.permission;
+      console.error('Push subscribe error:', error);
+      // Revert — подписка не удалась
       pushEnabled.value = false;
+      const { permission } = await getSubscriptionState();
+      pushPermission.value = permission;
     }
   } else {
-    // Turning OFF
-    pushEnabled.value = false;
+    unregisterWebPush().catch(err => console.error('Push unsubscribe error:', err));
   }
 };
 
+// Standard channels (exclude messengers — they have their own section)
+const messengerChannels = ['telegram', 'whatsapp'];
+const standardChannels = computed(() =>
+  Object.keys(preferences).filter(ch => !messengerChannels.includes(ch))
+);
+
 // Computed properties
 const hasChanges = computed(() => {
   return Object.keys(preferences).some(key =>
@@ -161,6 +238,38 @@ const resetChanges = () => {
   });
 };
 
+const handleConnectTelegram = async () => {
+  try {
+    telegramLinking.value = true;
+    
+    // Открываем окно синхронно, пока ещё в контексте user gesture
+    const win = window.open('', '_blank');
+    
+    const result = await generateTelegramLink();
+    
+    if (result?.deepLink) {
+      if (win) {
+        win.location.href = result.deepLink;
+      } else {
+        // Fallback если всё равно заблокировали
+        window.location.href = result.deepLink;
+      }
+    } else {
+      win?.close();
+    }
+    
+    telegramLinking.value = false;
+  } catch (error) {
+    console.error('Error generating Telegram link:', error);
+    telegramLinking.value = false;
+  }
+};
+
+const handleDisconnectTelegram = async () => {
+  await disconnectTelegram();
+  telegramConnected.value = false;
+};
+
 const getChannelIcon = (channelType) => {
   switch (channelType) {
     case 'web': return '🖥️';
@@ -206,8 +315,29 @@ const getChannelDescription = (channelType) => {
 
 // Lifecycle
 onMounted(async () => {
+  // Определяем реальное состояние подписки через getSubscriptionState (robust для iOS)
+  if (pushSupported.value) {
+    try {
+      const { permission, subscribed } = await getSubscriptionState();
+      pushPermission.value = permission;
+      pushEnabled.value = subscribed;
+    } catch (e) {
+      console.error('Failed to get subscription state:', e);
+    }
+  }
+
   await getPreferences();
 
+  // Check Telegram connection status
+  try {
+    const tgStatus = await getTelegramStatus();
+    if (tgStatus) {
+      telegramConnected.value = tgStatus.connected;
+    }
+  } catch (e) {
+    console.error('Failed to get Telegram status:', e);
+  }
+
   // Copy store preferences to local state
   Object.keys(storePreferences.value).forEach(key => {
     preferences[key] = storePreferences.value[key];

package/src/modules/notifications/controllers/notifications.controller.js

@@ -1,3 +1,4 @@
+import crypto from 'crypto';
 // controllers/notifications.controller.js
 const NotificationsController = (db, wss, notificationService) => {
   // Create a new notification
@@ -85,7 +86,22 @@ const NotificationsController = (db, wss, notificationService) => {
       return res.status(500).json({ message: err.message });
     }
   };
-  // controllers/notifications.controller.js (добавить к существующему контроллеру)
+  // Deactivate device (set isActive: false)
+  const deactivateDevice = async (req, res) => {
+    try {
+      const { deviceId, userId, anonymousId } = req.body;
+      if (!deviceId) return res.status(400).json({ message: 'deviceId is required' });
+
+      const filter = userId ? { userId, deviceId } : anonymousId ? { anonymousId, deviceId } : { deviceId };
+      const result = await db.userDevice.findOneAndUpdate(filter, { $set: { isActive: false, lastActive: Date.now() } }, { new: true });
+
+      if (!result) return res.status(404).json({ message: 'Device not found' });
+      return res.json({ message: 'Device deactivated', device: result });
+    } catch (err) {
+      return res.status(500).json({ message: err.message });
+    }
+  };
+
   // Mark all notifications as read for a user
   const markAllAsRead = async (req, res) => {
     try {
@@ -122,27 +138,18 @@ const NotificationsController = (db, wss, notificationService) => {
     try {
       const { userId, anonymousId, deviceId, deviceType, deviceToken } = req.body;
       
-      console.log('[RegisterDevice] Request:', { userId, anonymousId, deviceId, isAnonymous: !userId });
-      
       // Validate that either userId or anonymousId is provided
       if (!userId && !anonymousId) {
         return res.status(400).json({ message: 'Either userId or anonymousId is required' });
       }
       
-      // FIRST: Check if deviceToken is already used by another device
-      const tokenDevice = await db.userDevice.findOne({
-        deviceToken,
-        $or: [
-          { userId: { $ne: userId } },
-          { deviceId: { $ne: deviceId } }
-        ]
-      });
+      // FIRST: Remove any existing device with the same token but different identity
+      // This handles anonymous→authenticated transition and device re-registration
+      const existingFilter = userId
+        ? { deviceToken, $or: [{ userId: { $exists: false } }, { userId: null }, { userId: { $ne: userId } }, { deviceId: { $ne: deviceId } }] }
+        : { deviceToken, $or: [{ anonymousId: { $exists: false } }, { anonymousId: null }, { anonymousId: { $ne: anonymousId } }, { deviceId: { $ne: deviceId } }] };
 
-      if (tokenDevice) {
-        // This token is already registered to another device, remove it
-        console.log('[RegisterDevice] Token exists for different device, removing:', tokenDevice._id);
-        await tokenDevice.deleteOne();
-      }
+      await db.userDevice.deleteMany(existingFilter);
 
       // Use atomic findOneAndUpdate with upsert to avoid race condition
       const filter = userId
@@ -172,7 +179,6 @@ const NotificationsController = (db, wss, notificationService) => {
         }
       );
 
-      console.log('[RegisterDevice] Device upserted:', device._id);
       return res.status(200).json(device);
     } catch (err) {
       console.error('[RegisterDevice] Error:', err.message);
@@ -320,17 +326,236 @@ const NotificationsController = (db, wss, notificationService) => {
     }
   };
 
+  // Update subscription when endpoint rotates (pushsubscriptionchange from SW)
+  const updateSubscription = async (req, res) => {
+    try {
+      const { oldEndpoint, newSubscription } = req.body;
+
+      if (!oldEndpoint || !newSubscription) {
+        return res.status(400).json({ message: 'oldEndpoint and newSubscription are required' });
+      }
+
+      const newToken = JSON.stringify(newSubscription);
+
+      // Find device by old endpoint (stored as JSON in deviceToken)
+      const devices = await db.userDevice.find({ deviceType: 'web', isActive: true });
+      let updated = false;
+
+      for (const device of devices) {
+        try {
+          const parsed = JSON.parse(device.deviceToken);
+          if (parsed.endpoint === oldEndpoint) {
+            device.deviceToken = newToken;
+            device.lastActive = Date.now();
+            await device.save();
+            updated = true;
+            console.log('[UpdateSubscription] Updated device:', device._id);
+            break;
+          }
+        } catch (e) {}
+      }
+
+      if (!updated) {
+        return res.status(404).json({ message: 'Device with old endpoint not found' });
+      }
+
+      return res.json({ message: 'Subscription updated' });
+    } catch (err) {
+      console.error('[UpdateSubscription] Error:', err.message);
+      return res.status(500).json({ message: err.message });
+    }
+  };
+
+  // Generate a Telegram deep link for user to connect their account
+  const generateTelegramLink = async (req, res) => {
+    try {
+      const { userId } = req.body;
+      if (!userId) return res.status(400).json({ message: 'userId is required' });
+
+      const botUsername = process.env.TELEGRAM_BOT_USERNAME;
+      if (!botUsername) return res.status(500).json({ message: 'TELEGRAM_BOT_USERNAME not configured' });
+
+      const token = crypto.randomBytes(32).toString('hex');
+      const expiry = new Date(Date.now() + 10 * 60 * 1000); // 10 minutes
+
+      // Upsert telegram preference with link token
+      await db.notificationPreference.findOneAndUpdate(
+        { userId, channelType: 'telegram', notificationType: 'all' },
+        { $set: { telegramLinkToken: token, telegramLinkExpiry: expiry } },
+        { upsert: true, new: true }
+      );
+
+      const deepLink = `https://t.me/${botUsername}?start=${token}`;
+      return res.json({ deepLink, expiresAt: expiry });
+    } catch (err) {
+      return res.status(500).json({ message: err.message });
+    }
+  };
+
+  // Get Telegram connection status for a user
+  const getTelegramStatus = async (req, res) => {
+    try {
+      const { userId } = req.params;
+      const pref = await db.notificationPreference.findOne({
+        userId, channelType: 'telegram', notificationType: 'all'
+      });
+      return res.json({
+        connected: !!pref?.telegramChatId,
+        chatId: pref?.telegramChatId || null,
+      });
+    } catch (err) {
+      return res.status(500).json({ message: err.message });
+    }
+  };
+
+  // Disconnect Telegram
+  const disconnectTelegram = async (req, res) => {
+    try {
+      const { userId } = req.body;
+      if (!userId) return res.status(400).json({ message: 'userId is required' });
+
+      await db.notificationPreference.findOneAndUpdate(
+        { userId, channelType: 'telegram', notificationType: 'all' },
+        { $set: { telegramChatId: null, isEnabled: false } }
+      );
+      return res.json({ message: 'Telegram disconnected' });
+    } catch (err) {
+      return res.status(500).json({ message: err.message });
+    }
+  };
+
+  // Telegram bot webhook — receives updates from Telegram
+  const telegramWebhook = async (req, res) => {
+    try {
+      const update = req.body;
+
+      // Handle inline keyboard callback queries (Confirm/Cancel order buttons)
+      if (update?.callback_query) {
+        const callbackQuery = update.callback_query;
+        const data = callbackQuery.data; // e.g. "order_confirm:orderId" or "order_cancel:orderId"
+        const chatId = callbackQuery.message?.chat?.id?.toString();
+        const messageId = callbackQuery.message?.message_id;
+
+        const { sendChatMessageTelegram } = await import('@martyrs/src/modules/core/controllers/utils/mailing.js');
+
+        // Answer callback query to remove loading state
+        const telegramToken = process.env.TELEGRAM_BOT_TOKEN;
+        await fetch(`https://api.telegram.org/bot${telegramToken}/answerCallbackQuery`, {
+          method: 'POST',
+          headers: { 'Content-Type': 'application/json' },
+          body: JSON.stringify({ callback_query_id: callbackQuery.id }),
+        }).catch(() => {});
+
+        if (data?.startsWith('order_confirm:') || data?.startsWith('order_cancel:')) {
+          const [actionPart, orderId] = data.split(':');
+          const action = actionPart === 'order_confirm' ? 'confirm' : 'cancel';
+
+          try {
+            const response = await fetch(`${process.env.API_URL || ''}/api/orders/telegram-action`, {
+              method: 'POST',
+              headers: {
+                'Content-Type': 'application/json',
+                'X-Service-Key': process.env.SERVICE_KEY,
+              },
+              body: JSON.stringify({ action, orderId }),
+            });
+
+            const result = await response.json();
+
+            // Remove inline keyboard buttons from the message
+            const statusEmoji = action === 'confirm' ? '✅' : '❌';
+            const statusText = action === 'confirm' ? 'CONFIRMED' : 'CANCELLED';
+
+            await fetch(`https://api.telegram.org/bot${telegramToken}/editMessageReplyMarkup`, {
+              method: 'POST',
+              headers: { 'Content-Type': 'application/json' },
+              body: JSON.stringify({
+                chat_id: chatId,
+                message_id: messageId,
+                reply_markup: { inline_keyboard: [[
+                  { text: `${statusEmoji} ${statusText}`, callback_data: 'noop' }
+                ]] },
+              }),
+            }).catch(e => console.error('[Telegram] Failed to edit message:', e.message));
+
+            if (!response.ok) {
+              await sendChatMessageTelegram([chatId], `⚠️ ${result.message || 'Failed to process action'}`);
+            }
+          } catch (err) {
+            console.error('[Telegram Callback] Action error:', err);
+            await sendChatMessageTelegram([chatId], '⚠️ Error processing order action');
+          }
+        }
+
+        return res.json({ ok: true });
+      }
+
+      // Only handle /start messages
+      const message = update?.message;
+      if (!message?.text?.startsWith('/start ')) {
+        return res.json({ ok: true });
+      }
+
+      const token = message.text.replace('/start ', '').trim();
+      const chatId = message.chat.id.toString();
+
+      // Find preference with matching token
+      const pref = await db.notificationPreference.findOne({
+        channelType: 'telegram',
+        telegramLinkToken: token,
+        telegramLinkExpiry: { $gt: new Date() },
+      });
+
+      if (!pref) {
+        // Token invalid or expired — send message via bot
+        const { sendChatMessageTelegram } = await import('@martyrs/src/modules/core/controllers/utils/mailing.js');
+        await sendChatMessageTelegram([chatId], 'Link expired or invalid. Please generate a new link in notification settings.');
+        return res.json({ ok: true });
+      }
+
+      // Link successful — save chatId, clear token, enable
+      pref.telegramChatId = chatId;
+      pref.telegramLinkToken = null;
+      pref.telegramLinkExpiry = null;
+      pref.isEnabled = true;
+      await pref.save();
+
+      // Send confirmation to user
+      const { sendChatMessageTelegram } = await import('@martyrs/src/modules/core/controllers/utils/mailing.js');
+      await sendChatMessageTelegram([chatId], '✅ Telegram connected! You will now receive notifications here.');
+
+      // Notify frontend via WebSocket
+      if (wss) {
+        wss.sendToUserInModule('notification', pref.userId, {
+          type: 'telegram_connected',
+          data: { chatId },
+        });
+      }
+
+      return res.json({ ok: true });
+    } catch (err) {
+      console.error('[Telegram Webhook] Error:', err);
+      return res.json({ ok: true }); // Always return 200 to Telegram
+    }
+  };
+
   return {
     create,
     createBatch,
     getUserNotifications,
     markAsRead,
     registerDevice,
+    deactivateDevice,
+    updateSubscription,
     updatePreferences,
     getUserPreferences,
     markAllAsRead,
     sendToTokens,
     sendToAnonymous,
+    generateTelegramLink,
+    getTelegramStatus,
+    disconnectTelegram,
+    telegramWebhook,
   };
 };
 export default NotificationsController;

package/src/modules/notifications/models/notification-preference.model.js

@@ -8,6 +8,10 @@ export default (db, additionalFields = {}) => {
     },
     notificationType: { type: String, required: true }, // Type of notification (alerts, promotions, etc.)
     isEnabled: { type: Boolean, default: true },
+    // Telegram-specific fields
+    telegramChatId: { type: String, default: null },
+    telegramLinkToken: { type: String, default: null },
+    telegramLinkExpiry: { type: Date, default: null },
   });
   schema.index({ userId: 1, channelType: 1, notificationType: 1 }, { unique: true });
   return db.mongoose.model('NotificationPreference', schema);