# Step 1: Set your credentials (see /api/authentication for the signing helper)
export SALESOS_API_KEY="sk_live_YOUR_API_KEY"
export SALESOS_API_SECRET="YOUR_API_KEY_SECRET"
export SALESOS_URL="https://api.play2sell.com/functions/v1/default-integration"

# Step 2: Register your team (run once, or nightly to keep in sync)
curl -s -X POST "$SALESOS_URL" \
  -H "Authorization: P2S-SIGN-V1 API_KEY:TIMESTAMP:SIGNATURE" \
  -H "Content-Type: application/json" \
  -d '{
    "action": "sync_collaborators",
    "collaborators": [
      { "external_id": "emp-101", "name": "Maria Santos", "email": "maria@co.com", "team": "SP" },
      { "external_id": "emp-102", "name": "Joao Silva", "email": "joao@co.com", "team": "SP" },
      { "external_id": "emp-103", "name": "Ana Oliveira", "email": "ana@co.com", "team": "RJ" }
    ]
  }' | jq .

# Step 3: Send today's activities
curl -s -X POST "$SALESOS_URL" \
  -H "Authorization: P2S-SIGN-V1 API_KEY:TIMESTAMP:SIGNATURE" \
  -H "Content-Type: application/json" \
  -d '{
    "action": "sync_activities",
    "activities": [
      { "activity_code": "001", "external_id": "call-1001", "collaborator_email": "maria@co.com", "data": {"client": "Acme"} },
      { "activity_code": "001", "external_id": "call-1002", "collaborator_email": "maria@co.com", "data": {"client": "Beta"} },
      { "activity_code": "002", "external_id": "meet-2001", "collaborator_email": "joao@co.com", "data": {"client": "Gamma", "type": "video"} },
      { "activity_code": "003", "external_id": "prop-3001", "collaborator_email": "joao@co.com", "data": {"value": 50000} },
      { "activity_code": "001", "external_id": "call-1003", "collaborator_email": "ana@co.com", "data": {"client": "Delta"} }
    ]
  }' | jq .

const API_URL = 'https://api.play2sell.com/functions/v1/default-integration';
const API_KEY = process.env.SALESOS_API_KEY;

async function callSalesOS(payload, retries = 3) {
  for (let attempt = 1; attempt <= retries; attempt++) {
    const response = await fetch(API_URL, {
      method: 'POST',
      headers: {
        // P2S-SIGN-V1 — see signedRequest() in /api/authentication
        'Authorization': await signedHeader('POST', '/functions/v1/default-integration', payload),
        'Content-Type': 'application/json',
      },
      body: JSON.stringify(payload),
    });

    // Success
    if (response.ok) {
      return await response.json();
    }

    const error = await response.json();

    // Rate limited — wait and retry
    if (response.status === 429) {
      const waitSeconds = error.error?.retry_after || 60;
      console.log(`Rate limited. Waiting ${waitSeconds}s before retry...`);
      await new Promise(r => setTimeout(r, waitSeconds * 1000));
      continue;
    }

    // Server error — retry with backoff
    if (response.status >= 500) {
      const backoff = Math.pow(2, attempt) * 1000;
      console.log(`Server error (${response.status}). Retrying in ${backoff}ms...`);
      await new Promise(r => setTimeout(r, backoff));
      continue;
    }

    // Client error (400, 401, 403) — don't retry
    throw new Error(`SalesOS API error ${response.status}: ${error.error?.message}`);
  }

  throw new Error('Max retries exceeded');
}

// ---- Usage ----

// Sync your team
const teamResult = await callSalesOS({
  action: 'sync_collaborators',
  collaborators: [
    { external_id: 'emp-101', name: 'Maria Santos', email: 'maria@co.com', team: 'SP' },
    { external_id: 'emp-102', name: 'Joao Silva', email: 'joao@co.com', team: 'SP' },
  ],
});
console.log(`Team sync: ${teamResult.data.created} created, ${teamResult.data.existing} existing`);

// Send activities in batches of 1000
const allActivities = getActivitiesFromYourCRM(); // your function

for (let i = 0; i < allActivities.length; i += 1000) {
  const batch = allActivities.slice(i, i + 1000);
  const result = await callSalesOS({
    action: 'sync_activities',
    activities: batch.map(a => ({
      activity_code: a.type_code,        // "001", "002", etc.
      external_id: a.crm_event_id,       // unique ID from your CRM
      collaborator_email: a.agent_email,
      data: { client: a.client_name, notes: a.notes },
      occurred_at: a.timestamp,
    })),
  });
  console.log(`Batch ${i/1000 + 1}: ${result.data.processed} processed, ${result.data.duplicates} duplicates`);
}

import requests
import os
import logging
from datetime import datetime, timedelta
import time

logging.basicConfig(level=logging.INFO)
logger = logging.getLogger('salesos_sync')

API_URL = 'https://api.play2sell.com/functions/v1/default-integration'
API_KEY = os.environ['SALESOS_API_KEY']

HEADERS = {
    'Authorization': f'Bearer {API_KEY}',
    'Content-Type': 'application/json',
}

