Asset DDEX Management

const axios = require('axios');

async function updateAssetDDEX(assetId, ddexData) {
  try {
    const response = await axios.put(
      `https://api.royalti.io/asset/${assetId}/ddex-metadata`,
      {
        ddexMetadata: {
          resourceReference: ddexData.resourceReference,
          title: ddexData.title,
          displayArtist: ddexData.displayArtist,
          languageOfPerformance: ddexData.language || 'en',
          duration: ddexData.duration, // ISO 8601 format: PT3M45S
          parentalWarningType: ddexData.explicit ? 'Explicit' : 'NotExplicit'
        },
        technicalResourceDetails: {
          fileFormat: ddexData.format || 'WAV',
          sampleRate: ddexData.sampleRate || 44100,
          bitDepth: ddexData.bitDepth || 16,
          numberOfChannels: ddexData.channels || 2,
          audioCodec: ddexData.codec || 'PCM'
        },
        soundRecordingDetails: {
          isrc: ddexData.isrc,
          pLine: {
            year: new Date().getFullYear(),
            pLineText: ddexData.pLine
          },
          genre: ddexData.genre,
          subGenre: ddexData.subGenre
        }
      },
      {
        headers: {
          'Authorization': `Bearer ${process.env.ROYALTI_ACCESS_TOKEN}`,
          'Content-Type': 'application/json'
        }
      }
    );

    console.log('DDEX metadata updated:', response.data);
    return response.data;
  } catch (error) {
    console.error('Failed to update DDEX metadata:', error.response?.data);
    throw error;
  }
}

// Example usage
updateAssetDDEX('asset_123', {
  resourceReference: 'A123456789',
  title: 'My Song Title',
  displayArtist: 'Artist Name',
  language: 'en',
  duration: 'PT3M45S',
  explicit: false,
  isrc: 'USRC17607839',
  pLine: '2024 Record Label Name',
  genre: 'Pop',
  subGenre: 'Indie Pop'
});

import requests
from datetime import datetime

def update_asset_ddex(asset_id, ddex_data):
    """Update DDEX metadata for an asset"""
    url = f"https://api.royalti.io/asset/{asset_id}/ddex-metadata"

    payload = {
        "ddexMetadata": {
            "resourceReference": ddex_data["resource_reference"],
            "title": ddex_data["title"],
            "displayArtist": ddex_data["display_artist"],
            "languageOfPerformance": ddex_data.get("language", "en"),
            "duration": ddex_data["duration"],  # ISO 8601: PT3M45S
            "parentalWarningType": "Explicit" if ddex_data.get("explicit") else "NotExplicit"
        },
        "technicalResourceDetails": {
            "fileFormat": ddex_data.get("format", "WAV"),
            "sampleRate": ddex_data.get("sample_rate", 44100),
            "bitDepth": ddex_data.get("bit_depth", 16),
            "numberOfChannels": ddex_data.get("channels", 2),
            "audioCodec": ddex_data.get("codec", "PCM")
        },
        "soundRecordingDetails": {
            "isrc": ddex_data["isrc"],
            "pLine": {
                "year": datetime.now().year,
                "pLineText": ddex_data["p_line"]
            },
            "genre": ddex_data["genre"],
            "subGenre": ddex_data.get("sub_genre")
        }
    }

    headers = {
        "Authorization": f"Bearer {os.getenv('ROYALTI_ACCESS_TOKEN')}",
        "Content-Type": "application/json"
    }

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

    print(f"DDEX metadata updated: {response.json()}")
    return response.json()

# Example usage
update_asset_ddex('asset_123', {
    'resource_reference': 'A123456789',
    'title': 'My Song Title',
    'display_artist': 'Artist Name',
    'language': 'en',
    'duration': 'PT3M45S',
    'explicit': False,
    'isrc': 'USRC17607839',
    'p_line': '2024 Record Label Name',
    'genre': 'Pop',
    'sub_genre': 'Indie Pop'
})

async function checkDDEXReadiness(assetId) {
  try {
    const response = await axios.get(
      `https://api.royalti.io/asset/${assetId}/ddex-readiness`,
      {
        headers: {
          'Authorization': `Bearer ${process.env.ROYALTI_ACCESS_TOKEN}`
        }
      }
    );

    const { isReady, readinessScore, missingFields, invalidFields, warnings } = response.data.data;

    if (isReady) {
      console.log(`✓ Asset is DDEX ready (score: ${readinessScore}%)`);
    } else {
      console.log(`✗ Asset is NOT ready (score: ${readinessScore}%)`);
      if (missingFields.length > 0) {
        console.log('Missing fields:', missingFields);
      }
      if (invalidFields.length > 0) {
        console.log('Invalid fields:', invalidFields);
      }
      if (warnings.length > 0) {
        console.log('Warnings:', warnings);
      }
    }

    return response.data.data;
  } catch (error) {
    console.error('Failed to check DDEX readiness:', error.response?.data);
    throw error;
  }
}

checkDDEXReadiness('asset_123');

def check_ddex_readiness(asset_id):
    """Check if asset is ready for DDEX delivery"""
    url = f"https://api.royalti.io/asset/{asset_id}/ddex-readiness"

    headers = {
        "Authorization": f"Bearer {os.getenv('ROYALTI_ACCESS_TOKEN')}"
    }

    response = requests.get(url, headers=headers)
    response.raise_for_status()

    data = response.json()["data"]

    if data["isReady"]:
        print(f"✓ Asset is DDEX ready (score: {data['readinessScore']}%)")
    else:
        print(f"✗ Asset is NOT ready (score: {data['readinessScore']}%)")
        if data["missingFields"]:
            print(f"Missing fields: {data['missingFields']}")
        if data["invalidFields"]:
            print(f"Invalid fields: {data['invalidFields']}")
        if data["warnings"]:
            print(f"Warnings: {data['warnings']}")

    return data

check_ddex_readiness('asset_123')