get_media_buys

import { testAgent } from '@adcp/client/testing';
import { GetMediaBuysResponseSchema } from '@adcp/client';

const result = await testAgent.getMediaBuys({
  media_buy_ids: ['mb_12345']
});

if (!result.success) {
  throw new Error(`Request failed: ${result.error}`);
}

const validated = GetMediaBuysResponseSchema.parse(result.data);

if (validated.errors?.length > 0) {
  throw new Error(`Query failed: ${JSON.stringify(validated.errors)}`);
}

for (const mediaBuy of validated.media_buys) {
  for (const pkg of mediaBuy.packages) {
    // Check for missing creatives
    if (pkg.format_ids_pending?.length > 0) {
      console.log(`Package ${pkg.package_id}: missing formats ${pkg.format_ids_pending.map(f => f.id).join(', ')}`);
    }

    // Check approval states
    for (const approval of pkg.creative_approvals ?? []) {
      if (approval.approval_status === 'rejected') {
        console.log(`Creative ${approval.creative_id} rejected: ${approval.rejection_reason}`);
      } else if (approval.approval_status === 'pending_review') {
        console.log(`Creative ${approval.creative_id} pending review`);
      }
    }
  }
}

import asyncio
from adcp.testing import test_agent
from adcp.types import GetMediaBuysRequest

async def main():
    result = await test_agent.get_media_buys(
        GetMediaBuysRequest(media_buy_ids=['mb_12345'])
    )

    if result.errors:
        raise Exception(f"Query failed: {result.errors}")

    for media_buy in result.media_buys:
        for pkg in media_buy.packages:
            # Check for missing creatives
            if pkg.format_ids_pending:
                ids = [f.id for f in pkg.format_ids_pending]
                print(f"Package {pkg.package_id}: missing formats {', '.join(ids)}")

            # Check approval states
            for approval in pkg.creative_approvals or []:
                if approval.approval_status == 'rejected':
                    print(f"Creative {approval.creative_id} rejected: {approval.rejection_reason}")
                elif approval.approval_status == 'pending_review':
                    print(f"Creative {approval.creative_id} pending review")

asyncio.run(main())

import { testAgent } from '@adcp/client/testing';
import { GetMediaBuysResponseSchema } from '@adcp/client';

const result = await testAgent.getMediaBuys({
  status_filter: 'active',
  include_snapshot: true
});

if (!result.success) {
  throw new Error(`Request failed: ${result.error}`);
}

const validated = GetMediaBuysResponseSchema.parse(result.data);

for (const mediaBuy of validated.media_buys) {
  for (const pkg of mediaBuy.packages) {
    const snap = pkg.snapshot;
    if (!snap) continue;

    if (snap.delivery_status === 'not_delivering') {
      console.log(`Package ${pkg.package_id}: zero delivery (data up to ${snap.staleness_seconds}s old)`);
    } else if (snap.pacing_index !== undefined && snap.pacing_index < 0.8) {
      console.log(`Package ${pkg.package_id}: underpacing at ${(snap.pacing_index * 100).toFixed(0)}%`);
    } else {
      console.log(`Package ${pkg.package_id}: ${snap.impressions.toLocaleString()} impressions, pacing ${snap.pacing_index?.toFixed(2)}`);
    }
  }
}

import asyncio
from adcp.testing import test_agent
from adcp.types import GetMediaBuysRequest

async def main():
    result = await test_agent.get_media_buys(
        GetMediaBuysRequest(
            status_filter='active',
            include_snapshot=True
        )
    )

    if result.errors:
        raise Exception(f"Query failed: {result.errors}")

    for media_buy in result.media_buys:
        for pkg in media_buy.packages:
            snap = pkg.snapshot
            if not snap:
                continue

            if snap.delivery_status == 'not_delivering':
                print(f"Package {pkg.package_id}: zero delivery (data up to {snap.staleness_seconds}s old)")
            elif snap.pacing_index is not None and snap.pacing_index < 0.8:
                print(f"Package {pkg.package_id}: underpacing at {snap.pacing_index * 100:.0f}%")
            else:
                print(f"Package {pkg.package_id}: {snap.impressions:,} impressions, pacing {snap.pacing_index:.2f}")

asyncio.run(main())

import { testAgent } from '@adcp/client/testing';
import { GetMediaBuysResponseSchema } from '@adcp/client';

const result = await testAgent.getMediaBuys({
  media_buy_ids: ['mb_12345']
});

if (!result.success) {
  throw new Error(`Request failed: ${result.error}`);
}

const validated = GetMediaBuysResponseSchema.parse(result.data);
const [mediaBuy] = validated.media_buys;
const issues = [];

for (const pkg of mediaBuy.packages) {
  if (pkg.format_ids_pending?.length > 0) {
    issues.push(`Package ${pkg.package_id}: ${pkg.format_ids_pending.length} format(s) not yet uploaded`);
  }

  const rejected = (pkg.creative_approvals ?? []).filter(a => a.approval_status === 'rejected');
  if (rejected.length > 0) {
    issues.push(`Package ${pkg.package_id}: ${rejected.length} creative(s) rejected`);
  }
}

if (issues.length === 0) {
  console.log('Campaign ready to launch');
} else {
  console.log('Campaign has blocking issues:');
  issues.forEach(issue => console.log(`  - ${issue}`));
}

import asyncio
from adcp.testing import test_agent
from adcp.types import GetMediaBuysRequest

async def main():
    result = await test_agent.get_media_buys(
        GetMediaBuysRequest(media_buy_ids=['mb_12345'])
    )

    media_buy = result.media_buys[0]
    issues = []

    for pkg in media_buy.packages:
        if pkg.format_ids_pending:
            issues.append(f"Package {pkg.package_id}: {len(pkg.format_ids_pending)} format(s) not yet uploaded")

        rejected = [a for a in (pkg.creative_approvals or []) if a.approval_status == 'rejected']
        if rejected:
            issues.append(f"Package {pkg.package_id}: {len(rejected)} creative(s) rejected")

    if not issues:
        print("Campaign ready to launch")
    else:
        print("Campaign has blocking issues:")
        for issue in issues:
            print(f"  - {issue}")

asyncio.run(main())