get_media_buy_delivery

import { testAgent } from "@adcp/sdk/testing";
import { GetMediaBuyDeliveryResponseSchema } from "@adcp/sdk";

// 単一メディアバイの配信レポートを取得
const result = await testAgent.getMediaBuyDelivery({
  media_buy_ids: ["mb_12345"],
  start_date: "2024-02-01",
  end_date: "2024-02-07"
});

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

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

// 判別共用体レスポンスのエラーを確認
if ("errors" in validated && validated.errors) {
  throw new Error(`Query failed: ${JSON.stringify(validated.errors)}`);
}

console.log(
  `Delivered ${validated.aggregated_totals.impressions.toLocaleString()} impressions`
);
console.log(`Spend: $${validated.aggregated_totals.spend.toFixed(2)}`);
if (validated.media_buy_deliveries.length > 0) {
  console.log(
    `CTR: ${(validated.media_buy_deliveries[0].totals.ctr * 100).toFixed(2)}%`
  );
}

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

async def main():
    # 単一メディアバイの配信レポートを取得
    result = await test_agent.get_media_buy_delivery(
        GetMediaBuyDeliveryRequest(
            media_buy_ids=['mb_12345'],
            start_date='2024-02-01',
            end_date='2024-02-07'
        )
    )

    # 判別共用体レスポンスのエラーを確認
    if hasattr(result, 'errors') and result.errors:
        raise Exception(f"Query failed: {result.errors}")

    print(f"Delivered {result.aggregated_totals.impressions:,} impressions")
    print(f"Spend: ${result.aggregated_totals.spend:.2f}")
    if result.media_buy_deliveries:
        print(f"CTR: {result.media_buy_deliveries[0].totals.ctr * 100:.2f}%")

asyncio.run(main())

import { testAgent } from "@adcp/sdk/testing";
import { GetMediaBuyDeliveryResponseSchema } from "@adcp/sdk";

// コンテキスト内のアクティブなメディアバイをすべて取得
const result = await testAgent.getMediaBuyDelivery({
  status_filter: "active",
  start_date: "2024-02-01",
  end_date: "2024-02-07"
});

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

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

if ("errors" in validated && validated.errors) {
  throw new Error(`Query failed: ${JSON.stringify(validated.errors)}`);
}

console.log(`${validated.aggregated_totals.media_buy_count} active campaigns`);
console.log(
  `Total impressions: ${validated.aggregated_totals.impressions.toLocaleString()}`
);
console.log(`Total spend: $${validated.aggregated_totals.spend.toFixed(2)}`);

// キャンペーンごとに確認
validated.media_buy_deliveries.forEach((delivery) => {
  console.log(
    `${delivery.media_buy_id}: ${delivery.totals.impressions.toLocaleString()} impressions, CTR ${(delivery.totals.ctr * 100).toFixed(2)}%`
  );
});

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

async def main():
    # コンテキスト内のアクティブなメディアバイをすべて取得
    result = await test_agent.get_media_buy_delivery(
        GetMediaBuyDeliveryRequest(
            status_filter='active',
            start_date='2024-02-01',
            end_date='2024-02-07'
        )
    )

    if hasattr(result, 'errors') and result.errors:
        raise Exception(f"Query failed: {result.errors}")

    print(f"{result.aggregated_totals.media_buy_count} active campaigns")
    print(f"Total impressions: {result.aggregated_totals.impressions:,}")
    print(f"Total spend: ${result.aggregated_totals.spend:.2f}")

    # キャンペーンごとに確認
    for delivery in result.media_buy_deliveries:
        print(f"{delivery.media_buy_id}: {delivery.totals.impressions:,} impressions, CTR {delivery.totals.ctr * 100:.2f}%")

asyncio.run(main())

import { testAgent } from "@adcp/sdk/testing";
import { GetMediaBuyDeliveryResponseSchema } from "@adcp/sdk";

// 月初から現在までのパフォーマンスを取得
const now = new Date();
const monthStart = new Date(now.getFullYear(), now.getMonth(), 1);
const dateFormat = (date) => date.toISOString().split("T")[0];

