Elastyczne budżety – konto menedżera

Kliknij ikonę narzędzia

Ten skrypt rozszerza elastyczne budżety, aby działały na wielu kontach w ramach jednego konta menedżera. Budżety elastyczne umożliwiają dynamiczne dostosowywanie dziennego budżetu kampanii zgodnie z niestandardowym schematem dystrybucji budżetu.

Skrypt odczytuje arkusz kalkulacyjny dla każdej z wybranych kont lub kampanii i odpowiada im budżet (powiązany z datą rozpoczęcia i zakończenia), wyszukuje kampanię, oblicza jej budżet na bieżący dzień, ustawia go jako budżet dzienny kampanii i zapisuje wynik w arkuszu kalkulacyjnym. Nie dotknie kampanii, które nie zostały określone w arkuszu kalkulacyjnym.

Jak to działa

Skrypt działa tak samo jak skrypt elastycznego budżetu na jednym koncie. Jedyną dodatkową funkcją jest to, że obsługuje on wiele kont za pomocą określonego arkusza kalkulacyjnego.

Pierwsze 2 kolumny określają kampanię, dla której ma zostać obliczony budżet, następne 3 określają informacje o budżecie, a ostatnie – wynik wykonania.

Identyfikator konta powinien odnosić się do konta reklamodawcy, a nie do konta menedżera.

Możesz mieć wiele budżetów tego samego konta lub tej samej kampanii, ale upewnij się, że masz tylko jeden aktywny budżet w danym momencie. W przeciwnym razie nowsze obliczenie budżetu może zastąpić starszy budżet.

Jeśli w arkuszu nie podasz konta lub kampanii, skrypt nie ustawi dla nich elastycznego budżetu.

Testowanie strategii ustalania budżetu

Skrypt zawiera kod testowy do symulowania efektów działania aplikacji przez kilka dni. Pozwala to lepiej zrozumieć, co się dzieje, gdy skrypt ma działać codziennie w określonym czasie.

Domyślnie ten skrypt symuluje równomierny rozkład budżetu w wysokości 500 zł wydany w ciągu 10 dni.

Aby uruchomić kod testowania, wywołaj testBudgetStrategy zamiast setNewBudget w metodzie głównej:

function main() {
  testBudgetStrategy(calculateBudgetEvenly, 10, 500);
  //  setNewBudget(calculateBudgetWeighted);
}

Wywołanie funkcji setNewBudget jest komentowane, co oznacza, że skrypt uruchamia kod testowy. Oto dane wyjściowe z tego przykładu:

Day 1.0 of 10.0, new budget 50.0, cost so far 0.0
Day 2.0 of 10.0, new budget 50.0, cost so far 50.0
Day 3.0 of 10.0, new budget 50.0, cost so far 100.0
Day 4.0 of 10.0, new budget 50.0, cost so far 150.0
Day 5.0 of 10.0, new budget 50.0, cost so far 200.0
Day 6.0 of 10.0, new budget 50.0, cost so far 250.0
Day 7.0 of 10.0, new budget 50.0, cost so far 300.0
Day 8.0 of 10.0, new budget 50.0, cost so far 350.0
Day 9.0 of 10.0, new budget 50.0, cost so far 400.0
Day 10.0 of 10.0, new budget 50.0, cost so far 450.0
Day 11.0 of 10.0, new budget 0.0, cost so far 500.0

Codziennie obliczany jest nowy budżet, który zapewni równomierne wykorzystanie każdego dnia. Po przekroczeniu początkowego przydziału budżet jest ustawiany na zero, aby zatrzymać wydatki.

Strategię budżetu możesz zmienić, modyfikując używaną funkcję lub modyfikując samą funkcję. Skrypt zawiera 2 gotowe strategie: calculateBudgetEvenly i calculateBudgetWeighted. W poprzednim przykładzie testowano tylko pierwszą z nich – zaktualizuj wiersz testBudgetStrategy, tak aby korzystał z drugiego:

testBudgetStrategy(calculateBudgetWeighted, 10, 500);

