Update Template

PUT https://api.pictory.ai/pictoryapis/v1/templates/{templateId}

import requests

def update_template_text(template_id, new_scenes, api_key):
    """
    Update template with new scene content
    """
    url = f"https://api.pictory.ai/pictoryapis/v1/templates/{template_id}"
    headers = {
        "Authorization": api_key,
        "Content-Type": "application/json"
    }

    payload = {"scenes": new_scenes}

    response = requests.put(url, headers=headers, json=payload)
    result = response.json()

    if result.get('success'):
        print(f"Template updated successfully")
        return True
    else:
        print(f"Update failed: {result.get('message')}")
        return False

# Example usage
new_scenes = [
    {"text": "Updated introduction", "duration": 5},
    {"text": "Updated main content", "duration": 8},
    {"text": "Updated conclusion", "duration": 4}
]

update_template_text("YOUR_TEMPLATE_ID", new_scenes, "YOUR_API_KEY")

async function addSceneToTemplate(templateId, newScene, apiKey) {
  // First, retrieve current template structure
  // Note: You may need to maintain template data separately
  // as there's no GET endpoint for individual templates

  const currentScenes = [
    // ... existing scenes
  ];

  // Add new scene
  currentScenes.push(newScene);

  const url = `https://api.pictory.ai/pictoryapis/v1/templates/${templateId}`;

  const response = await fetch(url, {
    method: 'PUT',
    headers: {
      'Authorization': `${apiKey}`,
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({ scenes: currentScenes })
  });

  const result = await response.json();

  if (result.success) {
    console.log('Scene added successfully');
    return true;
  } else {
    console.error('Failed to add scene:', result.message);
    return false;
  }
}

// Example usage
const newScene = {
  text: 'New closing scene',
  duration: 5
};

await addSceneToTemplate('YOUR_TEMPLATE_ID', newScene, 'YOUR_API_KEY');

import requests
from typing import List, Dict

def batch_update_templates(
    template_ids: List[str],
    scene_updates: Dict,
    api_key: str
):
    """
    Update multiple templates with the same scene modifications
    """
    results = {
        'success': [],
        'failed': []
    }

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

    for template_id in template_ids:
        url = f"https://api.pictory.ai/pictoryapis/v1/templates/{template_id}"

        try:
            response = requests.put(
                url,
                headers=headers,
                json=scene_updates
            )
            result = response.json()

            if result.get('success'):
                results['success'].append(template_id)
                print(f"✓ Updated template: {template_id}")
            else:
                results['failed'].append({
                    'id': template_id,
                    'error': result.get('message')
                })
                print(f"✗ Failed template: {template_id}")

        except Exception as e:
            results['failed'].append({
                'id': template_id,
                'error': str(e)
            })
            print(f"✗ Error updating {template_id}: {e}")

    print(f"\nBatch update complete:")
    print(f"  Success: {len(results['success'])}")
    print(f"  Failed: {len(results['failed'])}")

    return results

# Example usage
template_ids = [
    "template_id_1",
    "template_id_2",
    "template_id_3"
]

scene_updates = {
    "scenes": [
        {"text": "Standardized intro", "duration": 5},
        {"text": "Main content placeholder", "duration": 10}
    ]
}

results = batch_update_templates(template_ids, scene_updates, "YOUR_API_KEY")

import requests

def validate_scenes(scenes):
    """
    Validate scene structure before updating
    """
    if not isinstance(scenes, list):
        return False, "Scenes must be an array"

    if len(scenes) == 0:
        return False, "Scenes array cannot be empty"

    for i, scene in enumerate(scenes):
        if not isinstance(scene, dict):
            return False, f"Scene {i} must be an object"

        # Add more validation as needed
        if 'text' in scene and not isinstance(scene['text'], str):
            return False, f"Scene {i} text must be a string"

        if 'duration' in scene and not isinstance(scene['duration'], (int, float)):
            return False, f"Scene {i} duration must be a number"

    return True, "Validation passed"

def safe_update_template(template_id, scenes, api_key):
    """
    Update template with validation
    """
    # Validate scenes
    is_valid, message = validate_scenes(scenes)

    if not is_valid:
        print(f"Validation error: {message}")
        return False

    # Update template
    url = f"https://api.pictory.ai/pictoryapis/v1/templates/{template_id}"
    headers = {
        "Authorization": api_key,
        "Content-Type": "application/json"
    }

    try:
        response = requests.put(
            url,
            headers=headers,
            json={"scenes": scenes}
        )
        result = response.json()

        if result.get('success'):
            print("Template updated successfully")
            return True
        else:
            print(f"Update failed: {result.get('message')}")
            return False

    except Exception as e:
        print(f"Error: {e}")
        return False

# Example usage
scenes = [
    {"text": "Validated scene 1", "duration": 5},
    {"text": "Validated scene 2", "duration": 8}
]

safe_update_template("YOUR_TEMPLATE_ID", scenes, "YOUR_API_KEY")

class TemplateManager {
  constructor(apiKey) {
    this.apiKey = apiKey;
    this.backups = new Map();
  }

  async backupTemplate(templateId, scenes) {
    // Store backup locally
    this.backups.set(templateId, {
      scenes: JSON.parse(JSON.stringify(scenes)),
      timestamp: new Date().toISOString()
    });

    console.log(`Backup created for template ${templateId}`);
  }

  async updateTemplate(templateId, newScenes) {
    const url = `https://api.pictory.ai/pictoryapis/v1/templates/${templateId}`;

    try {
      const response = await fetch(url, {
        method: 'PUT',
        headers: {
          'Authorization': this.apiKey,
          'Content-Type': 'application/json'
        },
        body: JSON.stringify({ scenes: newScenes })
      });

      const result = await response.json();

      if (result.success) {
        console.log('Template updated successfully');
        return { success: true, result };
      } else {
        console.error('Update failed:', result.message);
        return { success: false, error: result.message };
      }
    } catch (error) {
      console.error('Error updating template:', error);
      return { success: false, error: error.message };
    }
  }

  async rollbackTemplate(templateId) {
    const backup = this.backups.get(templateId);

    if (!backup) {
      console.error('No backup found for this template');
      return false;
    }

    console.log(`Rolling back to backup from ${backup.timestamp}`);
    return await this.updateTemplate(templateId, backup.scenes);
  }
}

// Example usage
const manager = new TemplateManager('YOUR_API_KEY');

// Backup current state
const currentScenes = [/* current scenes */];
await manager.backupTemplate('YOUR_TEMPLATE_ID', currentScenes);

// Update template
const newScenes = [/* new scenes */];
const result = await manager.updateTemplate('YOUR_TEMPLATE_ID', newScenes);

// Rollback if needed
if (!result.success) {
  await manager.rollbackTemplate('YOUR_TEMPLATE_ID');
}