Running Moderation

const response = await fetch('https://api.deepmod.ai/v1/moderation/run', {
  method: 'POST',
  headers: {
    'Authorization': `Bearer ${process.env.DEEPMOD_API_TOKEN}`,
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
    policyUri: 'your-policy-uri',
    content: 'Text content to moderate',
    metadata: {
      userId: 'user_12345',
      postId: 'post_67890',
      source: 'comment',
      priority: 'standard',
    },
    tags: ['user-generated', 'comments', 'public'],
  }),
});

const result = await response.json();
// Note: Production moderation is async, result delivered via webhook
console.log('Moderation job ID:', result.moderationJobId);

import requests
import os

response = requests.post('https://api.deepmod.ai/v1/moderation/run',
  headers={
    'Authorization': f"Bearer {os.environ['DEEPMOD_API_TOKEN']}",
    'Content-Type': 'application/json'
  },
  json={
    'policyUri': 'your-policy-uri',
    'content': 'Text content to moderate',
    'metadata': {
      'userId': 'user_12345',
      'postId': 'post_67890',
      'source': 'comment',
      'priority': 'standard'
    },
    'tags': ['user-generated', 'comments', 'public']
  }
)

result = response.json()
# Note: Production moderation is async, result delivered via webhook
print(f"Moderation job ID: {result['moderationJobId']}")

<?php
$response = file_get_contents('https://api.deepmod.ai/v1/moderation/run', false,
  stream_context_create([
    'http' => [
      'method' => 'POST',
      'header' => [
        'Authorization: Bearer ' . $_ENV['DEEPMOD_API_TOKEN'],
        'Content-Type: application/json'
      ],
      'content' => json_encode([
        'policyUri' => 'your-policy-uri',
        'content' => 'Text content to moderate',
        'metadata' => [
          'userId' => 'user_12345',
          'postId' => 'post_67890',
          'source' => 'comment',
          'priority' => 'standard'
        ],
        'tags' => ['user-generated', 'comments', 'public']
      ])
    ]
  ])
);

$result = json_decode($response, true);
// Note: Production moderation is async, result delivered via webhook
echo "Moderation job ID: " . $result['moderationJobId'];
?>

require 'net/http'
require 'json'

uri = URI('https://api.deepmod.ai/v1/moderation/run')
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true

request = Net::HTTP::Post.new(uri)
request['Authorization'] = "Bearer #{ENV['DEEPMOD_API_TOKEN']}"
request['Content-Type'] = 'application/json'
request.body = {
  policyUri: 'your-policy-uri',
  content: 'Text content to moderate',
  metadata: {
    userId: 'user_12345',
    postId: 'post_67890',
    source: 'comment',
    priority: 'standard'
  },
  tags: ['user-generated', 'comments', 'public']
}.to_json

response = http.request(request)
result = JSON.parse(response.body)
# Note: Production moderation is async, result delivered via webhook
puts "Moderation job ID: #{result['moderationJobId']}"

// Example webhook handler (Node.js/Express)
app.post('/webhook/moderation', async (req, res) => {
  try {
    // 1. Verify webhook signature (recommended)
    const signature = req.headers['x-deepmod-signature'];
    if (!verifySignature(req.body, signature, webhookSecret)) {
      return res.status(401).send('Invalid signature');
    }

    // 2. Parse webhook payload
    const { id: jobId, type, data } = req.body;

    // 3. Implement idempotent handling
    if (await isJobAlreadyProcessed(jobId)) {
      return res.status(200).send('Already processed');
    }

    // 4. Route based on webhook type
    switch (type) {
      case 'Moderation.Completed':
        await handleSingleModeration(data);
        break;
      case 'Moderation.BatchCompleted':
        await handleBatchModeration(data);
        break;
      case 'Moderation.Failed':
        await handleFailedModeration(data);
        break;
    }

    // 5. Mark job as processed
    await markJobProcessed(jobId);

    // 6. Return success response
    res.status(200).send('Processed');
  } catch (error) {
    // 7. Log errors and return error status
    console.error('Webhook processing error:', error);
    res.status(500).send('Processing failed');
  }
});

