Code Examples

class BrainPricesAPI {
  constructor(baseUrl = 'https://www.brainprices.com/api/v1') {
    this.baseUrl = baseUrl;
    this.token = null;
  }

  async request(endpoint, options = {}) {
    const headers = {
      'Content-Type': 'application/json',
      ...options.headers
    };

    if (this.token) {
      headers['Authorization'] = `Bearer ${this.token}`;
    }

    const response = await fetch(`${this.baseUrl}${endpoint}`, {
      ...options,
      headers
    });

    const data = await response.json();
    
    if (!response.ok) {
      throw new Error(data.message || 'API Error');
    }

    return data;
  }

  async login(email, password) {
    const data = await this.request('/auth/login', {
      method: 'POST',
      body: JSON.stringify({ email, password })
    });

    this.token = data.token;
    localStorage.setItem('auth_token', this.token);
    return data;
  }

  async getProducts(filters = {}) {
    const params = new URLSearchParams(filters);
    return await this.request(`/productos?${params}`);
  }

  async createProduct(productData) {
    return await this.request('/productos', {
      method: 'POST',
      body: JSON.stringify(productData)
    });
  }

  async updateStock(productId, quantity, operation = 'set') {
    return await this.request(`/productos/${productId}/stock`, {
      method: 'PUT',
      body: JSON.stringify({ stock_quantity: quantity, operation })
    });
  }

  async addToCart(sessionId, productId, quantity = 1) {
    return await this.request(`/carrito/${sessionId}/agregar`, {
      method: 'POST',
      body: JSON.stringify({ product_id: productId, quantity })
    });
  }
}

// Initialize API
const api = new BrainPricesAPI();

// Login
const user = await api.login('seller@example.com', 'password123');
console.log('Logged in as:', user.user.email);

// Get products on sale
const products = await api.getProducts({
  on_sale: true,
  category_id: 5,
  page: 1,
  per_page: 20
});

console.log(`Found ${products.pagination.total} products on sale`);

// Create new product
const newProduct = await api.createProduct({
  name: 'Vino Tinto Reserva 2023',
  sku: 'VIN-TINTO-RES-2023',
  price: 18.99,
  compare_price: 24.99,
  stock_quantity: 50,
  category_id: 5,
  description: '
Excelente vino tinto...
'
});

console.log('Product created with ID:', newProduct.data.id);

// Update stock
await api.updateStock(123, 75, 'set');
console.log('Stock updated successfully');

<?php

class BrainPricesAPI {
    private $baseUrl = 'https://www.brainprices.com/api/v1';
    private $token = null;
    
    public function __construct($token = null) {
        $this->token = $token;
    }
    
    private function request($endpoint, $method = 'GET', $data = null) {
        $ch = curl_init($this->baseUrl . $endpoint);
        
        $headers = ['Content-Type: application/json'];
        
        if ($this->token) {
            $headers[] = 'Authorization: Bearer ' . $this->token;
        }
        
        curl_setopt_array($ch, [
            CURLOPT_RETURNTRANSFER => true,
            CURLOPT_HTTPHEADER => $headers,
            CURLOPT_CUSTOMREQUEST => $method
        ]);
        
        if ($data && in_array($method, ['POST', 'PUT'])) {
            curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($data));
        }
        
        $response = curl_exec($ch);
        $httpCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);
        curl_close($ch);
        
        $result = json_decode($response, true);
        
        if ($httpCode >= 400) {
            throw new Exception($result['message'] ?? 'API Error');
        }
        
        return $result;
    }
    
    public function login($email, $password) {
        $data = $this->request('/auth/login', 'POST', [
            'email' => $email,
            'password' => $password
        ]);
        
        $this->token = $data['token'];
        return $data;
    }
    
    public function getProducts($filters = []) {
        $query = http_build_query($filters);
        return $this->request('/productos?' . $query);
    }
    
    public function createProduct($productData) {
        return $this->request('/productos', 'POST', $productData);
    }
    
    public function updateStock($id, $quantity, $operation = 'set') {
        return $this->request("/productos/{$id}/stock", 'PUT', [
            'stock_quantity' => $quantity,
            'operation' => $operation
        ]);
    }
}

<?php

$api = new BrainPricesAPI();

// Login
$loginData = $api->login('seller@example.com', 'password123');
echo "Logged in as: {$loginData['user']['email']}\n";

// Get products
$products = $api->getProducts([
    'category_id' => 5,
    'on_sale' => true,
    'page' => 1,
    'per_page' => 20
]);

echo "Found {$products['pagination']['total']} products\n";

