Delete Document

curl -X DELETE "https://api.docurift.com/v1/documents/doc_abc123xyz456" \
-H "X-API-Key: frc_your_api_key_here"

import requests
import os

API_KEY = os.getenv('DOCURIFT_API_KEY')
API_URL = 'https://api.docurift.com/v1'

def delete_document(document_id):
  """Delete a document permanently."""
  headers = {
      'X-API-Key': API_KEY
  }

  response = requests.delete(
      f'{API_URL}/documents/{document_id}',
      headers=headers
  )

  response.raise_for_status()
  return response.json()

# Example usage
result = delete_document('doc_abc123xyz456')

if result['success']:
  print(f"Document deleted successfully")
  print(f"Deleted at: {result['data']['deletedAt']}")

const API_KEY = process.env.DOCURIFT_API_KEY;
const API_URL = 'https://api.docurift.com/v1';

async function deleteDocument(documentId) {
const response = await fetch(`${API_URL}/documents/${documentId}`, {
  method: 'DELETE',
  headers: {
    'X-API-Key': API_KEY
  }
});

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

return response.json();
}

// Example usage
try {
const result = await deleteDocument('doc_abc123xyz456');
console.log('Document deleted:', result.data.id);
console.log('Deleted at:', result.data.deletedAt);
} catch (error) {
console.error('Failed to delete:', error.message);
}

import requests
import os
from concurrent.futures import ThreadPoolExecutor, as_completed

API_KEY = os.getenv('DOCURIFT_API_KEY')
API_URL = 'https://api.docurift.com/v1'

def delete_document(document_id):
  """Delete a single document."""
  headers = {'X-API-Key': API_KEY}
  response = requests.delete(f'{API_URL}/documents/{document_id}', headers=headers)
  response.raise_for_status()
  return document_id

def batch_delete_documents(document_ids, max_workers=5):
  """
  Delete multiple documents in parallel.

  Args:
      document_ids: List of document IDs to delete
      max_workers: Maximum concurrent deletions

  Returns:
      dict with successful and failed deletions
  """
  results = {'deleted': [], 'failed': []}

  with ThreadPoolExecutor(max_workers=max_workers) as executor:
      future_to_id = {
          executor.submit(delete_document, doc_id): doc_id
          for doc_id in document_ids
      }

      for future in as_completed(future_to_id):
          doc_id = future_to_id[future]
          try:
              future.result()
              results['deleted'].append(doc_id)
          except Exception as e:
              results['failed'].append({'id': doc_id, 'error': str(e)})

  return results

# Example: Delete all failed documents
def delete_failed_documents():
  """Delete all documents with failed status."""
  headers = {'X-API-Key': API_KEY}

  # Get all failed documents
  response = requests.get(
      f'{API_URL}/documents?status=failed&limit=100',
      headers=headers
  )
  response.raise_for_status()

  failed_docs = response.json()['data']['documents']
  doc_ids = [doc['id'] for doc in failed_docs]

  if doc_ids:
      results = batch_delete_documents(doc_ids)
      print(f"Deleted {len(results['deleted'])} documents")
      if results['failed']:
          print(f"Failed to delete {len(results['failed'])} documents")
  else:
      print("No failed documents to delete")

{
"success": true,
"data": {
  "id": "doc_abc123xyz456",
  "deleted": true,
  "deletedAt": "2024-01-26T12:00:00Z"
},
"message": "Document and all associated data have been permanently deleted"
}

{
"success": false,
"error": {
  "code": "INVALID_API_KEY",
  "message": "Invalid API key"
}
}

{
"success": false,
"error": {
  "code": "FORBIDDEN",
  "message": "You do not have permission to delete this document"
}
}

{
"success": false,
"error": {
  "code": "DOCUMENT_NOT_FOUND",
  "message": "Document with ID 'doc_abc123xyz456' not found"
}
}

{
"success": false,
"error": {
  "code": "DOCUMENT_PROCESSING",
  "message": "Cannot delete document while it is being processed. Wait for processing to complete or cancel first."
}
}

def safe_delete_document(document_id, confirm=True):
  """Delete with confirmation."""
  # First, get the document to verify
  headers = {'X-API-Key': API_KEY}
  response = requests.get(f'{API_URL}/documents/{document_id}', headers=headers)

  if response.status_code == 404:
      print(f"Document {document_id} not found")
      return None

  doc = response.json()['data']

  if confirm:
      print(f"About to delete:")
      print(f"  ID: {doc['id']}")
      print(f"  File: {doc['fileName']}")
      print(f"  Type: {doc['documentType']}")
      print(f"  Status: {doc['status']}")

      confirmation = input("Type 'DELETE' to confirm: ")
      if confirmation != 'DELETE':
          print("Deletion cancelled")
          return None

  return delete_document(document_id)

// Store deleted document IDs with metadata before deletion
const deletedDocuments = new Map();
const RETENTION_PERIOD = 30 * 24 * 60 * 60 * 1000; // 30 days

async function softDelete(documentId) {
// Get document data first
const doc = await getDocument(documentId);

// Store in soft delete registry
deletedDocuments.set(documentId, {
  metadata: doc.data,
  deletedAt: new Date(),
  expiresAt: new Date(Date.now() + RETENTION_PERIOD)
});

// Actually delete from DocuRift
await deleteDocument(documentId);

console.log(`Document ${documentId} soft-deleted. Metadata retained for 30 days.`);
}

// Clean up expired soft-deleted records
function cleanupExpired() {
const now = Date.now();
for (const [id, data] of deletedDocuments) {
  if (data.expiresAt < now) {
    deletedDocuments.delete(id);
  }
}
}

import logging
from datetime import datetime

# Configure audit logger
audit_logger = logging.getLogger('docurift.audit')
audit_logger.setLevel(logging.INFO)

def audited_delete(document_id, user_id, reason=None):
  """Delete with audit logging."""
  # Log before deletion
  audit_logger.info(
      f"DELETE_INITIATED | doc_id={document_id} | user={user_id} | reason={reason}"
  )

  try:
      result = delete_document(document_id)

      audit_logger.info(
          f"DELETE_SUCCESS | doc_id={document_id} | user={user_id} | "
          f"deleted_at={result['data']['deletedAt']}"
      )

      return result

  except Exception as e:
      audit_logger.error(
          f"DELETE_FAILED | doc_id={document_id} | user={user_id} | error={str(e)}"
      )
      raise

from datetime import datetime, timedelta

def cleanup_old_documents(retention_days=90, dry_run=True):
  """
  Delete documents older than retention period.

  Args:
      retention_days: Number of days to retain documents
      dry_run: If True, only report what would be deleted
  """
  cutoff_date = datetime.utcnow() - timedelta(days=retention_days)

  # Get old documents
  result = list_documents(
      end_date=cutoff_date.isoformat() + 'Z',
      status='completed',
      limit=100
  )

  documents = result['data']['documents']

  if dry_run:
      print(f"[DRY RUN] Would delete {len(documents)} documents:")
      for doc in documents:
          print(f"  - {doc['id']}: {doc['fileName']} ({doc['createdAt']})")
      return

  # Delete old documents
  deleted_count = 0
  for doc in documents:
      try:
          delete_document(doc['id'])
          deleted_count += 1
      except Exception as e:
          print(f"Failed to delete {doc['id']}: {e}")

  print(f"Deleted {deleted_count} documents older than {retention_days} days")