async function handleSingleModeration(data) {
  const { moderation, metadata } = data;

  switch (moderation.result) {
    case 'success':
      await handleApprovedContent(metadata, moderation);
      break;
    case 'failure':
      await handleRejectedContent(metadata, moderation);
      break;
    case 'ambiguous':
      await handleAmbiguousContent(metadata, moderation);
      break;
  }
}

async function handleBatchModeration(data) {
  const { batch, metadata } = data;

  // Check overall batch result
  switch (batch.result) {
    case 'success':
      await handleApprovedContent(metadata, batch);
      break;
    case 'failure':
      // Find which policy failed
      const failedPolicy = batch.moderation.find(m => m.result === 'failure');
      await handleRejectedContent(metadata, failedPolicy);
      break;
    case 'ambiguous':
      await handleAmbiguousContent(metadata, batch);
      break;
  }

  // Handle any abandoned policies
  const abandonedPolicies = batch.moderation.filter(m => m.result === 'abandoned');
  if (abandonedPolicies.length > 0) {
    console.log(`${abandonedPolicies.length} policies were abandoned due to earlier failure`);
  }
}

from flask import Flask, request, jsonify
import hmac
import hashlib

app = Flask(__name__)

@app.route('/webhook/moderation', methods=['POST'])
def webhook_handler():
    try:
        # 1. Verify webhook signature (recommended)
        signature = request.headers.get('x-deepmod-signature')
        if not verify_signature(request.data, signature, webhook_secret):
            return jsonify({'error': 'Invalid signature'}), 401

        # 2. Parse webhook payload
        data = request.json
        job_id = data['id']
        webhook_type = data['type']
        payload = data['data']

        # 3. Implement idempotent handling
        if is_job_already_processed(job_id):
            return jsonify({'status': 'Already processed'}), 200

        # 4. Route based on webhook type
        if webhook_type == 'Moderation.Completed':
            handle_single_moderation(payload)
        elif webhook_type == 'Moderation.BatchCompleted':
            handle_batch_moderation(payload)
        elif webhook_type == 'Moderation.Failed':
            handle_failed_moderation(payload)

        # 5. Mark job as processed
        mark_job_processed(job_id)

        # 6. Return success response
        return jsonify({'status': 'Processed'}), 200

    except Exception as error:
        # 7. Log errors and return error status
        print(f'Webhook processing error: {error}')
        return jsonify({'error': 'Processing failed'}), 500

def handle_single_moderation(payload):
    moderation = payload['moderation']
    metadata = payload['metadata']

    if moderation['result'] == 'success':
        handle_approved_content(metadata, moderation)
    elif moderation['result'] == 'failure':
        handle_rejected_content(metadata, moderation)
    elif moderation['result'] == 'ambiguous':
        handle_ambiguous_content(metadata, moderation)

def handle_batch_moderation(payload):
    batch = payload['batch']
    metadata = payload['metadata']

    if batch['result'] == 'success':
        handle_approved_content(metadata, batch)
    elif batch['result'] == 'failure':
        failed_policy = next(m for m in batch['moderation'] if m['result'] == 'failure')
        handle_rejected_content(metadata, failed_policy)
    elif batch['result'] == 'ambiguous':
        handle_ambiguous_content(metadata, batch)

    # Handle abandoned policies
    abandoned = [m for m in batch['moderation'] if m['result'] == 'abandoned']
    if abandoned:
        print(f"{len(abandoned)} policies were abandoned due to earlier failure")

