Brand Protection
& Monitoring

import requests
from bs4 import BeautifulSoup
import pandas as pd
import re
from urllib.parse import urljoin, urlparse
import time
import random

class BrandProtectionMonitor:
    def __init__(self, proxy_pool, brand_keywords):
        self.proxy_pool = proxy_pool
        self.brand_keywords = brand_keywords
        self.threats_detected = []
        
    def get_proxy(self):
        """Get a random proxy from the pool"""
        proxy = random.choice(self.proxy_pool)
        return {
            'http': f"http://{proxy['user']}:{proxy['pass']}@{proxy['host']}:{proxy['port']}",
            'https': f"https://{proxy['user']}:{proxy['pass']}@{proxy['host']}:{proxy['port']}"
        }
    
    def search_marketplace(self, marketplace_url, search_term):
        """Search marketplace for potential brand violations"""
        headers = {
            'User-Agent': self.get_random_user_agent(),
            'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8',
            'Accept-Language': 'en-US,en;q=0.5',
        }
        
        try:
            response = requests.get(
                f"{marketplace_url}/search?q={search_term}",
                headers=headers,
                proxies=self.get_proxy(),
                timeout=30
            )
            
            if response.status_code == 200:
                return self.analyze_search_results(response.text, marketplace_url)
            
        except Exception as e:
            print(f"Error searching {marketplace_url}: {e}")
            return []
    
    def analyze_search_results(self, html, source_url):
        """Analyze search results for potential threats"""
        soup = BeautifulSoup(html, 'html.parser')
        threats = []
        
        # Look for product listings
        product_elements = soup.find_all(['div', 'article'], class_=re.compile(r'product|item|listing'))
        
        for element in product_elements:
            try:
                # Extract product information
                title_elem = element.find(['h1', 'h2', 'h3', 'h4'], string=re.compile('|'.join(self.brand_keywords), re.I))
                price_elem = element.find(string=re.compile(r'\$[\d,]+'))
                link_elem = element.find('a', href=True)
                
                if title_elem:
                    threat = {
                        'type': 'potential_counterfeit',
                        'title': title_elem.get_text().strip(),
                        'price': price_elem.strip() if price_elem else 'Unknown',
                        'url': urljoin(source_url, link_elem['href']) if link_elem else source_url,
                        'source': urlparse(source_url).netloc,
                        'detected_at': time.time(),
                        'risk_score': self.calculate_risk_score(title_elem.get_text())
                    }
                    threats.append(threat)
                    
            except Exception as e:
                continue
        
        return threats
    
    def calculate_risk_score(self, title):
        """Calculate threat risk score based on title analysis"""
        risk_score = 0
        title_lower = title.lower()
        
        # Check for exact brand matches
        for keyword in self.brand_keywords:
            if keyword.lower() in title_lower:
                risk_score += 30
        
        # Check for suspicious terms
        suspicious_terms = ['replica', 'fake', 'copy', 'imitation', 'knockoff']
        for term in suspicious_terms:
            if term in title_lower:
                risk_score += 50
        
        # Check for pricing indicators
        if any(word in title_lower for word in ['cheap', 'discount', 'wholesale']):
            risk_score += 20
            
        return min(risk_score, 100)
    
    def monitor_social_media(self, platform_urls):
        """Monitor social media for brand mentions and violations"""
        social_threats = []
        
        for platform_url in platform_urls:
            try:
                for keyword in self.brand_keywords:
                    search_url = f"{platform_url}/search?q={keyword}"
                    
                    response = requests.get(
                        search_url,
                        headers={'User-Agent': self.get_random_user_agent()},
                        proxies=self.get_proxy(),
                        timeout=30
                    )
                    
                    if response.status_code == 200:
                        mentions = self.extract_social_mentions(response.text, platform_url)
                        social_threats.extend(mentions)
                    
                    # Rate limiting
                    time.sleep(random.uniform(2, 5))
                    
            except Exception as e:
                print(f"Error monitoring {platform_url}: {e}")
        
        return social_threats
    
    def extract_social_mentions(self, html, platform_url):
        """Extract brand mentions from social media content"""
        soup = BeautifulSoup(html, 'html.parser')
        mentions = []
        
        # Look for posts/content containing brand keywords
        content_elements = soup.find_all(['div', 'p', 'span'], string=re.compile('|'.join(self.brand_keywords), re.I))
        
        for element in content_elements:
            try:
                mention = {
                    'type': 'social_mention',
                    'content': element.get_text().strip()[:200],
                    'platform': urlparse(platform_url).netloc,
                    'detected_at': time.time(),
                    'risk_score': self.analyze_sentiment(element.get_text())
                }
                mentions.append(mention)
                
            except Exception:
                continue
        
        return mentions
    
    def analyze_sentiment(self, text):
        """Simple sentiment analysis for brand mentions"""
        negative_words = ['fake', 'scam', 'terrible', 'awful', 'worst', 'hate']
        positive_words = ['great', 'love', 'amazing', 'excellent', 'best']
        
        text_lower = text.lower()
        negative_count = sum(1 for word in negative_words if word in text_lower)
        positive_count = sum(1 for word in positive_words if word in text_lower)
        
        if negative_count > positive_count:
            return 70  # High risk for negative sentiment
        elif positive_count > negative_count:
            return 10  # Low risk for positive sentiment
        else:
            return 30  # Medium risk for neutral sentiment
    
    def generate_threat_report(self):
        """Generate comprehensive threat report"""
        if not self.threats_detected:
            return "No threats detected."
        
        # Sort by risk score
        sorted_threats = sorted(self.threats_detected, key=lambda x: x['risk_score'], reverse=True)
        
        report = {
            'total_threats': len(sorted_threats),
            'high_risk_threats': len([t for t in sorted_threats if t['risk_score'] >= 70]),
            'medium_risk_threats': len([t for t in sorted_threats if 30 <= t['risk_score'] < 70]),
            'low_risk_threats': len([t for t in sorted_threats if t['risk_score'] < 30]),
            'threats_by_type': {},
            'top_threats': sorted_threats[:10]
        }
        
        # Count threats by type
        for threat in sorted_threats:
            threat_type = threat['type']
            report['threats_by_type'][threat_type] = report['threats_by_type'].get(threat_type, 0) + 1
        
        return report
    
    def run_monitoring_cycle(self, marketplaces, social_platforms):
        """Run a complete monitoring cycle"""
        print("Starting brand protection monitoring...")
        
        # Monitor marketplaces
        for marketplace in marketplaces:
            for keyword in self.brand_keywords:
                threats = self.search_marketplace(marketplace, keyword)
                self.threats_detected.extend(threats)
                time.sleep(random.uniform(3, 7))
        
        # Monitor social media
        social_threats = self.monitor_social_media(social_platforms)
        self.threats_detected.extend(social_threats)
        
        # Generate report
        report = self.generate_threat_report()
        
        # Save results
        df = pd.DataFrame(self.threats_detected)
        df.to_csv('brand_threats.csv', index=False)
        
        return report
    
    def get_random_user_agent(self):
        user_agents = [
            'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36',
            'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36',
            'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36'
        ]
        return random.choice(user_agents)

