Notifications

import * as Notifications from 'expo-notifications';
import { Platform } from 'react-native';

// Get NATIVE token (not Expo token)
const nativeDeviceToken = await Notifications.getDevicePushTokenAsync();

// Register with backend
await convex.mutation(api.shared.notifications.recordNativeDeviceToken, {
  deviceToken: nativeDeviceToken.data, // This is FCM/APNs token
  platform: Platform.OS === 'ios' ? 'ios' : 'android',
  appVersion: "1.0.0",
  deviceInfo: {
    deviceId: "device-123",
    deviceName: "Samsung Galaxy S21",
    osVersion: "Android 12"
  }
});

import messaging from '@react-native-firebase/messaging';
import { Platform } from 'react-native';

// Get FCM token directly
const fcmToken = await messaging().getToken();

// Register with backend
await convex.mutation(api.shared.notifications.recordNativeDeviceToken, {
  deviceToken: fcmToken,
  platform: Platform.OS === 'ios' ? 'ios' : 'android',
  appVersion: "1.0.0",
  deviceInfo: {
    deviceId: "device-123",
    deviceName: "iPhone 14 Pro",
    osVersion: "iOS 16.0"
  }
});

const deviceToken = await getDeviceToken(); // Your implementation

await convex.mutation("shared.notifications.recordNativeDeviceToken", {
  deviceToken: deviceToken,
  platform: "android", // or "ios"
  appVersion: "1.0.0",
  deviceInfo: {
    deviceId: "device-123",
    deviceName: "Pixel 7",
    osVersion: "Android 13"
  }
});

const result = await convex.action(api.shared.notifications.sendNotificationToUser, {
  userId: "user-123",
  title: "🍕 Order Ready!",
  body: "Your order #12345 is ready for pickup",
  data: {
    type: "order_status",
    orderId: "order-12345",
    deepLink: "twigz://orders/order-12345"
  },
  priority: "high"
});

const result = await convex.action("shared.notifications.sendNotificationToUser", {
  userId: "user-123",
  title: "🍕 Order Ready!",
  body: "Your order #12345 is ready for pickup",
  data: {
    type: "order_status",
    orderId: "order-12345",
    deepLink: "twigz://orders/order-12345"
  },
  priority: "high"
});

import requests

response = requests.post(
    f"{CONVEX_URL}/api/action",
    json={
        "path": "shared.notifications.sendNotificationToUser",
        "args": {
            "userId": "user-123",
            "title": "🍕 Order Ready!",
            "body": "Your order #12345 is ready for pickup",
            "data": {
                "type": "order_status",
                "orderId": "order-12345",
                "deepLink": "twigz://orders/order-12345"
            },
            "priority": "high"
        }
    },
    headers={"Authorization": f"Bearer {token}"}
)

result = response.json()

const notificationId = await convex.mutation(api.shared.notifications.scheduleNotification, {
  userId: "user-123",
  title: "⏰ Appointment Reminder",
  body: "Don't forget your appointment tomorrow at 3 PM",
  scheduledTime: Date.now() + (24 * 60 * 60 * 1000), // 24 hours from now
  data: {
    type: "reminder",
    appointmentId: "apt-456"
  },
  priority: "normal"
});

const tomorrow = new Date();
tomorrow.setDate(tomorrow.getDate() + 1);
tomorrow.setHours(15, 0, 0, 0); // 3 PM tomorrow

const notificationId = await convex.mutation("shared.notifications.scheduleNotification", {
  userId: "user-123",
  title: "⏰ Appointment Reminder",
  body: "Don't forget your appointment tomorrow at 3 PM",
  scheduledTime: tomorrow.getTime(),
  data: {
    type: "reminder",
    appointmentId: "apt-456"
  },
  priority: "normal"
});

const cancelled = await convex.mutation(api.shared.notifications.cancelScheduledNotification, {
  notificationId: "sn123456789"
});

const cancelled = await convex.mutation("shared.notifications.cancelScheduledNotification", {
  notificationId: "sn123456789"
});

const result = await convex.action(api.shared.notifications.sendBulkNotification, {
  userIds: ["user-1", "user-2", "user-3"],
  title: "🎉 System Update",
  body: "New features are now available in the app!",
  data: {
    type: "announcement",
    updateVersion: "2.1.0"
  },
  batchSize: 100
});

const userIds = ["user-1", "user-2", "user-3"]; // Users with registered FCM/APNs tokens

const result = await convex.action("shared.notifications.sendBulkNotification", {
  userIds,
  title: "🎉 Weekend Special",
  body: "Get 25% off all orders this weekend! Use code WEEKEND25",
  data: {
    type: "promotion", 
    code: "WEEKEND25",
    discount: "25",
    validUntil: "2024-01-07"
  }
});

const tokens = await convex.query(api.shared.notifications.getUserDeviceTokens, {
  userId: "user-123"
});

const tokens = await convex.query("shared.notifications.getUserDeviceTokens", {
  userId: "user-123"
});

const result = await convex.action(api.shared.notifications.sendTestNotification, {
  userId: "user-123",
  title: "🔥 FCM/APNs Test",
  body: "Testing direct Firebase/Apple notifications!"
});