def call_salesos(payload: dict, max_retries: int = 3) -> dict:
    """Call SalesOS API with retry logic for rate limits and server errors."""
    for attempt in range(1, max_retries + 1):
        response = requests.post(API_URL, json=payload, headers=HEADERS)

        if response.ok:
            return response.json()

        error = response.json()
        error_code = error.get('error', {}).get('code', 'UNKNOWN')

        if response.status_code == 429:
            wait = error.get('error', {}).get('retry_after', 60)
            logger.warning(f'Rate limited. Waiting {wait}s...')
            time.sleep(wait)
            continue

        if response.status_code >= 500:
            backoff = 2 ** attempt
            logger.warning(f'Server error ({response.status_code}). Retry in {backoff}s...')
            time.sleep(backoff)
            continue

        raise Exception(f'SalesOS API error {response.status_code}: {error_code} - {error.get("error", {}).get("message")}')

    raise Exception('Max retries exceeded')


def sync_team(collaborators: list[dict]):
    """Sync collaborators to SalesOS. Safe to run multiple times."""
    result = call_salesos({
        'action': 'sync_collaborators',
        'collaborators': collaborators,
    })
    data = result['data']
    logger.info(f'Team sync: {data["created"]} created, {data["existing"]} existing, {len(data["errors"])} errors')
    if data['errors']:
        for err in data['errors']:
            logger.error(f'  - {err}')
    return data


def sync_activities(activities: list[dict]):
    """Send activities in batches of 1000."""
    total_processed = 0
    total_duplicates = 0
    total_skipped = 0

    for i in range(0, len(activities), 1000):
        batch = activities[i:i+1000]
        result = call_salesos({
            'action': 'sync_activities',
            'activities': batch,
        })
        data = result['data']
        total_processed += data['processed']
        total_duplicates += data['duplicates']
        total_skipped += data['skipped']
        logger.info(f'Batch {i//1000 + 1}: {data["processed"]} ok, {data["duplicates"]} dup, {data["skipped"]} skip')

    logger.info(f'Total: {total_processed} processed, {total_duplicates} duplicates, {total_skipped} skipped')
    return {'processed': total_processed, 'duplicates': total_duplicates, 'skipped': total_skipped}


# ---- Example: nightly sync job ----

if __name__ == '__main__':
    # 1. Sync team (idempotent)
    sync_team([
        {'external_id': 'emp-101', 'name': 'Maria Santos', 'email': 'maria@co.com', 'team': 'SP'},
        {'external_id': 'emp-102', 'name': 'Joao Silva', 'email': 'joao@co.com', 'team': 'SP'},
        {'external_id': 'emp-103', 'name': 'Ana Oliveira', 'email': 'ana@co.com', 'team': 'RJ'},
    ])

    # 2. Sync today's activities from your CRM
    today = datetime.now().strftime('%Y-%m-%d')
    crm_events = fetch_crm_events_for_date(today)  # your function

    activities = [{
        'activity_code': evt['type_code'],
        'external_id': evt['crm_id'],
        'collaborator_email': evt['agent_email'],
        'data': {'client': evt['client'], 'notes': evt.get('notes', '')},
        'occurred_at': evt['timestamp'],
    } for evt in crm_events]

    sync_activities(activities)

<?php

$api_url        = 'https://api.play2sell.com/functions/v1/default-integration';
$api_key        = getenv('SALESOS_API_KEY');
$api_key_secret = getenv('SALESOS_API_SECRET');

// Build the P2S-SIGN-V1 Authorization header. Note: PHP's hash_hmac()
// takes (data, key) — opposite of Node/Python — so the args look reversed.
function p2sSignedHeader(string $method, string $path, string $body): string {
    global $api_key, $api_key_secret;
    $ts          = (string) time();
    $payloadHash = hash('sha256', $body);
    $k1  = hash_hmac('sha256', $api_key,     $api_key_secret, true);
    $k2  = hash_hmac('sha256', $ts,          $k1,             true);
    $k3  = hash_hmac('sha256', $method,      $k2,             true);
    $k4  = hash_hmac('sha256', $path,        $k3,             true);
    $sig = hash_hmac('sha256', $payloadHash, $k4);  // hex
    return "P2S-SIGN-V1 {$api_key}:{$ts}:{$sig}";
}

function callSalesOS(array $payload): array {
    global $api_url;
    $body = json_encode($payload);
    $path = parse_url($api_url, PHP_URL_PATH);

    $ch = curl_init($api_url);
    curl_setopt_array($ch, [
        CURLOPT_POST => true,
        CURLOPT_RETURNTRANSFER => true,
        CURLOPT_HTTPHEADER => [
            'Authorization: ' . p2sSignedHeader('POST', $path, $body),
            'Content-Type: application/json',
        ],
        CURLOPT_POSTFIELDS => $body,
        CURLOPT_TIMEOUT => 30,
    ]);

    $response = curl_exec($ch);
    $httpCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);
    curl_close($ch);

    $result = json_decode($response, true);

    if ($httpCode !== 200) {
        $errorMsg = $result['error']['message'] ?? 'Unknown error';
        throw new Exception("SalesOS API error ({$httpCode}): {$errorMsg}");
    }

    return $result;
}

// Sync a collaborator
$result = callSalesOS([
    'action' => 'sync_collaborators',
    'collaborators' => [[
        'external_id' => 'wp-user-42',
        'name' => 'Carlos Lima',
        'email' => 'carlos@company.com',
        'team' => 'Inside Sales',
    ]],
]);
echo "Created: {$result['data']['created']}\n";

// Send an activity
$result = callSalesOS([
    'action' => 'sync_activities',
    'activities' => [[
        'activity_code' => '001',
        'external_id' => 'wp-form-' . uniqid(),
        'collaborator_email' => 'carlos@company.com',
        'data' => ['source' => 'wordpress_form', 'page' => '/contact'],
        'occurred_at' => date('c'),
    ]],
]);
echo "Processed: {$result['data']['processed']}\n";