<?php
// Example webhook handler (PHP)
if ($_SERVER['REQUEST_METHOD'] === 'POST') {
    try {
        // 1. Verify webhook signature (recommended)
        $signature = $_SERVER['HTTP_X_DEEPMOD_SIGNATURE'] ?? '';
        $requestBody = file_get_contents('php://input');

        if (!verifySignature($requestBody, $signature, $webhookSecret)) {
            http_response_code(401);
            echo 'Invalid signature';
            exit;
        }

        // 2. Parse webhook payload
        $data = json_decode($requestBody, true);
        $jobId = $data['id'];
        $type = $data['type'];
        $payload = $data['data'];

        // 3. Implement idempotent handling
        if (isJobAlreadyProcessed($jobId)) {
            http_response_code(200);
            echo 'Already processed';
            exit;
        }

        // 4. Route based on webhook type
        switch ($type) {
            case 'Moderation.Completed':
                handleSingleModeration($payload);
                break;
            case 'Moderation.BatchCompleted':
                handleBatchModeration($payload);
                break;
            case 'Moderation.Failed':
                handleFailedModeration($payload);
                break;
        }

        // 5. Mark job as processed
        markJobProcessed($jobId);

        // 6. Return success response
        http_response_code(200);
        echo 'Processed';

    } catch (Exception $error) {
        // 7. Log errors and return error status
        error_log('Webhook processing error: ' . $error->getMessage());
        http_response_code(500);
        echo 'Processing failed';
    }
}

function handleSingleModeration($payload) {
    $moderation = $payload['moderation'];
    $metadata = $payload['metadata'];

    switch ($moderation['result']) {
        case 'success':
            handleApprovedContent($metadata, $moderation);
            break;
        case 'failure':
            handleRejectedContent($metadata, $moderation);
            break;
        case 'ambiguous':
            handleAmbiguousContent($metadata, $moderation);
            break;
    }
}

function handleBatchModeration($payload) {
    $batch = $payload['batch'];
    $metadata = $payload['metadata'];

    switch ($batch['result']) {
        case 'success':
            handleApprovedContent($metadata, $batch);
            break;
        case 'failure':
            $failedPolicy = array_filter($batch['moderation'], fn($m) => $m['result'] === 'failure')[0];
            handleRejectedContent($metadata, $failedPolicy);
            break;
        case 'ambiguous':
            handleAmbiguousContent($metadata, $batch);
            break;
    }

    // Handle abandoned policies
    $abandoned = array_filter($batch['moderation'], fn($m) => $m['result'] === 'abandoned');
    if (count($abandoned) > 0) {
        error_log(count($abandoned) . " policies were abandoned due to earlier failure");
    }
}
?>

require 'sinatra'
require 'json'
require 'openssl'

post '/webhook/moderation' do
  begin
    # 1. Verify webhook signature (recommended)
    signature = request.env['HTTP_X_DEEPMOD_SIGNATURE']
    request_body = request.body.read

    unless verify_signature(request_body, signature, webhook_secret)
      status 401
      return 'Invalid signature'
    end

    # 2. Parse webhook payload
    data = JSON.parse(request_body)
    job_id = data['id']
    webhook_type = data['type']
    payload = data['data']

    # 3. Implement idempotent handling
    if job_already_processed?(job_id)
      status 200
      return 'Already processed'
    end

    # 4. Route based on webhook type
    case webhook_type
    when 'Moderation.Completed'
      handle_single_moderation(payload)
    when 'Moderation.BatchCompleted'
      handle_batch_moderation(payload)
    when 'Moderation.Failed'
      handle_failed_moderation(payload)
    end

    # 5. Mark job as processed
    mark_job_processed(job_id)

    # 6. Return success response
    status 200
    'Processed'

  rescue => error
    # 7. Log errors and return error status
    puts "Webhook processing error: #{error.message}"
    status 500
    'Processing failed'
  end
end

def handle_single_moderation(payload)
  moderation = payload['moderation']
  metadata = payload['metadata']

  case moderation['result']
  when 'success'
    handle_approved_content(metadata, moderation)
  when 'failure'
    handle_rejected_content(metadata, moderation)
  when 'ambiguous'
    handle_ambiguous_content(metadata, moderation)
  end
end

def handle_batch_moderation(payload)
  batch = payload['batch']
  metadata = payload['metadata']

  case batch['result']
  when 'success'
    handle_approved_content(metadata, batch)
  when 'failure'
    failed_policy = batch['moderation'].find { |m| m['result'] == 'failure' }
    handle_rejected_content(metadata, failed_policy)
  when 'ambiguous'
    handle_ambiguous_content(metadata, batch)
  end

  # Handle abandoned policies
  abandoned = batch['moderation'].select { |m| m['result'] == 'abandoned' }
  puts "#{abandoned.length} policies were abandoned due to earlier failure" if abandoned.any?
end