Add Remarketing Action

C#

// Copyright 2020 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.


using Google.Ads.GoogleAds.Lib;
using Google.Ads.GoogleAds.V4.Common;
using Google.Ads.GoogleAds.V4.Errors;
using Google.Ads.GoogleAds.V4.Resources;
using Google.Ads.GoogleAds.V4.Services;

using System;
using System.Linq;

namespace Google.Ads.GoogleAds.Examples.V4
{
    /// <summary>
    /// This code example adds a new remarketing action to the customer and then retrieves its
    /// associated tag snippets.
    /// </summary>
    public class AddRemarketingAction : ExampleBase
    {
        /// <summary>
        /// Main method, to run this code example as a standalone application.
        /// </summary>
        /// <param name="args">The command line arguments.</param>
        public static void Main(string[] args)
        {
            AddRemarketingAction codeExample = new AddRemarketingAction();
            Console.WriteLine(codeExample.Description);

            // The Google Ads customer ID for which the call is made.
            long customerId = long.Parse("INSERT_CUSTOMER_ID_HERE");

            codeExample.Run(new GoogleAdsClient(), customerId);
        }

        /// <summary>
        /// Returns a description about the code example.
        /// </summary>
        public override string Description
        {
            get
            {
                return "This code example adds a new remarketing action to the customer and then" +
                    " retrieves its associated tag snippets.";
            }
        }

        /// <summary>
        /// Runs the code example.
        /// </summary>
        /// <param name="client">The Google Ads client.</param>
        /// <param name="customerId">The Google Ads customer ID for the conversion action is
        /// added.</param>
        public void Run(GoogleAdsClient client, long customerId)
        {
            // Get the RemarketingActionService.
            RemarketingActionServiceClient remarketingActionService =
                client.GetService(Services.V4.RemarketingActionService);

            // Get the GoogleAdsService.
            GoogleAdsServiceClient googleAdsService =
                client.GetService(Services.V4.GoogleAdsService);

            try
            {
                // Creates a remarketing action with the specified name.
                RemarketingAction remarketingAction = new RemarketingAction()
                {
                    Name = $"Remarketing action # {ExampleUtilities.GetRandomString()}"
                };
                // Creates a remarketing action operation.
                RemarketingActionOperation remarketingActionOperation =
                    new RemarketingActionOperation()
                    {
                        Create = remarketingAction
                    };

                // Issues a mutate request to add the remarketing action and prints out
                // some information.
                MutateRemarketingActionsResponse response =
                    remarketingActionService.MutateRemarketingActions(
                        customerId.ToString(), new[] { remarketingActionOperation });

                string remarketingActionResourceName = response.Results[0].ResourceName;

                Console.WriteLine($"Added remarketing action with resource name " +
                    $"'{remarketingActionResourceName}'.");

                // Creates a query that retrieves the previously created remarketing action
                // with its generated tag snippets.
                var query = $"SELECT remarketing_action.id, remarketing_action.name, " +
                    $"remarketing_action.tag_snippets FROM remarketing_action " +
                    $"WHERE remarketing_action.resource_name = '{remarketingActionResourceName}'";

                // Issues a search request and retrieve the results. There is only one row
                // because we limited the search using the resource name, which is unique.
                RemarketingAction result = googleAdsService.Search(customerId.ToString(), query)
                    .First()
                    .RemarketingAction;

                // Display the result.
                Console.WriteLine($"Remarketing action has ID {result.Id} and name" +
                    $" '{result.Id}'.");

                Console.WriteLine("It has the following generated tag snippets:");
                foreach (TagSnippet tagSnippet in result.TagSnippets)
                {
                    Console.WriteLine($"Tag snippet with code type '{tagSnippet.Type}' and code " +
                        $"page format '{tagSnippet.PageFormat}' has the following global site " +
                        $"tag:{tagSnippet.GlobalSiteTag} \n\nand the following event snippet:" +
                        $"{tagSnippet.EventSnippet}.");
                }
            }
            catch (GoogleAdsException e)
            {
                Console.WriteLine("Failure:");
                Console.WriteLine($"Message: {e.Message}");
                Console.WriteLine($"Failure: {e.Failure}");
                Console.WriteLine($"Request ID: {e.RequestId}");
                throw;
            }
        }
    }
}

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\Remarketing;

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\V4\GoogleAdsClient;
use Google\Ads\GoogleAds\Lib\V4\GoogleAdsClientBuilder;
use Google\Ads\GoogleAds\Lib\V4\GoogleAdsException;
use Google\Ads\GoogleAds\Lib\OAuth2TokenBuilder;
use Google\Ads\GoogleAds\V4\Common\TagSnippet;
use Google\Ads\GoogleAds\V4\Enums\TrackingCodePageFormatEnum\TrackingCodePageFormat;
use Google\Ads\GoogleAds\V4\Enums\TrackingCodeTypeEnum\TrackingCodeType;
use Google\Ads\GoogleAds\V4\Errors\GoogleAdsError;
use Google\Ads\GoogleAds\V4\Resources\RemarketingAction;
use Google\Ads\GoogleAds\V4\Services\GoogleAdsRow;
use Google\Ads\GoogleAds\V4\Services\RemarketingActionOperation;
use Google\ApiCore\ApiException;
use Google\Protobuf\StringValue;