foreach ($products['data'] as $product) {
    echo "- {$product['name']}: €{$product['price']}\n";
}

// Create product
$newProduct = $api->createProduct([
    'name' => 'Jamón Ibérico de Bellota',
    'sku' => 'JAM-IB-BELL-001',
    'price' => 89.99,
    'stock_quantity' => 25,
    'category_id' => 8
]);

echo "Product created with ID: {$newProduct['data']['id']}\n";

// Update stock
$api->updateStock(123, 50, 'set');
echo "Stock updated successfully\n";

import requests
from typing import Dict, Optional

class BrainPricesAPI:
    def __init__(self, base_url='https://www.brainprices.com/api/v1'):
        self.base_url = base_url
        self.token = None
        self.session = requests.Session()
    
    def _request(self, endpoint, method='GET', data=None, params=None):
        url = f"{self.base_url}{endpoint}"
        headers = {'Content-Type': 'application/json'}
        
        if self.token:
            headers['Authorization'] = f'Bearer {self.token}'
        
        response = self.session.request(
            method=method,
            url=url,
            json=data,
            params=params,
            headers=headers
        )
        
        response.raise_for_status()
        return response.json()
    
    def login(self, email: str, password: str) -> Dict:
        data = self._request('/auth/login', 'POST', {
            'email': email,
            'password': password
        })
        self.token = data['token']
        return data
    
    def get_products(self, **filters) -> Dict:
        return self._request('/productos', params=filters)
    
    def create_product(self, product_data: Dict) -> Dict:
        return self._request('/productos', 'POST', product_data)
    
    def update_stock(self, product_id: int, quantity: int, operation='set') -> Dict:
        return self._request(f'/productos/{product_id}/stock', 'PUT', {
            'stock_quantity': quantity,
            'operation': operation
        })

# Initialize API
api = BrainPricesAPI()

# Login
user = api.login('seller@example.com', 'password123')
print(f"Logged in as: {user['user']['email']}")

# Get products on sale
products = api.get_products(
    on_sale=True,
    category_id=5,
    page=1,
    per_page=20
)

print(f"Found {products['pagination']['total']} products on sale")

# Create new product
new_product = api.create_product({
    'name': 'Aceitunas Rellenas Premium',
    'sku': 'ACEIT-PREM-001',
    'price': 5.99,
    'stock_quantity': 200,
    'category_id': 4
})

print(f"Product created with ID: {new_product['data']['id']}")

# Update stock
api.update_stock(123, 75, 'set')
print("Stock updated successfully")

# Login and save token to variable
TOKEN=$(curl -s -X POST https://www.brainprices.com/api/v1/auth/login \
  -H "Content-Type: application/json" \
  -d '{"email":"seller@example.com","password":"password123"}' \
  | jq -r '.token')

echo "Token saved: $TOKEN"

# Get products on sale
curl -X GET "https://www.brainprices.com/api/v1/productos?on_sale=true&page=1" \
  -H "Authorization: Bearer $TOKEN" \
  | jq '.data[] | {name, price, stock_quantity}'

curl -X POST https://www.brainprices.com/api/v1/productos \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $TOKEN" \
  -d '{
    "name": "Queso Manchego Curado",
    "sku": "QUESO-MANCH-001",
    "price": 24.99,
    "stock_quantity": 40,
    "category_id": 6
  }' \
  | jq .

# Set stock to specific value
curl -X PUT https://www.brainprices.com/api/v1/productos/123/stock \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $TOKEN" \
  -d '{"stock_quantity": 75, "operation": "set"}' \
  | jq .

# Increment stock
curl -X PUT https://www.brainprices.com/api/v1/productos/123/stock \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $TOKEN" \
  -d '{"quantity": 10, "operation": "increment"}' \
  | jq .

async function importCatalogFromCSV(csvData) {
  const api = new BrainPricesAPI();
  await api.login('admin@example.com', 'password');
  
  const results = {
    imported: 0,
    updated: 0,
    errors: []
  };
  
  for (const product of csvData) {
    try {
      await api.createProduct({
        name: product.name,
        sku: product.sku,
        price: parseFloat(product.price),
        stock_quantity: parseInt(product.stock),
        category_id: parseInt(product.category_id),
        description: product.description
      });
      
      results.imported++;
      console.log(`✅ Imported: ${product.name}`);
      
    } catch (error) {
      results.errors.push({
        sku: product.sku,
        error: error.message
      });
      console.error(`❌ Error: ${product.sku}`);
    }
    
    // Respect rate limiting
    await new Promise(resolve => setTimeout(resolve, 500));
  }
  
  return results;
}

