Update Vimeo Connection

# Update a Vimeo connection
# Replace YOUR_API_KEY with your actual API key
# Replace CONNECTION_ID with the actual connection ID

# Partial update - update only description
curl --request PUT \
  --url https://api.pictory.ai/pictoryapis/v1/vimeo-connections/CONNECTION_ID \
  --header 'Authorization: YOUR_API_KEY' \
  --header 'Content-Type: application/json' \
  --data '{
    "description": "Updated description",
    "version": 1
  }'

# Full update - update multiple fields
curl --request PUT \
  --url https://api.pictory.ai/pictoryapis/v1/vimeo-connections/CONNECTION_ID \
  --header 'Authorization: YOUR_API_KEY' \
  --header 'Content-Type: application/json' \
  --data '{
    "name": "Updated Connection Name",
    "description": "Updated description for marketing videos",
    "enabled": false,
    "clientIdentifier": "new_client_id_456",
    "clientSecret": "new_secret_xyz789",
    "accessToken": "new_token_1234567890",
    "version": 1
  }' | python -m json.tool

// Replace 'YOUR_API_KEY' with your actual API key

const updateVimeoConnection = async (apiKey, connectionId, updates) => {
  const response = await fetch(`https://api.pictory.ai/pictoryapis/v1/vimeo-connections/${connectionId}`, {
    method: 'PUT',
    headers: {
      'Authorization': `${apiKey}`,
      'Content-Type': 'application/json'
    },
    body: JSON.stringify(updates)
  });

  if (!response.ok) {
    const error = await response.json();
    throw new Error(`Failed: ${error.message}`);
  }

  return await response.json();
};

// Usage - Partial update
try {
  const connectionId = '20251222155613307xv0nodhitf9cd0f';

  // First, get current connection to retrieve version
  const getResponse = await fetch(`https://api.pictory.ai/pictoryapis/v1/vimeo-connections/${connectionId}`, {
    headers: { 'Authorization': 'YOUR_API_KEY' }
  });
  const currentConnection = await getResponse.json();

  // Partial update - only update description
  const partialUpdate = await updateVimeoConnection('YOUR_API_KEY', connectionId, {
    description: 'Updated description',
    version: currentConnection.version
  });
  console.log('Partial Update Result:', partialUpdate);

  // Full update - update multiple fields
  const fullUpdate = await updateVimeoConnection('YOUR_API_KEY', connectionId, {
    name: 'Updated Connection Name',
    description: 'Updated description for marketing videos',
    enabled: false,
    clientIdentifier: 'new_client_id_456',
    clientSecret: 'new_secret_xyz789',
    accessToken: 'new_token_1234567890',
    version: partialUpdate.version  // Use updated version
  });
  console.log('Full Update Result:', fullUpdate);
  console.log('New Version:', fullUpdate.version);
} catch (error) {
  console.error('Error:', error.message);
}

# Replace 'YOUR_API_KEY' with your actual API key

import requests

def update_vimeo_connection(api_key, connection_id, updates):
    """Update a Vimeo connection"""
    url = f"https://api.pictory.ai/pictoryapis/v1/vimeo-connections/{connection_id}"

    headers = {
        "Authorization": api_key,
        "Content-Type": "application/json"
    }

    response = requests.put(url, headers=headers, json=updates)
    response.raise_for_status()

    return response.json()

# Usage
try:
    connection_id = "20251222155613307xv0nodhitf9cd0f"

    # First, get current connection to retrieve version
    get_url = f"https://api.pictory.ai/pictoryapis/v1/vimeo-connections/{connection_id}"
    get_response = requests.get(get_url, headers={"Authorization": "YOUR_API_KEY"})
    current_connection = get_response.json()

    # Partial update - only update description
    partial_update = update_vimeo_connection("YOUR_API_KEY", connection_id, {
        "description": "Updated description",
        "version": current_connection["version"]
    })
    print(f"Partial Update Result: {partial_update}")

    # Full update - update multiple fields
    full_update = update_vimeo_connection("YOUR_API_KEY", connection_id, {
        "name": "Updated Connection Name",
        "description": "Updated description for marketing videos",
        "enabled": False,
        "clientIdentifier": "new_client_id_456",
        "clientSecret": "new_secret_xyz789",
        "accessToken": "new_token_1234567890",
        "version": partial_update["version"]  # Use updated version
    })
    print(f"Full Update Result: {full_update}")
    print(f"New Version: {full_update['version']}")
except requests.exceptions.HTTPError as e:
    error = e.response.json()
    print(f"Error: {error.get('message', 'Request failed')}")

<?php
// Replace 'YOUR_API_KEY' with your actual API key

function updateVimeoConnection($apiKey, $connectionId, $updates) {
    $url = "https://api.pictory.ai/pictoryapis/v1/vimeo-connections/{$connectionId}";

    $ch = curl_init($url);
    curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
    curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'PUT');
    curl_setopt($ch, CURLOPT_HTTPHEADER, [
        'Authorization: ' . $apiKey,
        'Content-Type: application/json'
    ]);
    curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($updates));

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

    if ($httpCode !== 200) {
        $error = json_decode($response, true);
        throw new Exception($error['message'] ?? 'Request failed');
    }

    return json_decode($response, true);
}

