Google Ads API is returning to beta status. Please read our blog post for more details.

Handle Expanded Text Ad Policy Violations

PHP
<?php

/**
 * Copyright 2019 Google LLC
 *
 * 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
 *
 *     https://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.
 */

namespace Google\Ads\GoogleAds\Examples\ErrorHandling;

require __DIR__ . '/../../vendor/autoload.php';

use GetOpt\GetOpt;
use Google\Ads\GoogleAds\Examples\Utils\ArgumentNames;
use Google\Ads\GoogleAds\Examples\Utils\ArgumentParser;
use Google\Ads\GoogleAds\Lib\V3\GoogleAdsClient;
use Google\Ads\GoogleAds\Lib\V3\GoogleAdsClientBuilder;
use Google\Ads\GoogleAds\Lib\V3\GoogleAdsException;
use Google\Ads\GoogleAds\Lib\OAuth2TokenBuilder;
use Google\Ads\GoogleAds\Util\V3\ResourceNames;
use Google\Ads\GoogleAds\V3\Common\ExpandedTextAdInfo;
use Google\Ads\GoogleAds\V3\Common\PolicyTopicEntry;
use Google\Ads\GoogleAds\V3\Common\PolicyValidationParameter;
use Google\Ads\GoogleAds\V3\Enums\AdGroupAdStatusEnum\AdGroupAdStatus;
use Google\Ads\GoogleAds\V3\Enums\PolicyTopicEntryTypeEnum\PolicyTopicEntryType;
use Google\Ads\GoogleAds\V3\Errors\GoogleAdsError;
use Google\Ads\GoogleAds\V3\Resources\Ad;
use Google\Ads\GoogleAds\V3\Resources\AdGroupAd;
use Google\Ads\GoogleAds\V3\Services\AdGroupAdOperation;
use Google\Ads\GoogleAds\V3\Services\AdGroupAdServiceClient;
use Google\ApiCore\ApiException;
use Google\Protobuf\StringValue;
use GPBMetadata\Google\Ads\GoogleAds\V3\Errors\PolicyFindingError;

/**
 * This example demonstrates how to request an exemption for policy violations of an expanded text
 * ad. If the request somehow fails with exceptions that are not policy finding errors, the example
 * will stop instead of trying sending an exemption request.
 */
class HandleExpandedTextAdPolicyViolations
{
    const CUSTOMER_ID = 'INSERT_CUSTOMER_ID_HERE';
    const AD_GROUP_ID = 'INSERT_AD_GROUP_ID_HERE';

    public static function main()
    {
        // Either pass the required parameters for this example on the command line, or insert them
        // into the constants above.
        $options = (new ArgumentParser())->parseCommandArguments([
            ArgumentNames::CUSTOMER_ID => GetOpt::REQUIRED_ARGUMENT,
            ArgumentNames::AD_GROUP_ID => GetOpt::REQUIRED_ARGUMENT
        ]);

        // Generate a refreshable OAuth2 credential for authentication.
        $oAuth2Credential = (new OAuth2TokenBuilder())->fromFile()->build();

        // Construct a Google Ads client configured from a properties file and the
        // OAuth2 credentials above.
        $googleAdsClient = (new GoogleAdsClientBuilder())->fromFile()
            ->withOAuth2Credential($oAuth2Credential)
            ->build();

        try {
            self::runExample(
                $googleAdsClient,
                $options[ArgumentNames::CUSTOMER_ID] ?: self::CUSTOMER_ID,
                $options[ArgumentNames::AD_GROUP_ID] ?: self::AD_GROUP_ID
            );
        } catch (GoogleAdsException $googleAdsException) {
            printf(
                "Request with ID '%s' has failed.%sGoogle Ads failure details:%s",
                $googleAdsException->getRequestId(),
                PHP_EOL,
                PHP_EOL
            );
            foreach ($googleAdsException->getGoogleAdsFailure()->getErrors() as $error) {
                /** @var GoogleAdsError $error */
                printf(
                    "\t%s: %s%s",
                    $error->getErrorCode()->getErrorCode(),
                    $error->getMessage(),
                    PHP_EOL
                );
            }
        } catch (ApiException $apiException) {
            printf(
                "ApiException was thrown with message '%s'.%s",
                $apiException->getMessage(),
                PHP_EOL
            );
        }
    }

