שליחת בקשת שינוי

אחרי שראינו איך ליצור פעולות שינוי לישויות נפרדות שנדרשות ליצירת קמפיין חכם חדש, אפשר לשלב אותן לבקשה אחת שיוצרת את כולן בבת אחת.

יתרונות השימוש בבקשת שינוי יחידה הם:

• המורכבות מצטמצמת כי הישויות האלה לא משותפות ותלויות מאוד אחת בשנייה.
• מניעת קיום של ישויות שלא משויך לאף מכונה וירטואלית אם אחת מהפעולות נכשלת מסיבה כלשהי.

שימו לב שכאשר משתמשים בשמות משאבים זמניים כדי ליצור ישויות בבקשה יחידה כזו, חשוב לסדר קודם את הפעולות כך שישויות עם יחסי תלות ייווצרו קודם.

Java

/**
 * Sends a mutate request with a group of mutate operations.
 *
 * <p>The {@link GoogleAdsServiceClient} allows batching together a list of operations. These are
 * executed sequentially, and later operations my refer to previous operations via temporary IDs.
 * For more detail on this, please refer to
 * https://developers.google.com/google-ads/api/docs/batch-processing/temporary-ids.
 */
private void sendMutateRequest(
    GoogleAdsClient googleAdsClient, long customerId, List<MutateOperation> operations) {
  try (GoogleAdsServiceClient client =
      googleAdsClient.getLatestVersion().createGoogleAdsServiceClient()) {
    MutateGoogleAdsResponse outerResponse = client.mutate(String.valueOf(customerId), operations);
    for (MutateOperationResponse innerResponse :
        outerResponse.getMutateOperationResponsesList()) {
      OneofDescriptor oneofDescriptor =
          innerResponse.getDescriptorForType().getOneofs().stream()
              .filter(o -> o.getName().equals("response"))
              .findFirst()
              .get();
      Message createdEntity =
          (Message)
              innerResponse.getField(innerResponse.getOneofFieldDescriptor(oneofDescriptor));
      String resourceName =
          (String)
              createdEntity.getField(
                  createdEntity.getDescriptorForType().findFieldByName("resource_name"));
      System.out.printf(
          "Created a(n) %s with resource name: '%s'.%n",
          createdEntity.getClass().getSimpleName(), resourceName);
    }
  }
}
AddSmartCampaign.java
      

C#

// The below methods create and return MutateOperations that we later provide to
// the GoogleAdsService.Mutate method in order to create the entities in a single
// request. Since the entities for a Smart campaign are closely tied to one-another
// it's considered a best practice to create them in a single Mutate request; the
// entities will either all complete successfully or fail entirely, leaving no
// orphaned entities. See:
// https://developers.google.com/google-ads/api/docs/mutating/overview
MutateOperation campaignBudgetOperation =
    CreateCampaignBudgetOperation(customerId, suggestedBudgetAmount);
MutateOperation smartCampaignOperation =
    CreateSmartCampaignOperation(customerId);
MutateOperation smartCampaignSettingOperation =
    CreateSmartCampaignSettingOperation(customerId, businessProfileLocation,
        businessName);
IEnumerable<MutateOperation> campaignCriterionOperations =
    CreateCampaignCriterionOperations(customerId, keywordThemeInfos,
        suggestionInfo);
MutateOperation adGroupOperation = CreateAdGroupOperation(customerId);
MutateOperation adGroupAdOperation = CreateAdGroupAdOperation(customerId,
    adSuggestions);

// Send the operations in a single mutate request.
MutateGoogleAdsRequest mutateGoogleAdsRequest = new MutateGoogleAdsRequest
{
    CustomerId = customerId.ToString()
};
// It's important to create these entities in this order because they depend on
// each other, for example the SmartCampaignSetting and ad group depend on the
// campaign, and the ad group ad depends on the ad group.
mutateGoogleAdsRequest.MutateOperations.Add(campaignBudgetOperation);
mutateGoogleAdsRequest.MutateOperations.Add(smartCampaignOperation);
mutateGoogleAdsRequest.MutateOperations.Add(smartCampaignSettingOperation);
mutateGoogleAdsRequest.MutateOperations.Add(campaignCriterionOperations);
mutateGoogleAdsRequest.MutateOperations.Add(adGroupOperation);
mutateGoogleAdsRequest.MutateOperations.Add(adGroupAdOperation);

MutateGoogleAdsResponse response =
    googleAdsServiceClient.Mutate(mutateGoogleAdsRequest);

PrintResponseDetails(response);
AddSmartCampaign.cs
      

PHP

    // The below methods create and return MutateOperations that we later provide to the
    // GoogleAdsService.Mutate method in order to create the entities in a single request.
    // Since the entities for a Smart campaign are closely tied to one-another it's considered
    // a best practice to create them in a single Mutate request so they all complete
    // successfully or fail entirely, leaving no orphaned entities.
    // See: https://developers.google.com/google-ads/api/docs/mutating/overview.
    $campaignBudgetOperation = self::createCampaignBudgetOperation(
        $customerId,
        $suggestedBudgetAmount
    );
    $smartCampaignOperation = self::createSmartCampaignOperation($customerId);
    $smartCampaignSettingOperation = self::createSmartCampaignSettingOperation(
        $customerId,
        $businessProfileLocationResourceName,
        $businessName
    );
    $campaignCriterionOperations = self::createCampaignCriterionOperations(
        $customerId,
        $keywordThemeInfos,
        $suggestionInfo
    );
    $adGroupOperation = self::createAdGroupOperation($customerId);
    $adGroupAdOperation = self::createAdGroupAdOperation($customerId, $adSuggestions);

    // Issues a single mutate request to add the entities.
    $googleAdsServiceClient = $googleAdsClient->getGoogleAdsServiceClient();
    $response = $googleAdsServiceClient->mutate(MutateGoogleAdsRequest::build(
        $customerId,
        // It's important to create these entities in this order because they depend on
        // each other, for example the SmartCampaignSetting and ad group depend on the
        // campaign, and the ad group ad depends on the ad group.
        array_merge(
            [
                $campaignBudgetOperation,
                $smartCampaignOperation,
                $smartCampaignSettingOperation,
            ],
            $campaignCriterionOperations,
            [
                $adGroupOperation,
                $adGroupAdOperation
            ]
        )
    ));

    self::printResponseDetails($response);
}
AddSmartCampaign.php
      