const result = await convex.action("shared.notifications.sendTestNotification", {
  userId: "user-123"
});

const debug = await convex.query(api.shared.notifications.debugUserNotifications, {
  userId: "user-123"
});

const debug = await convex.query("shared.notifications.debugUserNotifications", {
  userId: "user-123"
});

const stats = await convex.query(api.shared.notifications.getNotificationStats, {
  startDate: Date.now() - (7 * 24 * 60 * 60 * 1000), // Last 7 days
  endDate: Date.now()
});

const stats = await convex.query("shared.notifications.getNotificationStats", {
  startDate: Date.now() - (7 * 24 * 60 * 60 * 1000), // Last 7 days
  endDate: Date.now()
});

import { useEffect } from 'react';
import * as Notifications from 'expo-notifications';
import { Platform } from 'react-native';
import { useMutation, useAction } from 'convex/react';
import { api } from './convex/_generated/api';

function useNotifications(userId: string) {
  const recordToken = useMutation(api.shared.notifications.recordNativeDeviceToken);
  const sendTest = useAction(api.shared.notifications.sendTestNotification);

  useEffect(() => {
    setupNotifications();
  }, [userId]);

  const setupNotifications = async () => {
    try {
      // Request permissions
      const { status } = await Notifications.requestPermissionsAsync();
      if (status !== 'granted') {
        console.warn('Notification permissions not granted');
        return;
      }

      // Get native device token (FCM/APNs)
      const tokenData = await Notifications.getDevicePushTokenAsync();
      
      // Register with backend
      await recordToken({
        deviceToken: tokenData.data,
        platform: Platform.OS === 'ios' ? 'ios' : 'android',
        appVersion: '1.0.0',
        deviceInfo: {
          deviceId: 'unique-device-id',
          deviceName: Platform.OS === 'ios' ? 'iPhone' : 'Android Device',
          osVersion: Platform.Version.toString()
        }
      });

      console.log('✅ Notification token registered successfully');

    } catch (error) {
      console.error('❌ Failed to setup notifications:', error);
    }
  };

  const testNotification = async () => {
    try {
      const result = await sendTest({
        userId,
        title: '🧪 Test from App',
        body: 'This is a test notification!'
      });
      console.log('Test result:', result);
    } catch (error) {
      console.error('Test failed:', error);
    }
  };

  // Handle received notifications
  useEffect(() => {
    const subscription = Notifications.addNotificationReceivedListener(notification => {
      console.log('📱 Notification received:', notification);
      
      // Handle notification data
      const data = notification.request.content.data;
      if (data?.type === 'order_status' && data?.orderId) {
        // Navigate to order details
        // navigation.navigate('Order', { orderId: data.orderId });
      }
    });

    return () => subscription.remove();
  }, []);

  return { testNotification };
}

export default useNotifications;

import { ref, onMounted } from 'vue';
import { useConvexMutation, useConvexAction } from '@convex-vue/core';

export function useNotifications(userId: string) {
  const isSetup = ref(false);
  const recordToken = useConvexMutation('shared.notifications.recordNativeDeviceToken');
  const sendTest = useConvexAction('shared.notifications.sendTestNotification');

  onMounted(() => {
    setupNotifications();
  });

  const setupNotifications = async () => {
    try {
      // Your platform-specific token retrieval logic
      const deviceToken = await getDeviceToken();
      
      await recordToken({
        deviceToken,
        platform: 'android', // or 'ios'
        appVersion: '1.0.0',
        deviceInfo: {
          deviceId: 'unique-device-id',
          deviceName: 'Android Device',
          osVersion: 'Android 13'
        }
      });

      isSetup.value = true;
      console.log('✅ Notification setup complete');

    } catch (error) {
      console.error('❌ Notification setup failed:', error);
    }
  };

  const testNotification = async () => {
    const result = await sendTest({
      userId,
      title: '🧪 Vue Test',
      body: 'Testing from Vue app!'
    });
    return result;
  };

  return {
    isSetup,
    testNotification
  };
}

const debug = await convex.query(api.shared.notificationDebug.debugNotificationSystem, {
  userId: "user-123"
});

console.log("Tokens:", debug.deviceTokenCount);
console.log("FCM configured:", debug.environmentCheck.hasFCMConfig);
console.log("APNs configured:", debug.environmentCheck.hasAPNSConfig);
console.log("Recommendations:", debug.recommendations);

const debug = await convex.query("shared.notificationDebug.debugNotificationSystem", {
  userId: "user-123"
});

const result = await convex.action(api.shared.notificationDebug.testSendNotification, {});

if (result.success) {
  console.log("Test notification sent!", result.message);
} else {
  console.error("Failed:", result.message, result.details);
}

const result = await convex.action("shared.notificationDebug.testSendNotification", {});

const result = await convex.action(api.shared.notificationDebug.testFCMDirect, {
  fcmToken: "dGVzdC10b2tlbi0xMjM0NTY3ODkw...",
  title: "Direct Token Test",
  body: "Testing this specific FCM token"
});

console.log(result.success ? "Token is valid!" : "Token failed:", result.message);

const result = await convex.action("shared.notificationDebug.testFCMDirect", {
  fcmToken: "dGVzdC10b2tlbi0xMjM0NTY3ODkw..."
});