Dating App Safety

class DatingAppSafetyScanner {
  constructor(apiKey) {
    this.apiKey = apiKey;
    this.baseUrl = 'https://scamverify.ai/api/v1';
  }

  async callApi(endpoint, body) {
    const response = await fetch(`${this.baseUrl}${endpoint}`, {
      method: 'POST',
      headers: {
        'Authorization': `Bearer ${this.apiKey}`,
        'Content-Type': 'application/json',
      },
      body: JSON.stringify(body),
    });
    if (!response.ok) throw new Error(`API error: ${response.status}`);
    return response.json();
  }

  async scanMessage(messageText, senderId) {
    const threats = [];

    // Extract and check phone numbers
    const phoneRegex = /\(?\d{3}\)?[-.\s]?\d{3}[-.\s]?\d{4}/g;
    const phones = messageText.match(phoneRegex) || [];

    for (const phone of phones) {
      const result = await this.callApi('/phone/lookup', {
        phone_number: phone,
      });

      if (result.risk_score >= 40) {
        threats.push({
          type: 'risky_phone',
          value: phone,
          riskScore: result.risk_score,
          reason: result.explanation,
          lineType: result.signals.line_type,
        });
      }
    }

    // Extract and check URLs
    const urlRegex = /https?:\/\/[^\s)]+/gi;
    const urls = messageText.match(urlRegex) || [];

    for (const url of urls) {
      const result = await this.callApi('/url/lookup', { url });

      if (result.risk_score >= 30) {
        threats.push({
          type: 'risky_url',
          value: url,
          riskScore: result.risk_score,
          reason: result.explanation,
          verdict: result.verdict,
        });
      }
    }

    return {
      safe: threats.length === 0,
      threats,
      action: this.determineAction(threats, senderId),
    };
  }

  determineAction(threats, senderId) {
    if (threats.length === 0) return 'ALLOW';

    const hasHighRisk = threats.some(t => t.riskScore >= 70);
    const hasPhishing = threats.some(
      t => t.type === 'risky_url' && t.verdict === 'phishing'
    );

    if (hasHighRisk || hasPhishing) {
      return 'BLOCK_AND_FLAG_ACCOUNT';
    }

    const hasMediumRisk = threats.some(t => t.riskScore >= 40);
    if (hasMediumRisk) {
      return 'BLOCK_MESSAGE_WARN_RECIPIENT';
    }

    return 'WARN_RECIPIENT';
  }
}

// Integration as message middleware
const scanner = new DatingAppSafetyScanner(process.env.SCAMVERIFY_API_KEY);

app.post('/api/messages/send', async (req, res) => {
  const { senderId, recipientId, text } = req.body;

  // Only scan messages that contain phone numbers or URLs
  const hasContactInfo = /\d{3}[-.\s]?\d{3}[-.\s]?\d{4}|https?:\/\//i.test(text);

  if (hasContactInfo) {
    const scan = await scanner.scanMessage(text, senderId);

    switch (scan.action) {
      case 'BLOCK_AND_FLAG_ACCOUNT':
        await flagAccount(senderId, {
          reason: 'Sent message with high-risk contact details',
          threats: scan.threats,
        });
        return res.status(403).json({
          error: 'This message could not be sent.',
        });

      case 'BLOCK_MESSAGE_WARN_RECIPIENT':
        await logBlockedMessage(senderId, recipientId, scan.threats);
        return res.status(400).json({
          error: 'This message contains content that may be unsafe.',
        });

      case 'WARN_RECIPIENT':
        // Send the message but add a safety warning
        await sendMessageWithWarning(senderId, recipientId, text, {
          warning: 'This message contains external links or phone numbers. Be cautious.',
        });
        return res.json({ status: 'sent_with_warning' });
    }
  }

  // No contact info detected, send normally
  await sendMessage(senderId, recipientId, text);
  return res.json({ status: 'sent' });
});

import re
import requests
import os

class DatingAppSafetyScanner:
    def __init__(self, api_key: str):
        self.api_key = api_key
        self.base_url = "https://scamverify.ai/api/v1"

    def _call_api(self, endpoint: str, body: dict) -> dict:
        response = requests.post(
            f"{self.base_url}{endpoint}",
            headers={
                "Authorization": f"Bearer {self.api_key}",
                "Content-Type": "application/json",
            },
            json=body,
        )
        response.raise_for_status()
        return response.json()

    def scan_message(self, message_text: str) -> dict:
        threats = []

        # Check phone numbers
        phones = re.findall(r"\(?\d{3}\)?[-.\s]?\d{3}[-.\s]?\d{4}", message_text)
        for phone in phones:
            result = self._call_api("/phone/lookup", {"phone_number": phone})
            if result["risk_score"] >= 40:
                threats.append({
                    "type": "risky_phone",
                    "value": phone,
                    "risk_score": result["risk_score"],
                    "line_type": result["signals"]["line_type"],
                })

        # Check URLs
        urls = re.findall(r"https?://[^\s)]+", message_text, re.IGNORECASE)
        for url in urls:
            result = self._call_api("/url/lookup", {"url": url})
            if result["risk_score"] >= 30:
                threats.append({
                    "type": "risky_url",
                    "value": url,
                    "risk_score": result["risk_score"],
                    "verdict": result["verdict"],
                })

        return {
            "safe": len(threats) == 0,
            "threats": threats,
        }