Kliknij Podgląd i sprawdź dane wyjściowe rejestratora. Zauważ, że ta strategia ustalania budżetu przydziela mniejszy budżet na początku okresu i zwiększa go na kilka kolejnych dni.

Możesz użyć tej metody testowej, aby symulować zmiany w funkcjach obliczania budżetu i wypróbować własne podejście do rozdzielania budżetu.

Alokacja budżetu

Przyjrzyjmy się bliżej strategii dotyczącej budżetu (calculateBudgetWeighted):

// One calculation logic that distributes remaining budget in a weighted manner
function calculateBudgetWeighted(costSoFar, totalBudget, daysSoFar, totalDays) {
  const daysRemaining = totalDays - daysSoFar;
  const budgetRemaining = totalBudget - costSoFar;
  if (daysRemaining <= 0) {
    return budgetRemaining;
  } else {
    return budgetRemaining / (2 * daysRemaining - 1);
  }
}

Ta funkcja przyjmuje następujące argumenty:

  • costSoFar: jaki jest koszt tej kampanii od startDate do dzisiaj.
  • totalBudget: wysokość wydatków w okresie od startDate do endDate.
  • daysSoFar – liczba dni, które upłynęły od startDate do dzisiaj.
  • totalDays: łączna liczba dni od startDate do endDate.

Możesz napisać własną funkcję, o ile przyjmuje ona te argumenty. Dzięki tym wartościom możesz porównać dotychczasowe wydatki z całkowitymi planami i ustalić, gdzie w tej chwili mieści się cały budżet.

W szczególności ta strategia ustalania budżetu oblicza pozostały budżet (totalBudget–costSoFar) i dzieli go przez dwukrotnie liczbę pozostałych dni. Odzwierciedla on rozkład budżetu pod koniec kampanii. Przy korzystaniu z kosztu od startDate uwzględniane są też „powolne dni”, w których nie wykorzystasz całego ustawionego budżetu.

Planowanie budżetu na potrzeby produkcji

Po skonfigurowaniu strategii budżetu musisz wprowadzić kilka zmian, by zaplanować codzienne uruchamianie skryptu.

Najpierw zaktualizuj arkusz kalkulacyjny, określając konto, kampanię, budżet, datę rozpoczęcia i datę zakończenia – po jednym wierszu na każdy budżet kampanii.

  • Identyfikator konta: identyfikator konta (w formacie xxx-xxx-xxxx) kampanii, w której chcesz zastosować strategię budżetu.
  • Nazwa kampanii: nazwa kampanii, w której chcesz zastosować strategię budżetu.
  • Data rozpoczęcia: data rozpoczęcia strategii ustalania budżetu. Powinna to być data bieżąca lub z przeszłości.
  • Data zakończenia: ostatni dzień, w którym chcesz wyświetlać reklamy w ramach tego budżetu.
  • Całkowity budżet: łączna kwota, jaką chcesz wydać. Ta wartość jest wyrażona w walucie konta i może zostać przekroczona w zależności od tego, kiedy skrypt ma działać według harmonogramu.

Następnie wyłącz test i włącz funkcję, aby faktycznie zmienić budżet:

function main() {
  //  testBudgetStrategy(calculateBudgetEvenly, 10, 500);
  setNewBudget(calculateBudgetWeighted);
}

Wynik każdej kampanii jest odnotowywany w kolumnie Wynik wykonania.

Planuję

Zaplanuj uruchamianie tego skryptu codziennie o północy lub tuż po północy w lokalnej strefie czasowej, aby jak najlepiej wykorzystać budżet na kolejny dzień. Pamiętaj jednak, że pobieranie danych do raportów (takich jak koszt) może być opóźnione o około 3 godziny, więc parametr costSoFar może odnosić się do wczorajszej sumy dla skryptu, który ma zostać uruchomiony po północy.

Konfiguracja

Kod źródłowy

// Copyright 2015, Google Inc. All Rights Reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