Python

# The below methods create and return MutateOperations that we later
# provide to the GoogleAdsService.Mutate method in order to create the
# entities in a single request. Since the entities for a Smart campaign
# are closely tied to one-another it's considered a best practice to
# create them in a single Mutate request so they all complete successfully
# or fail entirely, leaving no orphaned entities. See:
# https://developers.google.com/google-ads/api/docs/mutating/overview
campaign_budget_operation = create_campaign_budget_operation(
    client, customer_id, suggested_budget_amount
)
smart_campaign_operation = create_smart_campaign_operation(
    client, customer_id
)
smart_campaign_setting_operation = create_smart_campaign_setting_operation(
    client, customer_id, business_profile_location, business_name
)
campaign_criterion_operations = create_campaign_criterion_operations(
    client, customer_id, keyword_theme_infos, suggestion_info
)
ad_group_operation = create_ad_group_operation(client, customer_id)
ad_group_ad_operation = create_ad_group_ad_operation(
    client, customer_id, ad_suggestions
)

googleads_service = client.get_service("GoogleAdsService")

# Send the operations into a single Mutate request.
response = googleads_service.mutate(
    customer_id=customer_id,
    mutate_operations=[
        # It's important to create these entities in this order because
        # they depend on each other, for example the SmartCampaignSetting
        # and ad group depend on the campaign, and the ad group ad depends
        # on the ad group.
        campaign_budget_operation,
        smart_campaign_operation,
        smart_campaign_setting_operation,
        # Expand the list of campaign criterion operations into the list of
        # other mutate operations
        *campaign_criterion_operations,
        ad_group_operation,
        ad_group_ad_operation,
    ],
)

print_response_details(response)
add_smart_campaign.py
      

Ruby

# The below methods create and return MutateOperations that we later
# provide to the GoogleAdsService.Mutate method in order to create the
# entities in a single request. Since the entities for a Smart campaign
# are closely tied to one-another it's considered a best practice to
# create them in a single Mutate request so they all complete successfully
# or fail entirely, leaving no orphaned entities. See:
# https://developers.google.com/google-ads/api/docs/mutating/overview
mutate_operations = []

# It's important to create these operations in this order because
# they depend on each other, for example the SmartCampaignSetting
# and ad group depend on the campaign, and the ad group ad depends
# on the ad group.
mutate_operations << create_campaign_budget_operation(
  client,
  customer_id,
  suggested_budget_amount,
)

mutate_operations << create_smart_campaign_operation(
  client,
  customer_id,
)

mutate_operations << create_smart_campaign_setting_operation(
  client,
  customer_id,
  business_profile_location,
  business_name,
)

mutate_operations += create_campaign_criterion_operations(
  client,
  customer_id,
  keyword_theme_infos,
  suggestion_info,
)

mutate_operations << create_ad_group_operation(client, customer_id)

mutate_operations << create_ad_group_ad_operation(
  client,
  customer_id,
  ad_suggestions
)

# Sends the operations into a single Mutate request.
response = client.service.google_ads.mutate(
  customer_id: customer_id,
  mutate_operations: mutate_operations,
)

print_response_details(response)
add_smart_campaign.rb
      

Perl

# The below methods create and return MutateOperations that we later provide to the
# GoogleAdsService.Mutate method in order to create the entities in a single
# request. Since the entities for a Smart campaign are closely tied to one-another
# it's considered a best practice to create them in a single Mutate request; the
# entities will either all complete successfully or fail entirely, leaving no
# orphaned entities. See:
# https://developers.google.com/google-ads/api/docs/mutating/overview
my $campaign_budget_operation =
  _create_campaign_budget_operation($customer_id, $suggested_budget_amount);
my $smart_campaign_operation = _create_smart_campaign_operation($customer_id);
my $smart_campaign_setting_operation =
  _create_smart_campaign_setting_operation($customer_id,
  $business_profile_location, $business_name);
my $campaign_criterion_operations =
  _create_campaign_criterion_operations($customer_id, $keyword_theme_infos,
  $suggestion_info);
my $ad_group_operation = _create_ad_group_operation($customer_id);
my $ad_group_ad_operation =
  _create_ad_group_ad_operation($customer_id, $ad_suggestions);

# It's important to create these entities in this order because they depend on
# each other. For example, the SmartCampaignSetting and ad group depend on the
# campaign and the ad group ad depends on the ad group.
my $mutate_operations = [
  $campaign_budget_operation, $smart_campaign_operation,
  $smart_campaign_setting_operation,
  # Expand the list of campaign criterion operations into the list of
  # other mutate operations.
  @$campaign_criterion_operations,
  $ad_group_operation, $ad_group_ad_operation
];

# Send the operations in a single mutate request.
my $mutate_google_ads_response = $api_client->GoogleAdsService()->mutate({
  customerId       => $customer_id,
  mutateOperations => $mutate_operations
});

_print_response_details($mutate_google_ads_response);
add_smart_campaign.pl