    /**
     * Runs the example.
     *
     * @param GoogleAdsClient $googleAdsClient the Google Ads API client
     * @param int $customerId the customer ID
     * @param int $adGroupId the ad group ID to add an expanded text ad to
     */
    public static function runExample(
        GoogleAdsClient $googleAdsClient,
        int $customerId,
        int $adGroupId
    ) {
        $adGroupResourceName =
            new StringValue(['value' => ResourceNames::forAdGroup($customerId, $adGroupId)]);

        // Creates an expanded text ad info object.
        $expandedTextAdInfo = new ExpandedTextAdInfo([
            'headline_part1' => new StringValue(['value' => 'Cruise to Mars #' . uniqid()]),
            'headline_part2' => new StringValue(['value' => 'Best Space Cruise Line']),
            // Intentionally use an ad text that violates policy -- having too many exclamation
            // marks.
            'description' => new StringValue(['value' => 'Buy your tickets now!!!!!!!'])
        ]);

        // Creates an ad group ad to hold the above ad.
        $adGroupAd = new AdGroupAd([
            'ad_group' => $adGroupResourceName,
            // Set the ad group ad to PAUSED to prevent it from immediately serving.
            // Set to ENABLED once you've added targeting and the ad are ready to serve.
            'status' => AdGroupAdStatus::PAUSED,
            // Sets the expanded text ad info on an Ad.
            'ad' => new Ad([
                'expanded_text_ad' => $expandedTextAdInfo,
                'final_urls' => [new StringValue(['value' => 'http://www.example.com'])]
            ])
        ]);

        // Creates an ad group ad operation.
        $adGroupAdOperation = new AdGroupAdOperation();
        $adGroupAdOperation->setCreate($adGroupAd);
        $adGroupAdServiceClient = $googleAdsClient->getAdGroupAdServiceClient();

        $ignorablePolicyTopics = [];
        try {
            // Try sending a mutate request to add the ad group ad.
            $adGroupAdServiceClient->mutateAdGroupAds($customerId, [$adGroupAdOperation]);
        } catch (GoogleAdsException $googleAdsException) {
            // The request will always fail because of the policy violation in the description of
            // the ad.
            $ignorablePolicyTopics = self::fetchIgnorablePolicyTopics($googleAdsException);
        }

        // Try sending exemption requests for creating an expanded text ad.
        self::requestExemption(
            $customerId,
            $adGroupAdServiceClient,
            $adGroupAdOperation,
            $ignorablePolicyTopics
        );
    }

    /**
     * Collects all ignorable policy topics that will be sent for exemption request later.
     *
     * @param GoogleAdsClient $googleAdsClient the Google Ads API client
     * @return StringValue[] the ignorable policy topics
     */
    private static function fetchIgnorablePolicyTopics(GoogleAdsException $googleAdsException)
    {
        $ignorablePolicyTopics = [];

        printf("Google Ads failure details:%s", PHP_EOL);
        foreach ($googleAdsException->getGoogleAdsFailure()->getErrors() as $error) {
            /** @var GoogleAdsError $error */
            if ($error->getErrorCode()->getErrorCode() !== 'policy_finding_error') {
                // This example supports sending exemption request for the policy finding error
                // only.
                throw $googleAdsException;
            }

            printf(
                "\t%s: %s%s",
                $error->getErrorCode()->getErrorCode(),
                $error->getMessage(),
                PHP_EOL
            );
            if (
                !is_null($error->getDetails())
                && !is_null($error->getDetails()->getPolicyFindingDetails())
            ) {
                $policyFindingDetails = $error->getDetails()->getPolicyFindingDetails();
                printf("\tPolicy finding details:%s", PHP_EOL);

                foreach ($policyFindingDetails->getPolicyTopicEntries() as $policyTopicEntry) {
                    /** @var PolicyTopicEntry $policyTopicEntry */
                    $ignorablePolicyTopics[] = $policyTopicEntry->getTopic();
                    printf(
                        "\t\tPolicy topic name: '%s'%s",
                        $policyTopicEntry->getTopicUnwrapped(),
                        PHP_EOL
                    );
                    printf(
                        "\t\tPolicy topic entry type: '%s'%s",
                        PolicyTopicEntryType::name($policyTopicEntry->getType()),
                        PHP_EOL
                    );
                    // For the sake of brevity, we exclude printing "policy topic evidences" and
                    // "policy topic constraints" here. You can fetch those data by calling:
                    // - $policyTopicEntry->getEvidences()
                    // - $policyTopicEntry->getConstraints()
                }
            }
        }
        return $ignorablePolicyTopics;
    }