/**
 * @name MCC Flexible Budgets
 *
 * @overview The MCC Flexible Budgets script dynamically adjusts campaign budget
 *     daily for accounts under an MCC account with a custom budget distribution
 *     scheme. See
 *     https://developers.google.com/google-ads/scripts/docs/solutions/manager-flexible-budgets
 *     for more details.
 *
 * @author Google Ads Scripts Team [adwords-scripts@googlegroups.com]
 *
 * @version 2.1
 *
 * @changelog
 * - version 2.1
 *   - Split into info, config, and code.
 *  - version 2.0
 *   - Updated to use new Google Ads scripts features.
 * - version 1.0.4
 *   - Add support for video and shopping campaigns.
 * - version 1.0.3
 *   - Added validation for external spreadsheet setup.
 * - version 1.0.2
 *   - Fix a minor bug in variable naming.
 *   - Use setAmount on the budget instead of campaign.setBudget.
 * - version 1.0.1
 *   - Improvements to time zone handling.
 * - version 1.0
 *   - Released initial version.
 */
/**
 * Configuration to be used for the Flexible Budgets script.
 */
CONFIG = {
  // URL of the default spreadsheet template. This should be a copy of
  // https://docs.google.com/spreadsheets/d/17wocOgrLeRWF1Qi_BjEigCG0qVMebFHrbUS-Vk_kpLg/copy
  // Make sure the sheet is owned by or shared with same Google user executing the script
  'spreadsheet_url': 'YOUR_SPREADSHEET_URL',

  'advanced_options': {
    // Please fix the following variables if you need to reformat the
    // spreadsheet
    // column numbers of each config column. Column A in your spreadsheet has
    // column number of 1, B has number of 2, etc.
    'column': {
      'accountId': 2,
      'campaignName': 3,
      'startDate': 4,
      'endDate': 5,
      'totalBudget': 6,
      'results': 7
    },

    // Actual config (without header and margin) starts from this row
    'config_start_row': 5
  }
};

const SPREADSHEET_URL = CONFIG.spreadsheet_url;
const COLUMN = CONFIG.advanced_options.column;
const CONFIG_START_ROW = CONFIG.advanced_options.config_start_row;

function main() {
  // Uncomment the following function to test your budget strategy function
  // testBudgetStrategy(calculateBudgetEvenly, 10, 500);
  setNewBudget(calculateBudgetWeighted);
}

// Core logic for calculating and setting campaign daily budget
function setNewBudget(budgetFunc) {
  console.log(`Using spreadsheet - ${SPREADSHEET_URL}.`);
  const spreadsheet = validateAndGetSpreadsheet(SPREADSHEET_URL);
  spreadsheet.setSpreadsheetTimeZone(AdsApp.currentAccount().getTimeZone());
  const sheet = spreadsheet.getSheets()[0];

  const endRow = sheet.getLastRow();

  const mccAccount = AdsApp.currentAccount();
  sheet.getRange(2, 6, 1, 2).setValue(mccAccount.getCustomerId());

  const today = new Date();

  for (let i = CONFIG_START_ROW; i <= endRow; i++) {
    console.log(`Processing row ${i}`);

    const accountId = sheet.getRange(i, COLUMN.accountId).getValue();
    const campaignName = sheet.getRange(i, COLUMN.campaignName).getValue();
    const startDate = new Date(sheet.getRange(i, COLUMN.startDate).getValue());
    const endDate = new Date(sheet.getRange(i, COLUMN.endDate).getValue());
    const totalBudget = sheet.getRange(i, COLUMN.totalBudget).getValue();
    const resultCell = sheet.getRange(i, COLUMN.results);

    const accountIter = AdsManagerApp.accounts().withIds([accountId]).get();
    if (!accountIter.hasNext()) {
      resultCell.setValue('Unknown account');
      continue;
    }
    const account = accountIter.next();
    AdsManagerApp.select(account);

    const campaign = getCampaign(campaignName);
    if (!campaign) {
      resultCell.setValue('Unknown campaign');
      continue;
    }

    if (today < startDate) {
      resultCell.setValue('Budget not started yet');
      continue;
    }
    if (today > endDate) {
      resultCell.setValue('Budget already finished');
      continue;
    }

    const costSoFar = campaign
                          .getStatsFor(
                              getDateStringInTimeZone('yyyyMMdd', startDate),
                              getDateStringInTimeZone('yyyyMMdd', endDate))
                          .getCost();
    const daysSoFar = datediff(startDate, today);
    const totalDays = datediff(startDate, endDate);
    const newBudget = budgetFunc(costSoFar, totalBudget, daysSoFar, totalDays);
    campaign.getBudget().setAmount(newBudget);
    console.log(
        `AccountId=${accountId}, CampaignName=${campaignName}, ` +
        `StartDate=${startDate}, EndDate=${endDate}, ` +
        `CostSoFar=${costSoFar}, DaysSoFar=${daysSoFar}, ` +
        `TotalDays=${totalDays}, NewBudget=${newBudget}'`);
    resultCell.setValue(`Set today's budget to ${newBudget}`);
  }

  // update "Last execution" timestamp
  sheet.getRange(1, 3).setValue(today);
  AdsManagerApp.select(mccAccount);
}

