Rapports hebdomadaires

const DAY_MS = 24 * 60 * 60 * 1000;

function isoDate(timestamp) {
  return new Date(timestamp).toISOString().slice(0, 10);
}

function completeSevenDayWindows(now = new Date()) {
  const todayUtc = Date.UTC(
    now.getUTCFullYear(),
    now.getUTCMonth(),
    now.getUTCDate()
  );
  const currentEnd = todayUtc - DAY_MS;
  const currentStart = currentEnd - 6 * DAY_MS;
  const previousEnd = currentStart - DAY_MS;
  const previousStart = previousEnd - 6 * DAY_MS;

  return {
    current: { startDate: isoDate(currentStart), endDate: isoDate(currentEnd) },
    previous: { startDate: isoDate(previousStart), endDate: isoDate(previousEnd) },
  };
}

from datetime import datetime, timedelta, timezone


def complete_seven_day_windows() -> dict:
    today_utc = datetime.now(timezone.utc).date()
    current_end = today_utc - timedelta(days=1)
    current_start = current_end - timedelta(days=6)
    previous_end = current_start - timedelta(days=1)
    previous_start = previous_end - timedelta(days=6)

    return {
        'current': {
            'start_date': current_start.isoformat(),
            'end_date': current_end.isoformat(),
        },
        'previous': {
            'start_date': previous_start.isoformat(),
            'end_date': previous_end.isoformat(),
        },
    }

async function generateWeeklyReport(client, brandId, now = new Date()) {
  const windows = completeSevenDayWindows(now);
  const [current, previous] = await Promise.all([
    client.getPerformance(brandId, windows.current),
    client.getPerformance(brandId, windows.previous),
  ]);

  const metricKeys = [
    ['Mention Rate', 'mentionRate'],
    ['Source Rate', 'sourceRate'],
    ['Coverage', 'coverage'],
    ['Share of Voice', 'shareOfVoice'],
    ['Sentiment', 'sentiment'],
  ];

  const metrics = metricKeys.map(([name, key]) => {
    const currentValue = current.scores[key];
    const previousValue = previous.scores[key];
    const changePoints = Number((currentValue - previousValue).toFixed(2));
    return {
      name,
      current: currentValue,
      previous: previousValue,
      changePoints,
      direction: changePoints > 0
        ? 'increased'
        : changePoints < 0
          ? 'decreased'
          : 'unchanged',
    };
  });

  return {
    generatedAt: now.toISOString(),
    windows,
    metrics,
    methodology: {
      current: current.methodology,
      previous: previous.methodology,
    },
  };
}

def generate_weekly_report(client, brand_id: str) -> dict:
    windows = complete_seven_day_windows()
    current = client.get_performance(
        brand_id,
        start_date=windows['current']['start_date'],
        end_date=windows['current']['end_date'],
    )
    previous = client.get_performance(
        brand_id,
        start_date=windows['previous']['start_date'],
        end_date=windows['previous']['end_date'],
    )

    metric_keys = [
        ('Mention Rate', 'mentionRate'),
        ('Source Rate', 'sourceRate'),
        ('Coverage', 'coverage'),
        ('Share of Voice', 'shareOfVoice'),
        ('Sentiment', 'sentiment'),
    ]

    metrics = []
    for name, key in metric_keys:
        change_points = round(
            current['scores'][key] - previous['scores'][key], 2
        )
        direction = (
            'increased' if change_points > 0
            else 'decreased' if change_points < 0
            else 'unchanged'
        )
        metrics.append({
            'name': name,
            'current': current['scores'][key],
            'previous': previous['scores'][key],
            'change_points': change_points,
            'direction': direction,
        })

    return {
        'generated_at': datetime.now(timezone.utc).isoformat(),
        'windows': windows,
        'metrics': metrics,
        'methodology': {
            'current': current['methodology'],
            'previous': previous['methodology'],
        },
    }