    /**
     * Sends exemption requests for creating an expanded text ad.
     *
     * @param int $customerId
     * @param AdGroupAdServiceClient $adGroupAdServiceClient
     * @param AdGroupAdOperation $adGroupAdOperation
     * @param StringValue[] $ignorablePolicyTopics
     */
    private static function requestExemption(
        int $customerId,
        AdGroupAdServiceClient $adGroupAdServiceClient,
        AdGroupAdOperation $adGroupAdOperation,
        array $ignorablePolicyTopics
    ) {
        print "Try adding an expanded text ad again by requesting exemption for its policy"
            . " violations." . PHP_EOL;
        $adGroupAdOperation->setPolicyValidationParameter(
            new PolicyValidationParameter(['ignorable_policy_topics' => $ignorablePolicyTopics])
        );
        $response = $adGroupAdServiceClient->mutateAdGroupAds(
            $customerId,
            [$adGroupAdOperation]
        );
        printf(
            "Successfully added an expanded text ad with resource name '%s' by requesting"
            . " for policy violation exemption.%s",
            $response->getResults()[0]->getResourceName(),
            PHP_EOL
        );
    }
}

HandleExpandedTextAdPolicyViolations::main();
Perl
#!/usr/bin/perl -w
#
# Copyright 2019, Google LLC
#
# 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.
#
# This example demonstrates how to request an exemption for policy violations
# of an expanded text ad. If the request somehow fails with exceptions that are
# not policy finding errors, the example will stop instead of trying sending an
# exemption request.

use strict;
use warnings;
use utf8;

use FindBin qw($Bin);
use lib "$Bin/../../lib";
use Google::Ads::GoogleAds::Client;
use Google::Ads::GoogleAds::Utils::GoogleAdsHelper;
use Google::Ads::GoogleAds::V3::Resources::AdGroupAd;
use Google::Ads::GoogleAds::V3::Resources::Ad;
use Google::Ads::GoogleAds::V3::Common::ExpandedTextAdInfo;
use Google::Ads::GoogleAds::V3::Common::PolicyValidationParameter;
use Google::Ads::GoogleAds::V3::Enums::AdGroupStatusEnum qw(PAUSED);
use Google::Ads::GoogleAds::V3::Services::AdGroupAdService::AdGroupAdOperation;
use Google::Ads::GoogleAds::V3::Utils::ResourceNames;

use Getopt::Long qw(:config auto_help);
use Pod::Usage;
use Cwd qw(abs_path);
use Data::Uniqid qw(uniqid);

# The following parameter(s) should be provided to run the example. You can
# either specify these by changing the INSERT_XXX_ID_HERE values below, or on
# the command line.
#
# Parameters passed on the command line will override any parameters set in
# code.
#
# Running the example with -h will print the command line usage.
my $customer_id = "INSERT_CUSTOMER_ID_HERE";
my $ad_group_id = "INSERT_AD_GROUP_ID_HERE";

sub handle_expanded_text_ad_policy_violations {
  my ($api_client, $customer_id, $ad_group_id) = @_;

  my $ad_group_resource_name =
    Google::Ads::GoogleAds::V3::Utils::ResourceNames::ad_group($customer_id,
    $ad_group_id);

  # Create an expanded text ad info object.
  my $expanded_text_ad_info =
    Google::Ads::GoogleAds::V3::Common::ExpandedTextAdInfo->new({
      headlinePart1 => "Cruise to Mars #" . uniqid(),
      headlinePart2 => "Best Space Cruise Line",
      # Intentionally use an ad text that violates policy -- having too many
      # exclamation marks.
      description => "Buy your tickets now!!!!!!!"
    });

  # Create an ad group ad to hold the above ad.
  my $ad_group_ad = Google::Ads::GoogleAds::V3::Resources::AdGroupAd->new({
      adGroup => $ad_group_resource_name,
      # Set the ad group ad to PAUSED to prevent it from immediately serving.
      # Set to ENABLED once you've added targeting and the ad are ready to serve.
      status => PAUSED,
      # Set the expanded text ad info on an ad.
      ad => Google::Ads::GoogleAds::V3::Resources::Ad->new({
          expandedTextAd => $expanded_text_ad_info,
          finalUrls      => ["http://www.example.com"]})});

  # Create an ad group ad operation.
  my $ad_group_ad_operation =
    Google::Ads::GoogleAds::V3::Services::AdGroupAdService::AdGroupAdOperation
    ->new({
      create => $ad_group_ad
    });

  # Try sending a mutate request to add the ad group ad.
  my $response = $api_client->AdGroupAdService()->mutate({
      customerId => $customer_id,
      operations => [$ad_group_ad_operation]});

  my $ignorable_policy_topics = [];
  if ($response->isa("Google::Ads::GoogleAds::GoogleAdsException")) {
    # The request will always fail because of the policy violation in the
    # description of the ad.
    $ignorable_policy_topics = fetch_ignorable_policy_topics($response);
  }

  # Try sending exemption requests for creating an expanded text ad.
  request_exemption($api_client, $customer_id, $ad_group_ad_operation,
    $ignorable_policy_topics);

  return 1;
}

