Endpoint Lista Prezzi Concorrenti

// Configurazione della richiesta
const apiUrl = 'https://api.commerceclarity.io/api/competitor-prices/index';
const token = 'IL_TUO_TOKEN_API';

// Parametro pagina (opzionale)
const page = 1; // Prima pagina

// Costruisci l'URL con il parametro di query
const requestUrl = `${apiUrl}?page=${page}`;

// Configurazione della richiesta
const requestOptions = {
  method: 'GET',
  headers: {
    'Authorization': `Bearer ${token}`,
    'Accept': 'application/json'
  }
};

// Effettua la richiesta API
fetch(requestUrl, requestOptions)
  .then(response => {
    if (!response.ok) {
      return response.json().then(errorData => {
        throw new Error(errorData.message || `Status: ${response.status}`);
      });
    }
    return response.json();
  })
  .then(data => {
    console.log('Risposta:', data);
    
    // Informazioni sulla paginazione
    console.log(`Pagina corrente: ${data.data.current_page}`);
    console.log(`Totale prodotti: ${data.data.total}`);
    console.log(`Prodotti per pagina: ${data.data.per_page}`);
    console.log(`Pagine totali: ${data.data.last_page}`);
    
    // Esempio: elaborazione dei prodotti e dei concorrenti
    const products = data.data.data;
    console.log(`Prodotti nella pagina corrente: ${products.length}`);
    
    // Esempio: visualizzazione dei prodotti in una tabella
    const productList = document.getElementById('product-list');
    if (productList) {
      // Svuota la lista esistente
      productList.innerHTML = '';
      
      // Crea intestazione tabella
      const headerRow = document.createElement('tr');
      headerRow.innerHTML = `
        Codice
        Nome
        Marca
        Prezzo
        Concorrenti
        Stato
      `;
      productList.appendChild(headerRow);
      
      // Aggiungi ogni prodotto
      products.forEach(product => {
        const productRow = document.createElement('tr');
        
        // Trova il concorrente più economico
        let cheapestCompetitor = null;
        if (product.competitors && product.competitors.length > 0) {
          cheapestCompetitor = product.competitors.reduce((min, comp) => 
            (comp.price + comp.shipping) < (min.price + min.shipping) ? comp : min
          );
        }
        
        const totalConcorrenti = product.competitors ? product.competitors.length : 0;
        
        productRow.innerHTML = `
          ${product.code}
          ${product.name || 'N/D'}
          ${product.brand || 'N/D'}
          ${product.price || 0} + ${product.shipping_cost || 0} spedizione
          ${totalConcorrenti} (min: ${cheapestCompetitor ? cheapestCompetitor.price + cheapestCompetitor.shipping : 'N/D'})
          ${product.status}
        `;
        
        productList.appendChild(productRow);
      });
    }
    
    // Aggiorna i controlli di paginazione
    updatePaginationControls(data.data);
    
    // Crea la dashboard di analisi dei concorrenti
    createCompetitorsAnalysisDashboard(products);
  })
  .catch(error => {
    console.error('Errore durante il recupero dei prezzi dei concorrenti:', error.message);
    
    // Mostra un messaggio di errore all'utente
    showNotification(`Errore: ${error.message}`, 'error');
  });

// Funzione di utilità per determinare il colore dello stato
function getStatusColor(state) {
  switch (state) {
    case 'completed':
      return 'success';
    case 'processing':
      return 'warning';
    case 'error':
      return 'danger';
    default:
      return 'secondary';
  }
}

// Funzione per aggiornare i controlli di paginazione
function updatePaginationControls(pagination) {
  const paginationElement = document.getElementById('pagination');
  if (!paginationElement) return;
  
  paginationElement.innerHTML = '';
  
  // Precedente
  const prevButton = document.createElement('button');
  prevButton.classList.add('btn', 'btn-outline-primary', 'me-2');
  prevButton.innerHTML = '« Precedente';
  prevButton.disabled = !pagination.prev_page_url;
  prevButton.onclick = () => loadPage(pagination.current_page - 1);
  paginationElement.appendChild(prevButton);
  
  // Aggiungi pulsanti per le pagine numeriche
  pagination.links.forEach(link => {
    if (link.url && !isNaN(link.label) && link.label !== '...') {
      const pageButton = document.createElement('button');
      pageButton.classList.add('btn', 'btn-outline-primary', 'me-2');
      if (link.active) {
        pageButton.classList.add('active');
      }
      pageButton.textContent = link.label;
      pageButton.onclick = () => loadPage(parseInt(link.label));
      paginationElement.appendChild(pageButton);
    }
  });
  
  // Successivo
  const nextButton = document.createElement('button');
  nextButton.classList.add('btn', 'btn-outline-primary');
  nextButton.innerHTML = 'Successivo »';
  nextButton.disabled = !pagination.next_page_url;
  nextButton.onclick = () => loadPage(pagination.current_page + 1);
  paginationElement.appendChild(nextButton);
}