# Usage
proxy_pool = [
    {'host': 'proxy1.nyronproxies.com', 'port': 8000, 'user': 'username', 'pass': 'password'},
    {'host': 'proxy2.nyronproxies.com', 'port': 8000, 'user': 'username', 'pass': 'password'},
]

brand_keywords = ['YourBrand', 'Your Brand', 'YourBrandName']
marketplaces = ['https://amazon.com', 'https://ebay.com', 'https://alibaba.com']
social_platforms = ['https://twitter.com', 'https://instagram.com', 'https://facebook.com']

monitor = BrandProtectionMonitor(proxy_pool, brand_keywords)
report = monitor.run_monitoring_cycle(marketplaces, social_platforms)

print("Brand Protection Report:", report)

const axios = require('axios');
const cheerio = require('cheerio');
const HttpsProxyAgent = require('https-proxy-agent');
const fs = require('fs').promises;

class TrademarkMonitor {
  constructor(proxyPool, trademarks) {
    this.proxyPool = proxyPool;
    this.trademarks = trademarks;
    this.violations = [];
  }

  getRandomProxy() {
    const proxy = this.proxyPool[Math.floor(Math.random() * this.proxyPool.length)];
    return `http://${proxy.user}:${proxy.pass}@${proxy.host}:${proxy.port}`;
  }

  createClient() {
    const proxyUrl = this.getRandomProxy();
    return axios.create({
      httpsAgent: new HttpsProxyAgent(proxyUrl),
      timeout: 30000,
      headers: {
        'User-Agent': this.getRandomUserAgent(),
        'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8'
      }
    });
  }

