init

.dockerignore

@@ -0,0 +1,81 @@
+# Node.js dependencies
+node_modules/
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+
+# Runtime data
+pids
+*.pid
+*.seed
+*.pid.lock
+
+# Coverage directory used by tools like istanbul
+coverage/
+
+# Logs
+logs
+*.log
+
+# Dependency directories
+.npm
+.eslintcache
+
+# Optional npm cache directory
+.npm
+
+# Optional eslint cache
+.eslintcache
+
+# Microbundle cache
+.rpt2_cache/
+.rts2_cache_cjs/
+.rts2_cache_es/
+.rts2_cache_umd/
+
+# Optional REPL history
+.node_repl_history
+
+# Output of 'npm pack'
+*.tgz
+
+# Yarn Integrity file
+.yarn-integrity
+
+# dotenv environment variables file
+.env
+.env.local
+.env.development.local
+.env.test.local
+.env.production.local
+
+# parcel-bundler cache (https://parceljs.org/)
+.cache
+.parcel-cache
+
+# OS generated files
+.DS_Store
+.DS_Store?
+._*
+.Spotlight-V100
+.Trashes
+ehthumbs.db
+Thumbs.db
+
+# Git
+.git
+.gitignore
+
+# Development files
+README.md
+*.md
+test/
+tests/
+docs/
+
+# Firebase service account (should be mounted as secret)
+firebase-service-account.json
+
+# Development scripts
+test-*.sh
+test-*.js 

Dockerfile

@@ -0,0 +1,39 @@
+# Use the official Node.js runtime as base image
+FROM node:18-alpine
+
+# Set the working directory
+WORKDIR /app
+
+# Copy package.json and package-lock.json
+COPY package*.json ./
+
+# Install dependencies
+RUN npm ci --only=production
+
+# Copy the rest of the application code
+COPY . .
+
+# Create a non-root user
+RUN addgroup -g 1001 -S nodejs
+RUN adduser -S nodejs -u 1001
+
+# Change ownership of the app directory to the nodejs user
+RUN chown -R nodejs:nodejs /app
+
+# Switch to the non-root user
+USER nodejs
+
+# Expose the port that the app runs on
+# Hugging Face Spaces expects the app to run on port 7860
+EXPOSE 7860
+
+# Set environment variables
+ENV NODE_ENV=production
+ENV PORT=7860
+
+# Health check
+HEALTHCHECK --interval=30s --timeout=3s --start-period=5s --retries=3 \
+  CMD node -e "require('http').get('http://localhost:7860', (res) => { process.exit(res.statusCode === 200 ? 0 : 1) })"
+
+# Start the application
+CMD ["node", "server.js"] 

devices.json

@@ -0,0 +1,22 @@
+[
+  [
+    "4903319C-6B6F-45A5-B3E1-1B2B1A0DE705",
+    {
+      "token": "f4jB7HvitkbLitRnP8PezM:APA91bFpr0zdompJnWqBZwjG_1--WdCnXbUAleDpnpbs_bhdBWGZuJBircYGyiW13JrPJ1OuI5Q3ZzLjZflsWIvvx_XCrnpa5JP5lJOrCcHZCJUdqBXuSzM",
+      "lastUpdated": "2025-07-04T01:57:11.482Z",
+      "platform": "iOS",
+      "appVersion": "1.0.0",
+      "registered": true
+    }
+  ],
+  [
+    "326514BA-AC8D-4F58-AFD8-AEE5708B9AE4",
+    {
+      "token": "dJz9z8vH0UMVhyRr0-M5Ul:APA91bHE1qqammp3lpv9KCN13yiRUk4EiQqZu0LvWqGtc__r7axaWgBjiTS5oIElfsZpyM6p3vYPv2he8XfbWRQDl1fITivKwvrjjjyeHdgzAcwZtCI55R4",
+      "lastUpdated": "2025-07-04T06:40:28.014Z",
+      "platform": "iOS",
+      "appVersion": "1.0.0",
+      "registered": true
+    }
+  ]
+]

package.json