// Funzione per caricare una pagina specifica
function loadPage(pageNumber) {
  // Aggiorna l'URL con il nuovo numero di pagina e ricarica i dati
  window.location.href = `?page=${pageNumber}`;
}

// Funzione per creare una dashboard di analisi dei concorrenti
function createCompetitorsAnalysisDashboard(products) {
  const dashboardElement = document.getElementById('competitors-dashboard');
  if (!dashboardElement) return;
  
  // Raccoglie statistiche sui prodotti e concorrenti
  let totalCompetitors = 0;
  let betterPricedProducts = 0;
  let worsePricedProducts = 0;
  let sellers = {};
  
  products.forEach(product => {
    if (!product.competitors) return;
    
    totalCompetitors += product.competitors.length;
    
    // Controlla se il nostro prezzo è più competitivo del prezzo medio dei concorrenti
    const averageCompetitorPrice = product.competitors.reduce((sum, comp) => 
      sum + (comp.price + comp.shipping), 0
    ) / product.competitors.length;
    
    const ourTotalPrice = product.price + product.shipping_cost;
    
    if (ourTotalPrice < averageCompetitorPrice) {
      betterPricedProducts++;
    } else {
      worsePricedProducts++;
    }
    
    // Raccoglie informazioni sui venditori
    product.competitors.forEach(comp => {
      if (!sellers[comp.seller]) {
        sellers[comp.seller] = {
          count: 0,
          totalDifference: 0
        };
      }
      
      sellers[comp.seller].count++;
      sellers[comp.seller].totalDifference += comp.difference;
    });
  });
  
  // Calcola venditori più competitivi
  const topSellers = Object.keys(sellers)
    .map(seller => ({
      name: seller,
      count: sellers[seller].count,
      avgDifference: sellers[seller].totalDifference / sellers[seller].count
    }))
    .sort((a, b) => a.avgDifference - b.avgDifference)
    .slice(0, 5);
  
  // Crea la dashboard
  dashboardElement.innerHTML = `
    

      

        

          

            
Prodotti analizzati
            
${products.length}
          
        
      
      

        

          

            
Concorrenti totali
            
${totalCompetitors}
          
        
      
      

        

          

            
Media concorrenti per prodotto
            
${(totalCompetitors / products.length).toFixed(1)}
          
        
      
    
    
    

      

        

          

            
Competitività prezzi
            

              

                
${betterPricedProducts}
                
Prodotti con prezzo migliore
              
              

                
${worsePricedProducts}
                
Prodotti con prezzo peggiore
              
            
          
        
      
      

        

          

            
Venditori più competitivi
            

              ${topSellers.map(seller => `
                

                  ${seller.name}
                  ${seller.avgDifference.toFixed(2)}%
                
              `).join('')}
            
          
        
      
    
  `;
}

// Funzione di utilità per mostrare notifiche
function showNotification(message, type) {
  // Implementazione della tua funzione di notifica
  console.log(`[${type.toUpperCase()}] ${message}`);
}

import requests
import json
from tabulate import tabulate  # Per una visualizzazione tabellare più elegante (opzionale)

# Configurazione API
api_url = 'https://api.commerceclarity.io/api/competitor-prices/index'
token = 'IL_TUO_TOKEN_API'

headers = {
    'Authorization': f'Bearer {token}',
    'Accept': 'application/json'
}

# Parametri della richiesta
params = {
    'page': 1  # Prima pagina (opzionale)
}