  async searchDomains(trademark) {
    const client = this.createClient();
    const searchQueries = [
      `${trademark}.com`,
      `${trademark}.net`,
      `${trademark}.org`,
      `${trademark}shop.com`,
      `buy${trademark}.com`
    ];

    const violations = [];

    for (const domain of searchQueries) {
      try {
        // Check domain registration
        const whoisResult = await this.checkDomainRegistration(domain);
        if (whoisResult.registered && !whoisResult.authorizedOwner) {
          violations.push({
            type: 'domain_violation',
            domain: domain,
            trademark: trademark,
            severity: 'high',
            details: whoisResult,
            detectedAt: new Date().toISOString()
          });
        }

        // Check if domain is active
        try {
          const response = await client.get(`https://${domain}`);
          if (response.status === 200) {
            const content = response.data;
            const suspiciousContent = this.analyzeDomainContent(content, trademark);
            
            if (suspiciousContent.length > 0) {
              violations.push({
                type: 'content_violation',
                domain: domain,
                trademark: trademark,
                severity: this.calculateSeverity(suspiciousContent),
                suspiciousElements: suspiciousContent,
                detectedAt: new Date().toISOString()
              });
            }
          }
        } catch (error) {
          // Domain might not be active
        }

        await this.delay(Math.random() * 2000 + 1000);

      } catch (error) {
        console.error(`Error checking domain ${domain}: ${error.message}`);
      }
    }

    return violations;
  }

  async checkDomainRegistration(domain) {
    // Simplified domain check - in production, use proper WHOIS API
    try {
      const client = this.createClient();
      const response = await client.get(`https://whois.net/${domain}`);
      const $ = cheerio.load(response.data);
      
      const registrationInfo = {
        registered: $('.whois-data').length > 0,
        authorizedOwner: false, // Check against authorized owner list
        registrationDate: $('.registration-date').text().trim(),
        registrar: $('.registrar').text().trim()
      };

      return registrationInfo;
    } catch (error) {
      return { registered: false, authorizedOwner: false };
    }
  }

  analyzeDomainContent(html, trademark) {
    const $ = cheerio.load(html);
    const suspiciousElements = [];

    // Check for trademark usage in title
    const title = $('title').text().toLowerCase();
    if (title.includes(trademark.toLowerCase())) {
      suspiciousElements.push({
        element: 'title',
        content: title,
        riskLevel: 'high'
      });
    }

    // Check for trademark in meta description
    const metaDescription = $('meta[name="description"]').attr('content');
    if (metaDescription && metaDescription.toLowerCase().includes(trademark.toLowerCase())) {
      suspiciousElements.push({
        element: 'meta_description',
        content: metaDescription,
        riskLevel: 'medium'
      });
    }

    // Check for trademark in headings
    $('h1, h2, h3').each((i, element) => {
      const text = $(element).text().toLowerCase();
      if (text.includes(trademark.toLowerCase())) {
        suspiciousElements.push({
          element: 'heading',
          content: text,
          riskLevel: 'high'
        });
      }
    });

    // Check for suspicious keywords
    const suspiciousKeywords = ['replica', 'fake', 'copy', 'imitation'];
    const bodyText = $('body').text().toLowerCase();
    
    suspiciousKeywords.forEach(keyword => {
      if (bodyText.includes(keyword) && bodyText.includes(trademark.toLowerCase())) {
        suspiciousElements.push({
          element: 'body_content',
          content: `Contains "${keyword}" with trademark`,
          riskLevel: 'critical'
        });
      }
    });

    return suspiciousElements;
  }

  calculateSeverity(suspiciousElements) {
    const criticalCount = suspiciousElements.filter(e => e.riskLevel === 'critical').length;
    const highCount = suspiciousElements.filter(e => e.riskLevel === 'high').length;
    const mediumCount = suspiciousElements.filter(e => e.riskLevel === 'medium').length;

    if (criticalCount > 0) return 'critical';
    if (highCount >= 2) return 'high';
    if (highCount >= 1 || mediumCount >= 3) return 'medium';
    return 'low';
  }