// One calculation logic that distributes remaining budget evenly
function calculateBudgetEvenly(costSoFar, totalBudget, daysSoFar, totalDays) {
  const daysRemaining = totalDays - daysSoFar;
  const budgetRemaining = totalBudget - costSoFar;
  if (daysRemaining <= 0) {
    return budgetRemaining;
  } else {
    return budgetRemaining / daysRemaining;
  }
}

// One calculation logic that distributes remaining budget in a weighted manner
function calculateBudgetWeighted(costSoFar, totalBudget, daysSoFar, totalDays) {
  const daysRemaining = totalDays - daysSoFar;
  const budgetRemaining = totalBudget - costSoFar;
  if (daysRemaining <= 0) {
    return budgetRemaining;
  } else {
    return budgetRemaining / (2 * daysRemaining - 1);
  }
}

// Test function to verify budget calculation logic
function testBudgetStrategy(budgetFunc, totalDays, totalBudget) {
  let daysSoFar = 0;
  let costSoFar = 0;
  while (daysSoFar <= totalDays + 2) {
    const newBudget = budgetFunc(costSoFar, totalBudget, daysSoFar, totalDays);
    console.log(
        `Day ${daysSoFar + 1} of ${totalDays}, ` +
        `new budget ${newBudget}, cost so far ${costSoFar}`);
    costSoFar += newBudget;
    daysSoFar += 1;
  }
}

// Return number of days between two dates, rounded up to nearest whole day.
function datediff(from, to) {
  const millisPerDay = 1000 * 60 * 60 * 24;
  return Math.ceil((to - from) / millisPerDay);
}

// Produces a formatted string representing a given date in a given time zone.
function getDateStringInTimeZone(format, date, timeZone) {
  date = date || new Date();
  timeZone = timeZone || AdsApp.currentAccount().getTimeZone();
  return Utilities.formatDate(date, timeZone, format);
}

/**
 * Finds a campaign by name, whether it is a regular, video, or shopping
 * campaign, by trying all in sequence until it finds one.
 *
 * @param {string} campaignName The campaign name to find.
 * @return {Object} The campaign found, or null if none was found.
 */
function getCampaign(campaignName) {
  const selectors =
      [AdsApp.campaigns(), AdsApp.videoCampaigns(), AdsApp.shoppingCampaigns()];
  for (const selector of selectors) {
    const campaignIter =
        selector.withCondition(`CampaignName = "${campaignName}"`).get();
    if (campaignIter.hasNext()) {
      return campaignIter.next();
    }
  }
  return null;
}

/**
 * Validates the provided spreadsheet URL to make sure that it's set up
 * properly. Throws a descriptive error message if validation fails.
 *
 * @param {string} spreadsheeturl The URL of the spreadsheet to open.
 * @return {Spreadsheet} The spreadsheet object itself, fetched from the URL.
 * @throws {Error} If the spreadsheet URL hasn't been set
 */
function validateAndGetSpreadsheet(spreadsheeturl) {
  if (spreadsheeturl == 'YOUR_SPREADSHEET_URL') {
    throw new Error(
        'Please specify a valid Spreadsheet URL. You can find' +
        ' a link to a template in the associated guide for this script.');
  }
  return SpreadsheetApp.openByUrl(spreadsheeturl);
}