/**
 * This example adds a new remarketing action to the customer and then retrieves its associated
 * tag snippets.
 */
class AddRemarketingAction
{
    private const PAGE_SIZE = 1000;

    private const CUSTOMER_ID = 'INSERT_CUSTOMER_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
        ]);

        // 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
            );
        } 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
                );
            }
            exit(1);
        } catch (ApiException $apiException) {
            printf(
                "ApiException was thrown with message '%s'.%s",
                $apiException->getMessage(),
                PHP_EOL
            );
            exit(1);
        }
    }

    /**
     * Runs the example.
     *
     * @param GoogleAdsClient $googleAdsClient the Google Ads API client
     * @param int $customerId the customer ID
     */
    public static function runExample(GoogleAdsClient $googleAdsClient, int $customerId)
    {
        // Creates a remarketing action with the specified name.
        $remarketingAction = new RemarketingAction([
            'name' => new StringValue(['value' => 'Remarketing action #' . uniqid()])
        ]);

        // Creates a remarketing action operation.
        $remarketingActionOperation =
            new RemarketingActionOperation(['create' => $remarketingAction]);

        // Issues a mutate request to add the remarketing action and prints out some information.
        $remarketingActionServiceClient = $googleAdsClient->getRemarketingActionServiceClient();
        $response = $remarketingActionServiceClient->mutateRemarketingActions(
            $customerId,
            [$remarketingActionOperation]
        );
        $remarketingActionResourceName = $response->getResults()[0]->getResourceName();
        printf(
            "Added remarketing action with resource name '%s'.%s",
            $remarketingActionResourceName,
            PHP_EOL
        );

        // Creates a query that retrieves the previously created remarketing action with its
        // generated tag snippets.
        $query =
            "SELECT remarketing_action.id, "
            . "remarketing_action.name, "
            . "remarketing_action.tag_snippets "
            . "FROM remarketing_action "
            . "WHERE remarketing_action.resource_name = '$remarketingActionResourceName'";

        // Issues a search request by specifying page size.
        $googleAdsServiceClient = $googleAdsClient->getGoogleAdsServiceClient();
        $response =
            $googleAdsServiceClient->search($customerId, $query, ['pageSize' => self::PAGE_SIZE]);

        // There is only one row because we limited the search using the resource name, which is
        // unique.
        /** @var GoogleAdsRow $googleAdsRow */
        $googleAdsRow = $response->iterateAllElements()->current();

        // Prints some attributes of the remarketing action. The ID and tag snippets are generated
        // by the API.
        printf(
            "Remarketing action has ID %d and name '%s'.%s%s",
            $googleAdsRow->getRemarketingAction()->getIdUnwrapped(),
            $googleAdsRow->getRemarketingAction()->getNameUnwrapped(),
            PHP_EOL,
            PHP_EOL
        );
        print 'It has the following generated tag snippets:' . PHP_EOL;
        foreach ($googleAdsRow->getRemarketingAction()->getTagSnippets() as $tagSnippet) {
            /** @var TagSnippet $tagSnippet */
            printf(
                "Tag snippet with code type '%s' and code page format '%s' has the following"
                . " global site tag:%s%s%s",
                TrackingCodeType::name($tagSnippet->getType()),
                TrackingCodePageFormat::name($tagSnippet->getPageFormat()),
                PHP_EOL,
                $tagSnippet->getGlobalSiteTagUnwrapped(),
                PHP_EOL
            );
            printf(
                "and the following event snippet:%s%s%s%s",
                PHP_EOL,
                $tagSnippet->getEventSnippetUnwrapped(),
                PHP_EOL,
                PHP_EOL
            );
        }
    }
}