  async monitorMarketplaces(trademark) {
    const marketplaces = [
      { name: 'Amazon', searchUrl: 'https://amazon.com/s?k=' },
      { name: 'eBay', searchUrl: 'https://ebay.com/sch/i.html?_nkw=' },
      { name: 'AliExpress', searchUrl: 'https://aliexpress.com/wholesale?SearchText=' }
    ];

    const violations = [];

    for (const marketplace of marketplaces) {
      try {
        const client = this.createClient();
        const searchUrl = `${marketplace.searchUrl}${encodeURIComponent(trademark)}`;
        
        const response = await client.get(searchUrl);
        const $ = cheerio.load(response.data);

        // Extract product listings
        const products = [];
        $('.s-result-item, .listing, .product').each((i, element) => {
          const $element = $(element);
          const title = $element.find('h2, .title, .product-title').text().trim();
          const price = $element.find('.price, .a-price, .notranslate').text().trim();
          const link = $element.find('a').first().attr('href');

          if (title && title.toLowerCase().includes(trademark.toLowerCase())) {
            products.push({ title, price, link, marketplace: marketplace.name });
          }
        });

        // Analyze products for violations
        products.forEach(product => {
          const riskScore = this.analyzeProductRisk(product, trademark);
          if (riskScore >= 60) {
            violations.push({
              type: 'marketplace_violation',
              marketplace: marketplace.name,
              product: product,
              trademark: trademark,
              riskScore: riskScore,
              severity: riskScore >= 80 ? 'high' : 'medium',
              detectedAt: new Date().toISOString()
            });
          }
        });

        await this.delay(Math.random() * 3000 + 2000);

      } catch (error) {
        console.error(`Error monitoring ${marketplace.name}: ${error.message}`);
      }
    }

    return violations;
  }

  analyzeProductRisk(product, trademark) {
    let riskScore = 0;
    const title = product.title.toLowerCase();
    const trademark_lower = trademark.toLowerCase();

    // Exact trademark match
    if (title.includes(trademark_lower)) {
      riskScore += 40;
    }

    // Suspicious terms
    const suspiciousTerms = ['replica', 'fake', 'copy', 'imitation', 'knockoff'];
    suspiciousTerms.forEach(term => {
      if (title.includes(term)) {
        riskScore += 30;
      }
    });

    // Price indicators (unusually low prices)
    const priceMatch = product.price.match(/[d.]+/);
    if (priceMatch) {
      const price = parseFloat(priceMatch[0]);
      if (price < 50) { // Adjust threshold based on brand
        riskScore += 20;
      }
    }

    // Marketplace reputation (simplified)
    if (product.marketplace === 'AliExpress') {
      riskScore += 10; // Higher risk marketplace
    }

    return Math.min(riskScore, 100);
  }

  async generateViolationReport() {
    const report = {
      generatedAt: new Date().toISOString(),
      totalViolations: this.violations.length,
      violationsByType: {},
      violationsBySeverity: {},
      criticalViolations: [],
      recommendations: []
    };

    // Group violations by type and severity
    this.violations.forEach(violation => {
      // By type
      report.violationsByType[violation.type] = 
        (report.violationsByType[violation.type] || 0) + 1;
      
      // By severity
      report.violationsBySeverity[violation.severity] = 
        (report.violationsBySeverity[violation.severity] || 0) + 1;
      
      // Critical violations
      if (violation.severity === 'critical' || violation.severity === 'high') {
        report.criticalViolations.push(violation);
      }
    });

    // Generate recommendations
    if (report.violationsByType.domain_violation > 0) {
      report.recommendations.push('Consider registering defensive domain names');
    }
    if (report.violationsByType.marketplace_violation > 0) {
      report.recommendations.push('File takedown requests with marketplace platforms');
    }
    if (report.criticalViolations.length > 0) {
      report.recommendations.push('Immediate legal action may be required for critical violations');
    }

    return report;
  }

  async runMonitoring() {
    console.log('Starting trademark monitoring...');

    for (const trademark of this.trademarks) {
      console.log(`Monitoring trademark: ${trademark}`);
      
      // Monitor domains
      const domainViolations = await this.searchDomains(trademark);
      this.violations.push(...domainViolations);
      
      // Monitor marketplaces
      const marketplaceViolations = await this.monitorMarketplaces(trademark);
      this.violations.push(...marketplaceViolations);
    }

    // Generate and save report
    const report = await this.generateViolationReport();
    await fs.writeFile('trademark_violations.json', JSON.stringify(report, null, 2));
    
    console.log('Monitoring completed. Report saved.');
    return report;
  }

  getRandomUserAgent() {
    const userAgents = [
      'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36',
      'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36'
    ];
    return userAgents[Math.floor(Math.random() * userAgents.length)];
  }

  delay(ms) {
    return new Promise(resolve => setTimeout(resolve, ms));
  }
}

// Usage
const proxyPool = [
  { host: 'proxy1.nyronproxies.com', port: 8000, user: 'username', pass: 'password' },
  { host: 'proxy2.nyronproxies.com', port: 8000, user: 'username', pass: 'password' }
];

const trademarks = ['YourBrand', 'YourTrademark'];
const monitor = new TrademarkMonitor(proxyPool, trademarks);

monitor.runMonitoring()
  .then(report => {
    console.log('Trademark Monitoring Report:', report);
  })
  .catch(console.error);