Delete Template

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

import requests

def delete_template_with_confirmation(template_id, api_key):
    """
    Delete a template after confirming with the user
    """
    # First, get template details
    get_url = f"https://api.pictory.ai/pictoryapis/v1/templates/{template_id}"
    headers = {"Authorization": api_key}

    template_response = requests.get(get_url, headers=headers)

    if template_response.status_code != 200:
        print("Template not found")
        return False

    template = template_response.json()
    template_name = template.get('name', 'Unknown')

    # Confirm deletion
    print(f"Are you sure you want to delete template '{template_name}'? (yes/no)")
    confirmation = input().strip().lower()

    if confirmation != 'yes':
        print("Deletion cancelled")
        return False

    # Delete template
    delete_url = f"https://api.pictory.ai/pictoryapis/v1/templates/{template_id}"
    delete_response = requests.delete(delete_url, headers=headers)

    if delete_response.status_code in [200, 204]:
        print(f"Template '{template_name}' deleted successfully")
        return True
    else:
        try:
            result = delete_response.json()
            print(f"Failed to delete template: {result.get('message')}")
        except:
            print(f"Failed to delete template: HTTP {delete_response.status_code}")
        return False

# Example usage
delete_template_with_confirmation("YOUR_TEMPLATE_ID", "YOUR_API_KEY")

import requests

def delete_deprecated_templates(api_key, dry_run=True):
    """
    Delete all deprecated templates
    """
    headers = {"Authorization": api_key}

    # Get all templates
    list_url = "https://api.pictory.ai/pictoryapis/v1/templates"
    response = requests.get(list_url, headers=headers)
    templates = response.json().get('items', [])

    # Find deprecated templates
    deprecated_templates = [
        t for t in templates
        if t.get('depricated') or t.get('deprecated')
    ]

    print(f"Found {len(deprecated_templates)} deprecated templates")

    if dry_run:
        print("DRY RUN - Templates that would be deleted:")
        for template in deprecated_templates:
            print(f"  - {template.get('name', 'Unknown')} (ID: {template['templateId']})")
        return

    # Delete deprecated templates
    deleted_count = 0
    for template in deprecated_templates:
        delete_url = f"https://api.pictory.ai/pictoryapis/v1/templates/{template['templateId']}"
        delete_response = requests.delete(delete_url, headers=headers)

        if delete_response.status_code in [200, 204]:
            print(f"✓ Deleted: {template.get('name', 'Unknown')}")
            deleted_count += 1
        else:
            print(f"✗ Failed: {template.get('name', 'Unknown')}")

    print(f"\nDeleted {deleted_count} out of {len(deprecated_templates)} deprecated templates")

# Example usage - dry run first
delete_deprecated_templates("YOUR_API_KEY", dry_run=True)

# Then execute for real
# delete_deprecated_templates("YOUR_API_KEY", dry_run=False)

async function deleteTemplatesByLanguage(language, apiKey, confirmAll = false) {
  const headers = { 'Authorization': `${apiKey}` };

  // Get all templates
  const listResponse = await fetch(
    'https://api.pictory.ai/pictoryapis/v1/templates',
    { headers }
  );
  const data = await listResponse.json();

  // Filter by language
  const matchingTemplates = data.items.filter(t => t.language === language);

  console.log(`Found ${matchingTemplates.length} templates with language: ${language}`);

  if (!confirmAll) {
    console.log('Set confirmAll=true to delete these templates');
    matchingTemplates.forEach(t => {
      console.log(`  - ${t.name} (${t.templateId})`);
    });
    return matchingTemplates;
  }

  // Delete matching templates
  const results = {
    deleted: [],
    failed: []
  };

  for (const template of matchingTemplates) {
    const deleteResponse = await fetch(
      `https://api.pictory.ai/pictoryapis/v1/templates/${template.templateId}`,
      { method: 'DELETE', headers }
    );

    if (deleteResponse.status === 200 || deleteResponse.status === 204) {
      results.deleted.push(template.name);
      console.log(`✓ Deleted: ${template.name}`);
    } else {
      results.failed.push(template.name);
      console.log(`✗ Failed: ${template.name}`);
    }
  }

  console.log(`\nDeleted: ${results.deleted.length}, Failed: ${results.failed.length}`);
  return results;
}

// Example usage
const results = await deleteTemplatesByLanguage('en', 'YOUR_API_KEY', false);

import requests
import json
import os
from datetime import datetime