const result = await testAgent.getMediaBuyDelivery({
  media_buy_ids: ["mb_12345"],
  start_date: dateFormat(monthStart),
  end_date: dateFormat(now)
});

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

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

if ("errors" in validated && validated.errors) {
  throw new Error(`Query failed: ${JSON.stringify(validated.errors)}`);
}

if (validated.media_buy_deliveries.length > 0) {
  // 日別内訳を分析
  const dailyBreakdown = validated.media_buy_deliveries[0].daily_breakdown;
  if (dailyBreakdown && dailyBreakdown.length > 0) {
    console.log(
      `Daily average: ${Math.round(validated.aggregated_totals.impressions / dailyBreakdown.length).toLocaleString()} impressions`
    );

    // ピーク日を特定
    const peakDay = dailyBreakdown.reduce((max, day) =>
      day.impressions > max.impressions ? day : max
    );
    console.log(
      `Peak day: ${peakDay.date} with ${peakDay.impressions.toLocaleString()} impressions`
    );
  }
}

import asyncio
from adcp.testing import test_agent
from adcp.types import GetMediaBuyDeliveryRequest
from datetime import date

async def main():
    # 月初から現在までのパフォーマンスを取得
    today = date.today()
    month_start = date(today.year, today.month, 1)

    result = await test_agent.get_media_buy_delivery(
        GetMediaBuyDeliveryRequest(
            media_buy_ids=['mb_12345'],
            start_date=str(month_start),
            end_date=str(today)
        )
    )

    if hasattr(result, 'errors') and result.errors:
        raise Exception(f"Query failed: {result.errors}")

    if result.media_buy_deliveries:
        # 日別内訳を分析
        daily_breakdown = result.media_buy_deliveries[0].daily_breakdown
        if daily_breakdown:
            daily_avg = result.aggregated_totals.impressions // len(daily_breakdown)
            print(f"Daily average: {daily_avg:,} impressions")

            # ピーク日を特定
            peak_day = max(daily_breakdown, key=lambda d: d.impressions)
            print(f"Peak day: {peak_day.date} with {peak_day.impressions:,} impressions")

asyncio.run(main())

import { testAgent } from "@adcp/sdk/testing";
import { GetMediaBuyDeliveryResponseSchema } from "@adcp/sdk";

// アクティブと一時停止中のキャンペーンを取得
const result = await testAgent.getMediaBuyDelivery({
  status_filter: ["active", "paused"],
  start_date: "2024-02-01",
  end_date: "2024-02-07"
});

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

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

if ("errors" in validated && validated.errors) {
  throw new Error(`Query failed: ${JSON.stringify(validated.errors)}`);
}

// ステータス別にグループ化
const byStatus = validated.media_buy_deliveries.reduce((acc, delivery) => {
  if (!acc[delivery.status]) acc[delivery.status] = [];
  acc[delivery.status].push(delivery);
  return acc;
}, {});

console.log(`Active campaigns: ${byStatus.active?.length || 0}`);
console.log(`Paused campaigns: ${byStatus.paused?.length || 0}`);

// パフォーマンスが低いキャンペーンを特定
byStatus.paused?.forEach((delivery) => {
  if (delivery.by_package && delivery.by_package.length > 0) {
    const avgPacing =
      delivery.by_package.reduce((sum, pkg) => sum + pkg.pacing_index, 0) /
      delivery.by_package.length;
    console.log(
      `${delivery.media_buy_id}: paused with ${(avgPacing * 100).toFixed(0)}% pacing`
    );
  }
});

import asyncio
from adcp.testing import test_agent
from adcp.types import GetMediaBuyDeliveryRequest
from collections import defaultdict