// Usage
const catalogData = [
  { name: 'Product 1', sku: 'PROD-001', price: '19.99', stock: '100', category_id: '5' },
  { name: 'Product 2', sku: 'PROD-002', price: '29.99', stock: '50', category_id: '5' }
];

const results = await importCatalogFromCSV(catalogData);
console.log(`Imported: ${results.imported}, Errors: ${results.errors.length}`);

class SalesDashboard {
  constructor(apiToken) {
    this.api = new BrainPricesAPI();
    this.api.token = apiToken;
    this.updateInterval = 60000; // 1 minute
  }

  async loadMetrics() {
    const today = new Date().toISOString().split('T')[0];
    
    // Get today's orders
    const orders = await this.api.request('/pedidos', {
      params: {
        from_date: today,
        to_date: today,
        per_page: 100
      }
    });
    
    // Calculate metrics
    const metrics = {
      total_orders: orders.pagination.total,
      total_sales: orders.data.reduce((sum, o) => sum + o.total, 0),
      pending_orders: orders.data.filter(o => o.status === 'pending').length,
      avg_order: 0
    };
    
    metrics.avg_order = metrics.total_sales / metrics.total_orders || 0;
    
    return metrics;
  }

  async displayDashboard() {
    const metrics = await this.loadMetrics();
    
    document.getElementById('total-sales').textContent = 
      `€${metrics.total_sales.toFixed(2)}`;
    document.getElementById('total-orders').textContent = 
      metrics.total_orders;
    document.getElementById('avg-order').textContent = 
      `€${metrics.avg_order.toFixed(2)}`;
    document.getElementById('pending-orders').textContent = 
      metrics.pending_orders;
  }

  startAutoUpdate() {
    this.displayDashboard();
    setInterval(() => this.displayDashboard(), this.updateInterval);
  }
}

// Usage
const dashboard = new SalesDashboard(authToken);
dashboard.startAutoUpdate();

async function processOrder(cartSessionId, customerData, paymentMethod) {
  const api = new BrainPricesAPI();
  
  // 1. Get cart contents
  const cart = await api.request(`/carrito/${cartSessionId}`);
  console.log('Cart total:', cart.data.totals.total);
  
  // 2. Validate coupon (if any)
  if (customerData.couponCode) {
    const coupon = await api.request(`/cupones/validar/${customerData.couponCode}`);
    if (coupon.data.is_valid) {
      console.log('Coupon applied:', coupon.data.value);
    }
  }
  
  // 3. Create order
  const orderData = {
    customer: {
      email: customerData.email,
      first_name: customerData.firstName,
      last_name: customerData.lastName,
      phone: customerData.phone
    },
    shipping_address: customerData.shippingAddress,
    billing_address: customerData.billingAddress,
    items: cart.data.items.map(item => ({
      product_id: item.product_id,
      quantity: item.quantity,
      price: item.price
    })),
    payment_method: paymentMethod,
    shipping_method: 'standard',
    coupon_code: customerData.couponCode || null
  };
  
  const order = await api.request('/pedidos', {
    method: 'POST',
    body: JSON.stringify(orderData)
  });
  
  console.log('Order created:', order.data.order_number);
  
  // 4. Process payment
  if (paymentMethod === 'credit_card') {
    const payment = await api.request('/pagos/procesar', {
      method: 'POST',
      body: JSON.stringify({
        order_id: order.data.order_id,
        payment_method: 'credit_card',
        card: customerData.cardData
      })
    });
    
    console.log('Payment processed:', payment.data.transaction_id);
  }
  
  // 5. Clear cart
  await api.request(`/carrito/${cartSessionId}/limpiar`, {
    method: 'DELETE'
  });
  
  return {
    order_id: order.data.order_id,
    order_number: order.data.order_number,
    total: order.data.total
  };
}

// Usage
const result = await processOrder('session123', {
  email: 'customer@example.com',
  firstName: 'Juan',
  lastName: 'Pérez',
  phone: '+34 600 123 456',
  shippingAddress: {
    address: 'Calle Mayor 123',
    city: 'Madrid',
    postal_code: '28001',
    country: 'ES'
  },
  billingAddress: {
    address: 'Calle Mayor 123',
    city: 'Madrid',
    postal_code: '28001',
    country: 'ES'
  },
  couponCode: 'DESCUENTO10',
  cardData: {
    number: '4111111111111111',
    exp_month: '12',
    exp_year: '2025',
    cvv: '123',
    holder_name: 'Juan Pérez'
  }
}, 'credit_card');

console.log('Order completed:', result.order_number);