# Collects all ignorable policy topics that will be sent for exemption request
# later.
sub fetch_ignorable_policy_topics {
  my $google_ads_exception = shift;

  my $ignorable_policy_topics = [];

  printf "Google Ads failure details:\n";
  foreach
    my $error (@{$google_ads_exception->get_google_ads_failure()->{errors}})
  {
    if ([keys %{$error->{errorCode}}]->[0] ne "policyFindingError") {
      # This example supports sending exemption request for the policy finding
      # error only.
      die $google_ads_exception->get_message();
    }

    printf "\t%s: %s\n", [keys %{$error->{errorCode}}]->[0], $error->{message};

    if ($error->{details}{policyFindingDetails}) {
      my $policy_finding_details = $error->{details}{policyFindingDetails};
      printf "\tPolicy finding details:\n";

      foreach my $policy_topic_entry (
        @{$policy_finding_details->{policyTopicEntries}})
      {
        push @$ignorable_policy_topics, $policy_topic_entry->{topic};
        printf
          "\t\tPolicy topic name: '%s'\n",
          $policy_topic_entry->{topic};
        printf "\t\tPolicy topic entry type: '%s'\n",
          $policy_topic_entry->{type};
        # For the sake of brevity, we exclude printing "policy topic evidences" and
        # "policy topic constraints" here. You can fetch those data by calling:
        # - $policy_topic_entry->{evidences}
        # - $policy_topic_entry->{constraints}
      }
    }
  }

  return $ignorable_policy_topics;
}

# Sends exemption requests for creating an expanded text ad.
sub request_exemption {
  my ($api_client, $customer_id, $ad_group_ad_operation,
    $ignorable_policy_topics)
    = @_;

  print
    "Try adding an expanded text ad again by requesting exemption for its " .
    "policy violations.\n";

  $ad_group_ad_operation->{policyValidationParameter} =
    Google::Ads::GoogleAds::V3::Common::PolicyValidationParameter->new(
    {ignorablePolicyTopics => $ignorable_policy_topics});

  my $ad_group_ad_response = $api_client->AdGroupAdService()->mutate({
      customerId => $customer_id,
      operations => [$ad_group_ad_operation]});

  printf "Successfully added an expanded text ad with resource name '%s' by " .
    "requesting for policy violation exemption.\n",
    $ad_group_ad_response->{results}[0]{resourceName};
}

# Don't run the example if the file is being included.
if (abs_path($0) ne abs_path(__FILE__)) {
  return 1;
}

# Get Google Ads Client, credentials will be read from ~/googleads.properties.
my $api_client = Google::Ads::GoogleAds::Client->new({version => "V3"});

# By default examples are set to die on any server returned fault.
$api_client->set_die_on_faults(0);

# Parameters passed on the command line will override any parameters set in code.
GetOptions(
  "customer_id=s" => \$customer_id,
  "ad_group_id=i" => \$ad_group_id
);

# Print the help message if the parameters are not initialized in the code nor
# in the command line.
pod2usage(2) if not check_params($customer_id, $ad_group_id);

# Call the example.
handle_expanded_text_ad_policy_violations($api_client, $customer_id =~ s/-//gr,
  $ad_group_id);

=pod

=head1 NAME

handle_expanded_text_ad_policy_violations

=head1 DESCRIPTION

This example demonstrates how to request an exemption for policy violations of an
expanded text ad. If the request somehow fails with exceptions that are not policy
finding errors, the example will stop instead of trying sending an exemption request.

=head1 SYNOPSIS

handle_expanded_text_ad_policy_violations.pl [options]

    -help                       Show the help message.
    -customer_id                The Google Ads customer ID.
    -ad_group_id                The ad group ID.

=cut