@@ -0,0 +1,23 @@
+{
+  "name": "houzou-notification-server",
+  "version": "1.0.0",
+  "description": "Notification server for Houzou Medical App",
+  "main": "server.js",
+  "scripts": {
+    "start": "node server.js",
+    "dev": "nodemon server.js"
+  },
+  "dependencies": {
+    "express": "^4.18.2",
+    "firebase-admin": "^12.0.0",
+    "cors": "^2.8.5",
+    "body-parser": "^1.20.2",
+    "dotenv": "^16.3.1"
+  },
+  "devDependencies": {
+    "nodemon": "^3.0.2"
+  },
+  "keywords": ["firebase", "fcm", "notification", "flutter"],
+  "author": "Houzou Medical",
+  "license": "MIT"
+} 

server.js

@@ -0,0 +1,685 @@
+const express = require('express');
+const admin = require('firebase-admin');
+const cors = require('cors');
+const bodyParser = require('body-parser');
+const os = require('os');
+require('dotenv').config();
+
+const app = express();
+const PORT = process.env.PORT || 3000;
+
+// Middleware
+app.use(cors());
+app.use(bodyParser.json());
+app.use(bodyParser.urlencoded({ extended: true }));
+
+// Initialize Firebase Admin SDK
+// Supports both environment variable (production) and file (development)
+try {
+  let serviceAccount;
+  
+  if (process.env.FIREBASE_SERVICE_ACCOUNT) {
+    // Production: Read from environment variable (Hugging Face Spaces secret)
+    console.log('🔥 Loading Firebase service account from environment variable');
+    serviceAccount = JSON.parse(process.env.FIREBASE_SERVICE_ACCOUNT);
+  } else {
+    // Development: Read from file
+    console.log('🔥 Loading Firebase service account from file');
+    serviceAccount = require('./firebase-service-account.json');
+  }
+  
+  console.log(`🔥 Firebase service account loaded for project: ${serviceAccount.project_id}`);
+  
+  admin.initializeApp({
+    credential: admin.credential.cert(serviceAccount),
+  });
+  
+  console.log('✅ Firebase Admin SDK initialized successfully');
+} catch (error) {
+  console.error('❌ Firebase Admin SDK initialization failed:', error);
+  if (!process.env.FIREBASE_SERVICE_ACCOUNT) {
+    console.error('💡 Please check that firebase-service-account.json exists and has correct permissions');
+    console.error('💡 Or set FIREBASE_SERVICE_ACCOUNT environment variable for production');
+  } else {
+    console.error('💡 Please check that FIREBASE_SERVICE_ACCOUNT environment variable contains valid JSON');
+  }
+  process.exit(1);
+}
+
+// Sample products data (matching your Flutter app)
+const sampleProducts = [
+  { id: 1, title: "NMN 10000mg Ultra", price: "¥8,800", category: "Anti-Aging" },
+  { id: 2, title: "Arginine & Citrulline", price: "¥5,200", category: "Sports Nutrition" },
+  { id: 3, title: "Broccoli Sprout Extract", price: "¥3,600", category: "Detox & Cleanse" },
+  { id: 4, title: "Sun Protection Plus", price: "¥4,200", category: "Skin Health" },
+  { id: 5, title: "Alpha-GPC Cognitive", price: "¥6,500", category: "Brain Health" },
+  { id: 6, title: "Multivitamin Complete", price: "¥2,800", category: "General Health" },
+];
+
+const fs = require('fs');
+const path = require('path');
+
+// File storage for FCM tokens
+const DEVICES_FILE = path.join(__dirname, 'devices.json');
+
+// Load devices from file or create empty storage
+let deviceTokens = new Map();
+
+function loadDevicesFromFile() {
+  try {
+    if (fs.existsSync(DEVICES_FILE)) {
+      const data = fs.readFileSync(DEVICES_FILE, 'utf8');
+      const devicesArray = JSON.parse(data);
+      deviceTokens = new Map(devicesArray);
+      console.log(`📁 Loaded ${deviceTokens.size} devices from file`);
+    } else {
+      console.log('📁 No devices file found, starting fresh');
+    }
+  } catch (error) {
+    console.error('❌ Error loading devices file:', error);
+    deviceTokens = new Map();
+  }
+}
+
+function saveDevicesToFile() {
+  try {
+    const devicesArray = Array.from(deviceTokens.entries());
+    fs.writeFileSync(DEVICES_FILE, JSON.stringify(devicesArray, null, 2));
+    console.log(`💾 Saved ${deviceTokens.size} devices to file`);
+  } catch (error) {
+    console.error('❌ Error saving devices file:', error);
+  }
+}
+
+// Load devices on startup
+loadDevicesFromFile();
+
+// Routes
+
+// Health check
+app.get('/', (req, res) => {
+  res.json({
+    message: 'Houzou Medical Notification Server',
+    status: 'running',
+    timestamp: new Date().toISOString()
+  });
+});
+
+// Test Firebase connectivity
+app.get('/test-firebase', async (req, res) => {
+  try {
+    console.log('🔥 Testing Firebase connectivity...');
+    
+    // Try to get Firebase project info
+    const projectId = admin.app().options.projectId;
+    console.log(`📱 Project ID: ${projectId}`);
+    
+    // Try a simple Firebase operation
+    const testMessage = {
+      notification: {
+        title: 'Test',
+        body: 'Firebase connectivity test'
+      },
+      token: 'test-token-that-will-fail' // This will fail but test auth
+    };
+    
+    try {
+      await admin.messaging().send(testMessage);
+    } catch (testError) {
+      console.log(`🔍 Test message error (expected):`, testError.code);
+      
+      if (testError.code === 'messaging/invalid-registration-token') {
+        // This is expected - it means Firebase auth is working
+        res.json({
+          success: true,
+          message: 'Firebase connectivity OK',
+          projectId: projectId,
+          note: 'Authentication working (test token failed as expected)'
+        });
+        return;
+      } else if (testError.code && testError.code.includes('auth')) {
+        // Auth error - this is the real problem
+        throw testError;
+      } else {
+        // Other error but auth seems OK
+        res.json({
+          success: true,
+          message: 'Firebase connectivity OK',
+          projectId: projectId,
+          note: `Test completed with expected error: ${testError.code}`
+        });
+        return;
+      }
+    }
+    
+    res.json({
+      success: true,
+      message: 'Firebase connectivity OK',
+      projectId: projectId
+    });
+    
+  } catch (error) {
+    console.error('❌ Firebase test failed:', error);
+    res.status(500).json({
+      success: false,
+      error: error.message,
+      code: error.code
+    });
+  }
+});
+
+// Send notification to navigate to Home
+app.post('/send-home-notification', async (req, res) => {
+  try {
+    const { token, title, body } = req.body;
+
+    if (!token) {
+      return res.status(400).json({ error: 'FCM token is required' });
+    }
+
+    const message = {
+      notification: {
+        title: title || 'Welcome Back!',
+        body: body || 'Check out our latest health supplements',
+      },
+      data: {
+        type: 'home',
+        click_action: 'FLUTTER_NOTIFICATION_CLICK',
+      },
+      token: token,
+    };
+
+    const response = await admin.messaging().send(message);
+    
+    res.json({
+      success: true,
+      messageId: response,
+      message: 'Home notification sent successfully'
+    });
+
+  } catch (error) {
+    console.error('Error sending home notification:', error);
+    res.status(500).json({
+      success: false,
+      error: error.message
+    });
+  }
+});
+
+// Send notification to navigate to Product Detail
+app.post('/send-product-notification', async (req, res) => {
+  try {
+    const { token, productId, title, body } = req.body;
+
+    if (!token) {
+      return res.status(400).json({ error: 'FCM token is required' });
+    }
+
+    if (!productId) {
+      return res.status(400).json({ error: 'Product ID is required' });
+    }
+
+    // Find product by ID
+    const product = sampleProducts.find(p => p.id.toString() === productId.toString());
+    
+    if (!product) {
+      return res.status(404).json({ error: 'Product not found' });
+    }
+
+    const message = {
+      notification: {
+        title: title || `New Deal: ${product.title}`,
+        body: body || `Special offer on ${product.title} - ${product.price}. Tap to view details!`,
+      },
+      data: {
+        type: 'product_detail',
+        product_id: productId.toString(),
+        product_title: product.title,
+        product_price: product.price,
+        click_action: 'FLUTTER_NOTIFICATION_CLICK',
+      },
+      token: token,
+    };
+
+    const response = await admin.messaging().send(message);
+    
+    res.json({
+      success: true,
+      messageId: response,
+      message: 'Product notification sent successfully',
+      product: product
+    });
+
+  } catch (error) {
+    console.error('Error sending product notification:', error);
+    res.status(500).json({
+      success: false,
+      error: error.message
+    });
+  }
+});
+
+// Send notification to multiple devices (topic)
+app.post('/send-topic-notification', async (req, res) => {
+  try {
+    const { topic, title, body, type, productId } = req.body;
+
+    if (!topic) {
+      return res.status(400).json({ error: 'Topic is required' });
+    }
+
+    let data = {
+      type: type || 'home',
+      click_action: 'FLUTTER_NOTIFICATION_CLICK',
+    };
+
+    // Add product data if it's a product notification
+    if (type === 'product_detail' && productId) {
+      const product = sampleProducts.find(p => p.id.toString() === productId.toString());
+      if (product) {
+        data.product_id = productId.toString();
+        data.product_title = product.title;
+        data.product_price = product.price;
+      }
+    }
+
+    const message = {
+      notification: {
+        title: title || 'Houzou Medical',
+        body: body || 'New update available!',
+      },
+      data: data,
+      topic: topic,
+    };
+
+    const response = await admin.messaging().send(message);
+    
+    res.json({
+      success: true,
+      messageId: response,
+      message: `Topic notification sent successfully to ${topic}`
+    });
+
+  } catch (error) {
+    console.error('Error sending topic notification:', error);
+    res.status(500).json({
+      success: false,
+      error: error.message
+    });
+  }
+});
+
+// Get sample products
+app.get('/products', (req, res) => {
+  res.json({
+    success: true,
+    products: sampleProducts
+  });
+});
+
+// Test notification endpoint
+app.post('/test-notification', async (req, res) => {
+  try {
+    const { token } = req.body;
+
+    if (!token) {
+      return res.status(400).json({ error: 'FCM token is required for testing' });
+    }
+
+    // Send a test notification to home
+    const homeMessage = {
+      notification: {
+        title: '🏠 Test Home Notification',
+        body: 'This will take you to the home screen!',
+      },
+      data: {
+        type: 'home',
+        click_action: 'FLUTTER_NOTIFICATION_CLICK',
+      },
+      token: token,
+    };
+
+    const homeResponse = await admin.messaging().send(homeMessage);
+
+    // Send a test notification for product detail (random product)
+    const randomProduct = sampleProducts[Math.floor(Math.random() * sampleProducts.length)];
+    
+    const productMessage = {
+      notification: {
+        title: '🛍️ Test Product Notification',
+        body: `Check out ${randomProduct.title} - ${randomProduct.price}`,
+      },
+      data: {
+        type: 'product_detail',
+        product_id: randomProduct.id.toString(),
+        product_title: randomProduct.title,
+        product_price: randomProduct.price,
+        click_action: 'FLUTTER_NOTIFICATION_CLICK',
+      },
+      token: token,
+    };
+
+    const productResponse = await admin.messaging().send(productMessage);
+
+    res.json({
+      success: true,
+      message: 'Test notifications sent successfully',
+      results: {
+        home: homeResponse,
+        product: productResponse,
+        testedProduct: randomProduct
+      }
+    });
+
+  } catch (error) {
+    console.error('Error sending test notifications:', error);
+    res.status(500).json({
+      success: false,
+      error: error.message
+    });
+  }
+});
+
+// Register/Update FCM Token
+app.post('/register-token', async (req, res) => {
+  try {
+    const { token, deviceId, platform, appVersion } = req.body;
+
+    if (!token || !deviceId) {
+      return res.status(400).json({ 
+        success: false,
+        error: 'FCM token and device ID are required' 
+      });
+    }
+
+    // Store token with metadata
+    deviceTokens.set(deviceId, {
+      token: token,
+      lastUpdated: new Date().toISOString(),
+      platform: platform || 'unknown',
+      appVersion: appVersion || '1.0.0',
+      registered: true
+    });
+
+    console.log(`📱 Token registered for device ${deviceId} (${platform})`);
+
+    // Auto-subscribe to 'all_users' topic for broadcast notifications
+    try {
+      await admin.messaging().subscribeToTopic([token], 'all_users');
+      console.log(`✅ Device ${deviceId} subscribed to 'all_users' topic`);
+    } catch (topicError) {
+      console.warn(`⚠️ Failed to subscribe device to topic: ${topicError.message}`);
+    }
+
+    // Save to file
+    saveDevicesToFile();
+
+    res.json({
+      success: true,
+      message: 'FCM token registered successfully',
+      deviceCount: deviceTokens.size
+    });
+
+  } catch (error) {
+    console.error('Error registering token:', error);
+    res.status(500).json({
+      success: false,
+      error: error.message
+    });
+  }
+});
+
+// Unregister FCM Token
+app.post('/unregister-token', async (req, res) => {
+  try {
+    const { deviceId } = req.body;
+
+    if (!deviceId) {
+      return res.status(400).json({ 
+        success: false,
+        error: 'Device ID is required' 
+      });
+    }
+
+    const deviceInfo = deviceTokens.get(deviceId);
+    if (deviceInfo) {
+      // Unsubscribe from topics
+      try {
+        await admin.messaging().unsubscribeFromTopic([deviceInfo.token], 'all_users');
+      } catch (topicError) {
+        console.warn(`⚠️ Failed to unsubscribe device from topic: ${topicError.message}`);
+      }
+
+      deviceTokens.delete(deviceId);
+      console.log(`📱 Token unregistered for device ${deviceId}`);
+    }
+
+    // Save to file
+    saveDevicesToFile();
+
+    res.json({
+      success: true,
+      message: 'FCM token unregistered successfully',
+      deviceCount: deviceTokens.size
+    });
+
+  } catch (error) {
+    console.error('Error unregistering token:', error);
+    res.status(500).json({
+      success: false,
+      error: error.message
+    });
+  }
+});
+
+// Get registered devices info
+app.get('/devices', (req, res) => {
+  const devices = Array.from(deviceTokens.entries()).map(([deviceId, info]) => ({
+    deviceId,
+    platform: info.platform,
+    appVersion: info.appVersion,
+    lastUpdated: info.lastUpdated,
+    registered: info.registered
+  }));
+
+  res.json({
+    success: true,
+    deviceCount: devices.length,
+    devices: devices
+  });
+});
+
+// Debug endpoint to manually add test device
+app.post('/debug-add-device', (req, res) => {
+  try {
+    const { deviceId, token, platform } = req.body;
+    
+    if (!deviceId || !token) {
+      return res.status(400).json({
+        success: false,
+        error: 'deviceId and token are required'
+      });
+    }
+    
+    deviceTokens.set(deviceId, {
+      token: token,
+      lastUpdated: new Date().toISOString(),
+      platform: platform || 'debug',
+      appVersion: '1.0.0',
+      registered: true
+    });
+    
+    saveDevicesToFile();
+    
+    console.log(`🔧 Debug: Added device ${deviceId} (${platform})`);
+    
+    res.json({
+      success: true,
+      message: 'Device added for testing',
+      deviceCount: deviceTokens.size
+    });
+    
+  } catch (error) {
+    console.error('Error adding debug device:', error);
+    res.status(500).json({
+      success: false,
+      error: error.message
+    });
+  }
+});
+
+// Send notification to ALL registered devices
+app.post('/send-broadcast-notification', async (req, res) => {
+  try {
+    const { title, body, type, productId } = req.body;
+
+    if (deviceTokens.size === 0) {
+      return res.status(400).json({ 
+        success: false,
+        error: 'No devices registered' 
+      });
+    }
+
+    // Prepare message data
+    let data = {
+      type: type || 'home',
+      click_action: 'FLUTTER_NOTIFICATION_CLICK',
+    };
+
+    // Add product data if it's a product notification
+    if (type === 'product_detail' && productId) {
+      const product = sampleProducts.find(p => p.id.toString() === productId.toString());
+      if (product) {
+        data.product_id = productId.toString();
+        data.product_title = product.title;
+        data.product_price = product.price;
+      }
+    }
+
+    // Get all active tokens
+    const tokens = Array.from(deviceTokens.values()).map(device => device.token);
+    
+    // Send to all devices using multicast
+    const message = {
+      notification: {
+        title: title || 'Houzou Medical',
+        body: body || 'New update available!',
+      },
+      data: data,
+      tokens: tokens,
+    };
+
+    console.log(`📤 Attempting to send notification to ${tokens.length} devices`);
+    console.log(`📋 Message data:`, JSON.stringify(message, null, 2));
+    
+    const response = await admin.messaging().sendEachForMulticast(message);
+    
+    console.log(`📊 Send results: Success=${response.successCount}, Failed=${response.failureCount}`);
+
+    // Handle failed tokens with detailed logging
+    if (response.failureCount > 0) {
+      console.log(`❌ Detailed failure analysis:`);
+      const failedTokens = [];
+      
+      response.responses.forEach((resp, idx) => {
+        const token = tokens[idx];
+        const deviceId = Array.from(deviceTokens.entries()).find(([id, info]) => info.token === token)?.[0];
+        
+        if (!resp.success) {
+          console.log(`❌ Device ${deviceId} failed:`, resp.error);
+          console.log(`   Error code: ${resp.error?.code}`);
+          console.log(`   Error message: ${resp.error?.message}`);
+          
+          // Only remove tokens for specific errors (not auth errors)
+          const errorCode = resp.error?.code;
+          const shouldRemoveToken = [
+            'messaging/invalid-registration-token',
+            'messaging/registration-token-not-registered'
+          ].includes(errorCode);
+          
+          if (shouldRemoveToken) {
+            failedTokens.push(token);
+            console.log(`🗑️ Marking token for removal: ${deviceId} (${errorCode})`);
+          } else {
+            console.log(`⚠️ Keeping token for ${deviceId} - temporary error: ${errorCode}`);
+          }
+        } else {
+          console.log(`✅ Device ${deviceId} notification sent successfully`);
+        }
+      });
+      
+      // Remove only truly invalid tokens
+      if (failedTokens.length > 0) {
+        console.log(`🗑️ Removing ${failedTokens.length} invalid tokens`);
+        failedTokens.forEach(failedToken => {
+          for (const [deviceId, info] of deviceTokens.entries()) {
+            if (info.token === failedToken) {
+              console.log(`🗑️ Removing invalid token for device ${deviceId}`);
+              deviceTokens.delete(deviceId);
+              break;
+            }
+          }
+        });
+        saveDevicesToFile();
+      } else {
+        console.log(`⚠️ No tokens removed - all failures appear to be temporary`);
+      }
+    }
+
+    res.json({
+      success: true,
+      message: `Broadcast notification sent to ${response.successCount} devices`,
+      results: {
+        successCount: response.successCount,
+        failureCount: response.failureCount,
+        totalDevices: deviceTokens.size
+      }
+    });
+
+  } catch (error) {
+    console.error('Error sending broadcast notification:', error);
+    res.status(500).json({
+      success: false,
+      error: error.message
+    });
+  }
+});
+
+// Error handling middleware
+app.use((error, req, res, next) => {
+  console.error('Server error:', error);
+  res.status(500).json({
+    success: false,
+    error: 'Internal server error'
+  });
+});
+
+// Get local IP address
+function getLocalIPAddress() {
+  const interfaces = os.networkInterfaces();
+  for (const devName in interfaces) {
+    const iface = interfaces[devName];
+    for (let i = 0; i < iface.length; i++) {
+      const alias = iface[i];
+      if (alias.family === 'IPv4' && alias.address !== '127.0.0.1' && !alias.internal) {
+        return alias.address;
+      }
+    }
+  }
+  return 'localhost';
+}
+
+// Start server
+app.listen(PORT, () => {
+  const localIP = getLocalIPAddress();
+  
+  console.log(`🚀 Houzou Medical Notification Server running on port ${PORT}`);
+  console.log(`📱 Ready to send notifications to your Flutter app!`);
+  console.log(`\n📍 Server URLs:`);
+  console.log(`   Local:    http://localhost:${PORT}`);
+  console.log(`   Network:  http://${localIP}:${PORT}`);
+  console.log(`\n🔧 For iPhone app, use: http://${localIP}:${PORT}`);
+  console.log(`📁 Devices saved to: ${DEVICES_FILE}`);
+});
+
+module.exports = app;