def backup_and_delete_template(template_id, api_key, backup_dir="./template_backups"):
    """
    Backup template configuration before deleting
    """
    headers = {"Authorization": api_key}

    # Get template details
    get_url = f"https://api.pictory.ai/pictoryapis/v1/templates/{template_id}"
    response = requests.get(get_url, headers=headers)

    if response.status_code != 200:
        print("Template not found")
        return False

    template = response.json()
    template_name = template.get('name', template_id)

    # Create backup directory
    os.makedirs(backup_dir, exist_ok=True)

    # Save template configuration
    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
    filename = f"{template_name.replace(' ', '_')}_{template_id}_{timestamp}.json"
    filepath = os.path.join(backup_dir, filename)

    backup_data = {
        "deletedDate": datetime.now().isoformat(),
        "templateData": template
    }

    with open(filepath, 'w') as f:
        json.dump(backup_data, f, indent=2)

    print(f"Backup saved to: {filepath}")

    # Delete template
    print(f"Deleting template...")
    delete_url = f"https://api.pictory.ai/pictoryapis/v1/templates/{template_id}"
    delete_response = requests.delete(delete_url, headers=headers)

    if delete_response.status_code in [200, 204]:
        print(f"Template '{template_name}' deleted successfully")
        return True
    else:
        print(f"Failed to delete template")
        return False

# Example usage
backup_and_delete_template("YOUR_TEMPLATE_ID", "YOUR_API_KEY")

async function safeDeleteTemplate(templateId, apiKey, maxRetries = 3) {
  const headers = { 'Authorization': `${apiKey}` };

  for (let attempt = 1; attempt <= maxRetries; attempt++) {
    try {
      console.log(`Attempt ${attempt} to delete template ${templateId}...`);

      const response = await fetch(
        `https://api.pictory.ai/pictoryapis/v1/templates/${templateId}`,
        { method: 'DELETE', headers }
      );

      if (response.status === 401) {
        throw new Error('Unauthorized - check your API key');
      }

      if (response.status === 404) {
        console.log('Template already deleted or does not exist');
        return { success: true, message: 'Template not found' };
      }

      if (response.status === 200 || response.status === 204) {
        console.log('Template deleted successfully');
        return { success: true };
      }

      const result = await response.json().catch(() => ({}));

      if (attempt < maxRetries) {
        console.log(`Deletion failed, retrying in ${attempt * 2} seconds...`);
        await new Promise(resolve => setTimeout(resolve, attempt * 2000));
      }
    } catch (error) {
      console.error(`Error on attempt ${attempt}:`, error.message);

      if (attempt === maxRetries) {
        throw error;
      }

      await new Promise(resolve => setTimeout(resolve, attempt * 2000));
    }
  }

  throw new Error(`Failed to delete template after ${maxRetries} attempts`);
}

// Example usage
try {
  const result = await safeDeleteTemplate('YOUR_TEMPLATE_ID', 'YOUR_API_KEY');
  console.log('Result:', result);
} catch (error) {
  console.error('Final error:', error.message);
}

import requests

def delete_unpublished_templates(api_key, confirm=False):
    """
    Delete all unpublished (draft) templates
    """
    headers = {"Authorization": api_key}

    # Get all templates
    list_url = "https://api.pictory.ai/pictoryapis/v1/templates"
    response = requests.get(list_url, headers=headers)
    templates = response.json().get('items', [])

    # Find unpublished templates
    unpublished = [t for t in templates if not t.get('published')]

    print(f"Found {len(unpublished)} unpublished templates")

    if not unpublished:
        print("No unpublished templates to delete")
        return

    # List templates
    for i, template in enumerate(unpublished, 1):
        print(f"{i}. {template.get('name', 'Unknown')} (ID: {template['templateId']})")

    if not confirm:
        print("\nSet confirm=True to delete these templates")
        return

    # Delete templates
    deleted_count = 0
    for template in unpublished:
        delete_url = f"https://api.pictory.ai/pictoryapis/v1/templates/{template['templateId']}"
        delete_response = requests.delete(delete_url, headers=headers)

        if delete_response.status_code in [200, 204]:
            print(f"✓ Deleted: {template.get('name', 'Unknown')}")
            deleted_count += 1
        else:
            print(f"✗ Failed: {template.get('name', 'Unknown')}")

    print(f"\nDeleted {deleted_count} out of {len(unpublished)} unpublished templates")

# Example usage
delete_unpublished_templates("YOUR_API_KEY", confirm=False)