AddRemarketingAction::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 adds a new remarketing action to the customer and then retrieves
# its associated tag snippets.

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::V4::Resources::RemarketingAction;
use
  Google::Ads::GoogleAds::V4::Services::RemarketingActionService::RemarketingActionOperation;

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

use constant PAGE_SIZE => 1000;

# 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";

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

  # Create a remarketing action with the specified name.
  my $remarketing_action =
    Google::Ads::GoogleAds::V4::Resources::RemarketingAction->new({
      name => "Remarketing action #" . uniqid()});

  # Create a remarketing action operation.
  my $remarketing_action_operation =
    Google::Ads::GoogleAds::V4::Services::RemarketingActionService::RemarketingActionOperation
    ->new({
      create => $remarketing_action
    });

  # Issue a mutate request to add the remarketing action and print out some information.
  my $remarketing_action_response =
    $api_client->RemarketingActionService()->mutate({
      customerId => $customer_id,
      operations => [$remarketing_action_operation]});

  my $remarketing_action_resource_name =
    $remarketing_action_response->{results}[0]{resourceName};
  printf
    "Added remarketing action with resource name '%s'.\n",
    $remarketing_action_resource_name;

  # Create a query that retrieves the previously created remarketing action with
  # its generated tag snippets.
  my $search_query =
    sprintf "SELECT remarketing_action.id, remarketing_action.name, " .
    "remarketing_action.tag_snippets FROM remarketing_action " .
    "WHERE remarketing_action.resource_name = '%s'",
    $remarketing_action_resource_name;

  # Issue a search request by specifying page size.
  my $search_response = $api_client->GoogleAdsService()->search({
    customerId => $customer_id,
    query      => $search_query,
    pageSize   => PAGE_SIZE
  });

  # There is only one row because we limited the search using the resource name,
  # which is unique.
  my $google_ads_row = $search_response->{results}[0];

  # Print some attributes of the remarketing action. The ID and tag snippets are
  # generated by the API.
  printf
    "Remarketing action has ID %d and name '%s'.\n\n",
    $google_ads_row->{remarketingAction}{id},
    $google_ads_row->{remarketingAction}{name};

  print "It has the following generated tag snippets:\n";

  foreach my $tag_snippet (@{$google_ads_row->{remarketingAction}{tagSnippets}})
  {
    printf "Tag snippet with code type '%s' and code page format '%s' " .
      "has the following global site tag:\n%s\n",
      $tag_snippet->{type},
      $tag_snippet->{pageFormat},
      $tag_snippet->{globalSiteTag};

    printf "and the following event snippet:\n%s\n\n",
      $tag_snippet->{eventSnippet};
  }

  return 1;
}

# 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();

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

# Parameters passed on the command line will override any parameters set in code.
GetOptions("customer_id=s" => \$customer_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);

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

=pod

=head1 NAME

add_remarketing_action

=head1 DESCRIPTION

This example adds a new remarketing action to the customer and then retrieves its
associated tag snippets.

=head1 SYNOPSIS

add_remarketing_action.pl [options]

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

=cut