// Usage
try {
    $connectionId = '20251222155613307xv0nodhitf9cd0f';

    // First, get current connection to retrieve version
    $getUrl = "https://api.pictory.ai/pictoryapis/v1/vimeo-connections/{$connectionId}";
    $ch = curl_init($getUrl);
    curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
    curl_setopt($ch, CURLOPT_HTTPHEADER, ['Authorization: YOUR_API_KEY']);
    $currentConnection = json_decode(curl_exec($ch), true);
    curl_close($ch);

    // Partial update - only update description
    $partialUpdate = updateVimeoConnection('YOUR_API_KEY', $connectionId, [
        'description' => 'Updated description',
        'version' => $currentConnection['version']
    ]);
    echo "Partial Update Result:\n";
    print_r($partialUpdate);

    // Full update - update multiple fields
    $fullUpdate = updateVimeoConnection('YOUR_API_KEY', $connectionId, [
        'name' => 'Updated Connection Name',
        'description' => 'Updated description for marketing videos',
        'enabled' => false,
        'clientIdentifier' => 'new_client_id_456',
        'clientSecret' => 'new_secret_xyz789',
        'accessToken' => 'new_token_1234567890',
        'version' => $partialUpdate['version']  // Use updated version
    ]);
    echo "Full Update Result:\n";
    print_r($fullUpdate);
    echo "New Version: " . $fullUpdate['version'] . "\n";
} catch (Exception $e) {
    echo "Error: " . $e->getMessage() . "\n";
}
?>

// Replace "YOUR_API_KEY" with your actual API key

package main

import (
    "bytes"
    "encoding/json"
    "fmt"
    "io"
    "net/http"
)

type VimeoConnectionUpdate struct {
    Name             string `json:"name,omitempty"`
    Description      string `json:"description,omitempty"`
    Enabled          *bool  `json:"enabled,omitempty"`
    ClientIdentifier string `json:"clientIdentifier,omitempty"`
    ClientSecret     string `json:"clientSecret,omitempty"`
    AccessToken      string `json:"accessToken,omitempty"`
    Version          int    `json:"version"`
}

type VimeoConnectionResponse struct {
    ConnectionID     string `json:"connectionId"`
    Name             string `json:"name"`
    Description      string `json:"description"`
    ClientIdentifier string `json:"clientIdentifier"`
    Type             string `json:"type"`
    Enabled          bool   `json:"enabled"`
    CreatedDate      string `json:"createdDate"`
    UpdatedDate      string `json:"updatedDate"`
    Version          int    `json:"version"`
}

func updateVimeoConnection(apiKey string, connectionId string, updates VimeoConnectionUpdate) (*VimeoConnectionResponse, error) {
    url := fmt.Sprintf("https://api.pictory.ai/pictoryapis/v1/vimeo-connections/%s", connectionId)

    jsonData, err := json.Marshal(updates)
    if err != nil {
        return nil, err
    }

    req, err := http.NewRequest("PUT", url, bytes.NewBuffer(jsonData))
    if err != nil {
        return nil, err
    }

    req.Header.Set("Authorization", apiKey)
    req.Header.Set("Content-Type", "application/json")

    client := &http.Client{}
    resp, err := client.Do(req)
    if err != nil {
        return nil, err
    }
    defer resp.Body.Close()

    body, err := io.ReadAll(resp.Body)
    if err != nil {
        return nil, err
    }

    if resp.StatusCode != http.StatusOK {
        return nil, fmt.Errorf("request failed (status %d): %s", resp.StatusCode, string(body))
    }

    var result VimeoConnectionResponse
    if err := json.Unmarshal(body, &result); err != nil {
        return nil, err
    }

    return &result, nil
}

// Usage
func main() {
    connectionId := "20251222155613307xv0nodhitf9cd0f"

    // First, get current connection to retrieve version
    // (Assuming a getCurrentConnection function exists)
    currentVersion := 1 // Replace with actual version from GET request

    // Partial update - only update description
    partialUpdate := VimeoConnectionUpdate{
        Description: "Updated description",
        Version:     currentVersion,
    }

    result, err := updateVimeoConnection("YOUR_API_KEY", connectionId, partialUpdate)
    if err != nil {
        panic(err)
    }

    fmt.Printf("Partial Update Result: %+v\n", result)
    fmt.Printf("New Version: %d\n", result.Version)

    // Full update - update multiple fields
    enabled := false
    fullUpdate := VimeoConnectionUpdate{
        Name:             "Updated Connection Name",
        Description:      "Updated description for marketing videos",
        Enabled:          &enabled,
        ClientIdentifier: "new_client_id_456",
        ClientSecret:     "new_secret_xyz789",
        AccessToken:      "new_token_1234567890",
        Version:          result.Version, // Use updated version
    }

    fullResult, err := updateVimeoConnection("YOUR_API_KEY", connectionId, fullUpdate)
    if err != nil {
        panic(err)
    }

    fmt.Printf("Full Update Result: %+v\n", fullResult)
    fmt.Printf("New Version: %d\n", fullResult.Version)
}