try:
    # Effettua la richiesta GET
    response = requests.get(
        api_url,
        headers=headers,
        params=params
    )
    
    # Solleva eccezione per errori HTTP
    response.raise_for_status()
    
    # Estrai i dati dalla risposta
    result = response.json()
    
    print(f"Stato: {result['status']}")
    print(f"Pagina corrente: {result['data']['current_page']}")
    print(f"Totale prodotti: {result['data']['total']}")
    print(f"Prodotti per pagina: {result['data']['per_page']}")
    print(f"Pagine totali: {result['data']['last_page']}\n")
    
    # Analisi e presentazione dei dati
    products = result['data']['data']
    print(f"Prodotti nella pagina corrente: {len(products)}\n")
    
    # Visualizzazione dei prodotti con i loro concorrenti principali
    for index, product in enumerate(products):
        print(f"{index + 1}. {product['name']} ({product['brand']})")
        print(f"   Codice: {product['code']}")
        print(f"   Prezzo: {product['price']} + {product['shipping_cost']} (spedizione)")
        print(f"   Stato: {product['status']}")
        
        competitors = product.get('competitors', [])
        if competitors:
            print(f"   Concorrenti: {len(competitors)}")
            
            # Ordiniamo i concorrenti per prezzo totale (prezzo + spedizione)
            sorted_competitors = sorted(competitors, key=lambda x: x['price'] + x['shipping'])
            
            # Mostriamo i tre concorrenti più economici
            print("   Concorrenti più economici:")
            for i, competitor in enumerate(sorted_competitors[:3]):
                total_price = competitor['price'] + competitor['shipping']
                diff = competitor['difference']
                diff_symbol = "↓" if diff < 0 else "↑" if diff > 0 else "="
                print(f"     {i+1}. {competitor['seller']}: {competitor['price']} + {competitor['shipping']} = {total_price} ({diff_symbol}{abs(diff):.2f}%)")
        else:
            print("   Nessun concorrente trovato")
        
        print()  # Riga vuota tra i prodotti
    
    # Analisi della competitività
    print("\nAnalisi della competitività:")
    
    # Calcola prodotti con prezzo migliore o peggiore dei concorrenti
    product_competitive_status = []
    for product in products:
        if not product.get('competitors'):
            continue
            
        avg_competitor_price = sum([(c['price'] + c['shipping']) for c in product['competitors']]) / len(product['competitors'])
        our_price = product['price'] + product['shipping_cost']
        
        status = "Migliore" if our_price < avg_competitor_price else "Peggiore"
        product_competitive_status.append({
            'name': product['name'],
            'our_price': our_price,
            'avg_competitor': avg_competitor_price,
            'difference': ((our_price - avg_competitor_price) / avg_competitor_price) * 100,
            'status': status
        })
    
    # Stampa risultati dell'analisi
    better_priced = len([p for p in product_competitive_status if p['status'] == "Migliore"])
    worse_priced = len([p for p in product_competitive_status if p['status'] == "Peggiore"])
    
    print(f"Prodotti con prezzo migliore dei concorrenti: {better_priced} ({better_priced/len(product_competitive_status)*100:.1f}%)")
    print(f"Prodotti con prezzo peggiore dei concorrenti: {worse_priced} ({worse_priced/len(product_competitive_status)*100:.1f}%)")
    
    # Navigazione
    print("\nNavigazione:")
    prev_page_url = result['data']['prev_page_url']
    next_page_url = result['data']['next_page_url']
    print(f"Pagina precedente: {prev_page_url if prev_page_url else 'Non disponibile'}")
    print(f"Pagina successiva: {next_page_url if next_page_url else 'Non disponibile'}")
    
    # Esempio: navigazione automatica tra le pagine
    def fetch_all_competitor_prices():
        """Funzione di utilità per recuperare tutti i prezzi dei concorrenti attraverso la paginazione."""
        all_products = []
        current_page = 1
        last_page = result['data']['last_page']
        
        print(f"\nRecupero di tutti i prodotti ({result['data']['total']}) attraverso {last_page} pagine...")
        
        while current_page <= last_page:
            print(f"Recupero pagina {current_page}...")
            
            page_response = requests.get(
                api_url,
                headers=headers,
                params={'page': current_page}
            )
            page_response.raise_for_status()
            page_data = page_response.json()
            
            # Aggiungi i prodotti della pagina corrente alla lista completa
            all_products.extend(page_data['data']['data'])
            
            current_page += 1
        
        print(f"Totale prodotti recuperati: {len(all_products)}")
        return all_products
    
    # Decommentare per eseguire il recupero di tutti i prodotti (attenzione: potrebbe richiedere molto tempo)
    # all_products = fetch_all_competitor_prices()
    
except requests.exceptions.HTTPError as err:
    print(f"Errore HTTP: {err}")
    if response.text:
        error_data = response.json()
        print(f"Stato: {error_data.get('status', 'sconosciuto')}")
        print(f"Messaggio: {error_data.get('message', 'nessun messaggio')}")
        
except requests.exceptions.RequestException as err:
    print(f"Errore durante la richiesta: {err}")

curl -X GET "https://api.commerceclarity.io/api/competitor-prices/index?page=1" \
     -H "Authorization: Bearer IL_TUO_TOKEN_API" \
     -H "Accept: application/json"