async def main():
    # アクティブと一時停止中のキャンペーンを取得
    result = await test_agent.get_media_buy_delivery(
        GetMediaBuyDeliveryRequest(
            status_filter=['active', 'paused'],
            start_date='2024-02-01',
            end_date='2024-02-07'
        )
    )

    if hasattr(result, 'errors') and result.errors:
        raise Exception(f"Query failed: {result.errors}")

    # ステータス別にグループ化
    by_status = defaultdict(list)
    for delivery in result.media_buy_deliveries:
        by_status[delivery.status].append(delivery)

    print(f"Active campaigns: {len(by_status['active'])}")
    print(f"Paused campaigns: {len(by_status['paused'])}")

    # パフォーマンスが低いキャンペーンを特定
    for delivery in by_status['paused']:
        if delivery.by_package:
            avg_pacing = sum(pkg.pacing_index for pkg in delivery.by_package) / len(delivery.by_package)
            print(f"{delivery.media_buy_id}: paused with {avg_pacing * 100:.0f}% pacing")

asyncio.run(main())

import { testAgent } from "@adcp/sdk/testing";
import { GetMediaBuyDeliveryResponseSchema } from "@adcp/sdk";

// メディアバイ ID の代わりに buyer reference で検索
const result = await testAgent.getMediaBuyDelivery({
  media_buy_ids: ["acme_q1_campaign_2024", "acme_q1_retargeting_2024"]
});

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

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

if ("errors" in validated && validated.errors) {
  throw new Error(`Query failed: ${JSON.stringify(validated.errors)}`);
}

console.log(
  `Total lifetime impressions: ${validated.aggregated_totals.impressions.toLocaleString()}`
);
console.log(
  `Total lifetime spend: $${validated.aggregated_totals.spend.toFixed(2)}`
);

validated.media_buy_deliveries.forEach((delivery) => {
  if (delivery.totals.impressions > 0) {
    const cpm = (delivery.totals.spend / delivery.totals.impressions) * 1000;
    console.log(
      `${delivery.media_buy_id}: CPM $${cpm.toFixed(2)}, CTR ${(delivery.totals.ctr * 100).toFixed(2)}%`
    );
  }
});

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

async def main():
    # メディアバイ ID の代わりに buyer reference で検索
    result = await test_agent.get_media_buy_delivery(
        GetMediaBuyDeliveryRequest(
            media_buy_ids=['acme_q1_campaign_2024', 'acme_q1_retargeting_2024']
        )
    )

    if hasattr(result, 'errors') and result.errors:
        raise Exception(f"Query failed: {result.errors}")

    # ライフタイム配信データ（日付範囲を指定しない場合）
    print(f"Total lifetime impressions: {result.aggregated_totals.impressions:,}")
    print(f"Total lifetime spend: ${result.aggregated_totals.spend:.2f}")

    # キャンペーン比較
    for delivery in result.media_buy_deliveries:
        if delivery.totals.impressions > 0:
            cpm = (delivery.totals.spend / delivery.totals.impressions) * 1000
            print(f"{delivery.media_buy_id}: CPM ${cpm:.2f}, CTR {delivery.totals.ctr * 100:.2f}%")

asyncio.run(main())

import { testAgent } from '@adcp/sdk/testing';
import { GetMediaBuyDeliveryResponseSchema } from '@adcp/sdk';

// Get delivery for a specific advertiser account
const result = await testAgent.getMediaBuyDelivery({
  account: { account_id: 'acc_acme_pinnacle' },
  status_filter: 'active',
  start_date: '2024-02-01',
  end_date: '2024-02-07'
});

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

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

if ('errors' in validated && validated.errors) {
  throw new Error(`Query failed: ${JSON.stringify(validated.errors)}`);
}

console.log(`${validated.aggregated_totals.media_buy_count} campaigns for account`);
console.log(`Total spend: $${validated.aggregated_totals.spend.toFixed(2)}`);

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

async def main():
    # Get delivery for a specific advertiser account
    result = await test_agent.get_media_buy_delivery(
        GetMediaBuyDeliveryRequest(
            account={'account_id': 'acc_acme_pinnacle'},
            status_filter='active',
            start_date='2024-02-01',
            end_date='2024-02-07'
        )
    )

    if hasattr(result, 'errors') and result.errors:
        raise Exception(f"Query failed: {result.errors}")

    print(f"{result.aggregated_totals.media_buy_count} campaigns for account")
    print(f"Total spend: ${result.aggregated_totals.spend:.2f}")

asyncio.run(main())