/// <summary> /// Creates the campaign draft. /// </summary> /// <param name="client">The Google Ads client.</param> /// <param name="customerId">The Google Ads customer ID for which the call is made.</param> /// <param name="baseCampaignId">The base campaign ID.</param> /// <returns>The resource name of the newly created campaign draft.</returns> internal static string CreateCampaignDraft(GoogleAdsClient client, long customerId, long baseCampaignId) { // Get the CampaignDraftService. CampaignDraftServiceClient campaignDraftService = client.GetService(Services.V6.CampaignDraftService); CampaignDraft campaignDraft = new CampaignDraft() { BaseCampaign = ResourceNames.Campaign(customerId, baseCampaignId), Name = "Campaign Draft #" + ExampleUtilities.GetRandomString(), }; CampaignDraftOperation operation = new CampaignDraftOperation() { Create = campaignDraft }; MutateCampaignDraftsResponse response = campaignDraftService.MutateCampaignDrafts( customerId.ToString(), new CampaignDraftOperation[] { operation }); return(response.Results[0].ResourceName); }
/// <summary> /// Creates a new CampaignGroup in the specified client account. /// </summary> /// <param name="client">The Google Ads API client.</param> /// <param name="customerId">The Google Ads customer ID for which the call is made.</param> /// <returns>resource name of the newly created campaign group.</returns> private static String CreateCampaignGroup(GoogleAdsClient client, long customerId) { CampaignGroupServiceClient campaignGroupService = client.GetService( Services.V0.CampaignGroupService); CampaignGroup campaignGroup = new CampaignGroup() { Name = "Mars campaign group #" + ExampleUtilities.GetRandomString() }; CampaignGroupOperation op = new CampaignGroupOperation() { Create = campaignGroup }; MutateCampaignGroupsResponse response = campaignGroupService.MutateCampaignGroups( customerId.ToString(), new CampaignGroupOperation[] { op }); String groupResourceName = response.Results[0].ResourceName; Console.WriteLine($"Added campaign group with resource name: {groupResourceName}"); return(groupResourceName); }
/// <summary> /// Runs the code example. /// </summary> /// <param name="client">The Google Ads client.</param> /// <param name="customerId">The Google Ads customer ID for which the call is made.</param> /// <param name="baseCampaignId">ID of the base campaign.</param> /// <param name="draftId">ID of the draft campaign.</param> public void Run(GoogleAdsClient client, long customerId, long baseCampaignId, long draftId) { try { string campaignDraftResourceName = ResourceNames.CampaignDraft( customerId, baseCampaignId, draftId); Operation <Empty, CreateCampaignExperimentMetadata> operation = CreateExperiment(client, customerId, campaignDraftResourceName); Console.WriteLine("Waiting until operation completes..."); operation.PollUntilCompleted(); DisplayExperimentDetails(client, customerId, operation.Metadata.CampaignExperiment); } catch (GoogleAdsException e) { Console.WriteLine("Failure:"); Console.WriteLine($"Message: {e.Message}"); Console.WriteLine($"Failure: {e.Failure}"); Console.WriteLine($"Request ID: {e.RequestId}"); throw; } }
/// <summary> /// Creates a keyword. /// </summary> /// <param name="client">The Google Ads client.</param> /// <param name="adGroupResourceName">The resource name of the ad group to which keyword /// is added.</param> /// <returns>The resource name of the newly created keyword.</returns> internal static string CreateKeyword(GoogleAdsClient client, string adGroupResourceName) { AdGroupCriterion criterion = new AdGroupCriterion() { AdGroup = adGroupResourceName, Status = AdGroupCriterionStatus.Enabled, Keyword = new KeywordInfo() { Text = $"mars cruise #{DateTime.Now.Ticks}", MatchType = KeywordMatchType.Exact } }; MutateOperation mutateOperation = new MutateOperation() { AdGroupCriterionOperation = new AdGroupCriterionOperation() { Create = criterion } }; return(ExecuteOperations(client, new[] { mutateOperation }).First() .AdGroupCriterionResult.ResourceName); }
/// <summary> /// Gets the Affiliate Location Extension feed mapping. /// </summary> /// <param name="client">The Google Ads client.</param> /// <param name="customerId">The customer ID for which the call is made.</param> /// <param name="feedResourceName">The feed resource name.</param> /// <returns>The newly created feed mapping.</returns> private static FeedMapping GetAffiliateLocationExtensionFeedMapping(GoogleAdsClient client, long customerId, string feedResourceName) { // Get the GoogleAdsService. GoogleAdsServiceClient googleAdsService = client.GetService( Services.V4.GoogleAdsService); // Create the query. string query = $"SELECT feed_mapping.resource_name, " + $"feed_mapping.attribute_field_mappings, feed_mapping.status FROM " + $"feed_mapping WHERE feed_mapping.feed = '{feedResourceName}' and " + $"feed_mapping.status = ENABLED and feed_mapping.placeholder_type = " + "AFFILIATE_LOCATION LIMIT 1"; // Issue a search request. PagedEnumerable <SearchGoogleAdsResponse, GoogleAdsRow> result = googleAdsService.Search(customerId.ToString(), query); // Display the results. GoogleAdsRow googleAdsRow = result.FirstOrDefault(); return((googleAdsRow == null) ? null : googleAdsRow.FeedMapping); }
/// <summary> /// Retrieves a feed item and its attribute values given a resource name. /// </summary> /// <param name="client">The Google Ads API client.</param> /// <param name="customerId">The client customer ID.</param> /// <param name="feedId">The feed ID that contains the target feed item.</param> /// <param name="feedItemId">The feed item ID that will be updated.</param> /// <returns>FeedItem with the given resource name.</returns> private FeedItem GetFeedItem(GoogleAdsClient client, long customerId, long feedId, long feedItemId) { // Gets the Google Ads service. GoogleAdsServiceClient googleAdsServiceClient = client.GetService( Services.V5.GoogleAdsService); // Constructs the resource name for the feed item. string feedItemResourceName = ResourceNames.FeedItem(customerId, feedId, feedItemId); // Constructs the query. string query = $@" SELECT feed_item.attribute_values FROM feed_item WHERE feed_item.resource_name = '{feedItemResourceName}'"; // Issues the search request. PagedEnumerable <SearchGoogleAdsResponse, GoogleAdsRow> searchResponse = googleAdsServiceClient.Search(customerId.ToString(), query); // Returns the feed item attribute values. return(searchResponse.First().FeedItem); }
/// <summary> /// Creates feed items, which fill out the feed table with data. /// </summary> /// <param name="client">The Google Ads client.</param> /// <param name="customerId">The customer ID for which the call is made.</param> /// <param name="feed">The feed for which the operation will be created.</param> /// <returns>A list of string Feed Item Resource Names.</returns> private List <string> CreateFeedItems(GoogleAdsClient client, long customerId, Feed feed) { FeedItemServiceClient feedItemService = client.GetService(Services.V4.FeedItemService); List <FeedItemOperation> operations = new List <FeedItemOperation> { NewFeedItemOperation(feed, "Home", "http://www.example.com", "Home line 1", "Home line 2"), NewFeedItemOperation(feed, "Stores", "http://www.example.com/stores", "Stores line 1", "Stores line 2"), NewFeedItemOperation(feed, "On Sale", "http://www.example.com/sale", "On Sale line 1", "On Sale line 2"), NewFeedItemOperation(feed, "Support", "http://www.example.com/support", "Support line 1", "Support line 2"), NewFeedItemOperation(feed, "Products", "http://www.example.com/catalogue", "Products line 1", "Products line 2"), NewFeedItemOperation(feed, "About Us", "http://www.example.com/about", "About Us line 1", "About Us line 2") }; MutateFeedItemsResponse response = feedItemService.MutateFeedItems(customerId.ToString(), operations); // We will need the resource name of each feed item to use in targeting. List <string> feedItemResourceNames = new List <string>(); Console.WriteLine("Created the following feed items:"); foreach (MutateFeedItemResult feedItemResult in response.Results) { Console.WriteLine($"\t{feedItemResult.ResourceName}"); feedItemResourceNames.Add(feedItemResult.ResourceName); } return(feedItemResourceNames); }
/// <summary>Adds an expanded dynamic search ad.</summary> /// <param name="client">The Google Ads client.</param> /// <param name="customerId">The Google Ads customer ID for which the call is made.</param> /// <param name="adGroupResourceName">The ad group resource name.</param> private static void AddExpandedDSA(GoogleAdsClient client, long customerId, string adGroupResourceName) { // Get the AdGroupAdService. AdGroupAdServiceClient adGroupAdService = client.GetService(Services.V4.AdGroupAdService); // Create an ad group ad. AdGroupAd adGroupAd = new AdGroupAd() { AdGroup = adGroupResourceName, Status = AdGroupAdStatus.Paused, // Set the ad as an expanded dynamic search ad. Ad = new Ad() { ExpandedDynamicSearchAd = new ExpandedDynamicSearchAdInfo() { Description = "Buy tickets now!" } } }; // Create the operation. AdGroupAdOperation operation = new AdGroupAdOperation() { Create = adGroupAd }; // Add the dynamic search ad. MutateAdGroupAdsResponse response = adGroupAdService.MutateAdGroupAds( customerId.ToString(), new AdGroupAdOperation[] { operation }); // Display the response. Console.WriteLine($"Added ad group ad with resource name " + $"'{response.Results[0].ResourceName}'."); }
// [END add_shopping_product_ad] /// <summary> /// Creates a new default shopping listing group for the specified ad group. A listing /// group is the Google Ads API representation of a "product group" described in the /// Google Ads user interface. The listing group will be added to the ad group using an /// "ad group criterion". /// </summary> /// <param name="client">The Google Ads API client.</param> /// <param name="customerId">The client customer ID.</param> /// <param name="adGroupResourceName">The resource name of the ad group that the new /// listing group will belong to.</param> /// <returns>Resource name of the newly created ad group criterion containing the /// listing group.</returns> /// <exception cref="GoogleAdsException">Thrown if an API request failed with one or more /// service errors.</exception> private string AddDefaultShoppingListingGroup(GoogleAdsClient client, long customerId, string adGroupResourceName) { // Get the AdGroupCriterionService. AdGroupCriterionServiceClient adGroupCriterionService = client.GetService( Services.V10.AdGroupCriterionService); // Creates a new ad group criterion. This will contain the "default" listing group (All // products). AdGroupCriterion adGroupCriterion = new AdGroupCriterion() { AdGroup = adGroupResourceName, Status = AdGroupCriterionStatus.Enabled, // Creates a new listing group. This will be the top-level "root" node. // Set the type of the listing group to be a biddable unit. ListingGroup = new ListingGroupInfo() { Type = ListingGroupType.Unit }, // Set the bid for products in this listing group unit. CpcBidMicros = 500_000L }; AdGroupCriterionOperation operation = new AdGroupCriterionOperation() { Create = adGroupCriterion }; MutateAdGroupCriterionResult mutateAdGroupCriteriaResult = adGroupCriterionService.MutateAdGroupCriteria(customerId.ToString(), new AdGroupCriterionOperation[] { operation }).Results[0]; Console.WriteLine("Added an ad group criterion containing a listing group with " + "resource name: '{0}'.", mutateAdGroupCriteriaResult.ResourceName); return(mutateAdGroupCriteriaResult.ResourceName); }
/// <summary> /// Runs the code example. /// </summary> /// <param name="client">The Google Ads client.</param> /// <param name="customerId">The Google Ads customer ID for which the call is made.</param> public void Run(GoogleAdsClient client, long customerId) { // Get the GoogleAdsService. GoogleAdsServiceClient googleAdsService = client.GetService( Services.V4.GoogleAdsService); // Create a query that will retrieve all campaigns. string query = @"SELECT campaign.id, campaign.name, campaign.network_settings.target_content_network FROM campaign ORDER BY campaign.id"; try { // Issue a search request. googleAdsService.SearchStream(customerId.ToString(), query, delegate(SearchGoogleAdsStreamResponse resp) { foreach (GoogleAdsRow googleAdsRow in resp.Results) { Console.WriteLine("Campaign with ID {0} and name '{1}' was found.", googleAdsRow.Campaign.Id, googleAdsRow.Campaign.Name); } } ); } catch (GoogleAdsException e) { Console.WriteLine("Failure:"); Console.WriteLine($"Message: {e.Message}"); Console.WriteLine($"Failure: {e.Failure}"); Console.WriteLine($"Request ID: {e.RequestId}"); throw; } }
/// <summary> /// Runs the code example. /// </summary> /// <param name="client">The Google Ads client.</param> /// <param name="customerId">The Google Ads customer ID for which the call is made.</param> /// <param name="merchantCenterAccountId">The Merchant Center account ID.</param> /// <param name="createDefaultListingGroup">The boolean to indicate if a default listing /// group should be created for the ad group. Set to false if the listing group will be /// constructed elsewhere. /// /// See AddShoppingListingGroupTree for a more comprehensive example.</param> public void Run(GoogleAdsClient client, long customerId, long merchantCenterAccountId, bool createDefaultListingGroup) { try { // Creates a budget to be used by the campaign that will be created below. string budgetResourceName = AddCampaignBudget(client, customerId); // Creates a Smart Shopping campaign. string campaignResourceName = AddSmartShoppingCampaign( client, customerId, budgetResourceName, merchantCenterAccountId); // Creates a Smart Shopping ad group. string adGroupResourceName = AddSmartShoppingAdGroup( client, customerId, campaignResourceName); // Creates a Smart Shopping ad group ad. AddSmartShoppingAdGroupAd(client, customerId, adGroupResourceName); if (createDefaultListingGroup) { // A product group is a subset of inventory. Listing groups are the equivalent // of product groups in the API and allow you to bid on the chosen group or // exclude a group from bidding. This method creates an ad group criterion // containing a listing group. AddDefaultShoppingListingGroup(client, customerId, adGroupResourceName); } } catch (GoogleAdsException e) { Console.WriteLine("Failure:"); Console.WriteLine($"Message: {e.Message}"); Console.WriteLine($"Failure: {e.Failure}"); Console.WriteLine($"Request ID: {e.RequestId}"); throw; } }
// [END setup_remarketing_2] /// <summary> /// Creates a campaign criterion that targets a user list with a campaign. /// </summary> /// <param name="client">The Google Ads API client.</param> /// <param name="customerId">The Google Ads customer ID for which the call is made.</param> /// <param name="campaignId">The campaign on which the user list will be targeted.</param> /// <param name="userListResourceName">The resource name of the user list to be /// targeted.</param> /// <returns>The resource name of the newly created campaign criterion.</returns> // [START setup_remarketing_4] private string TargetAdsInCampaignToUserList( GoogleAdsClient client, long customerId, long campaignId, string userListResourceName) { // Get the CampaignCriterionService client. CampaignCriterionServiceClient campaignCriterionServiceClient = client.GetService(Services.V10.CampaignCriterionService); // Create the campaign criterion. CampaignCriterion campaignCriterion = new CampaignCriterion { Campaign = ResourceNames.Campaign(customerId, campaignId), UserList = new UserListInfo { UserList = userListResourceName } }; // Create the operation. CampaignCriterionOperation campaignCriterionOperation = new CampaignCriterionOperation { Create = campaignCriterion }; // Add the campaign criterion and print the resulting criterion's resource name. MutateCampaignCriteriaResponse mutateCampaignCriteriaResponse = campaignCriterionServiceClient.MutateCampaignCriteria(customerId.ToString(), new[] { campaignCriterionOperation }); string campaignCriterionResourceName = mutateCampaignCriteriaResponse.Results.First().ResourceName; Console.WriteLine("Successfully created campaign criterion with resource name " + $"'{campaignCriterionResourceName}' targeting user list with resource name " + $"'{userListResourceName}' with campaign with ID {campaignId}."); return(campaignCriterionResourceName); }
/// <summary> /// Runs the examples from command line arguments. /// </summary> /// <param name="args">The command line arguments.</param> /// <returns>The application's exit code. The valid return codes are: /// /// <list type="bullet"> /// <item><description>0. The code example ran successfully.</description></item> /// <item><description>1. The code example threw an exception and did not complete /// successfully.</description></item> /// <item><description>2. The application was invoked with an incorrect command line /// argument.</description></item> /// </list> /// </returns> private static int RunExamplesFromCommandLineArguments(string[] args) { ExampleRunner runner = new ExampleRunner(); runner.LoadCodeExamples(Assembly.GetExecutingAssembly()); if (args.Length == 0) { // Bad command line parameter. ShowUsage(runner); return(2); } GoogleAdsClient session = new GoogleAdsClient(); string exampleName = args[0]; try { runner.Run(exampleName, session, args.Skip(1)); return(0); } catch (TargetInvocationException) { // Indicates a failure due to an unhandled exception. return(1); } catch (Exception e) when(e is KeyNotFoundException || e is ArgumentException || e is TargetParameterCountException) { // Bad command line parameter. // Note: There are a couple more exceptions that the runner may throw, but all // those indicate a failure with the runner implementation than a code example // failure. ShowUsage(runner); return(2); } }
/// <summary> /// Creates a new hotel ad group ad in the specified ad group. /// </summary> /// <param name="client">The Google Ads client.</param> /// <param name="customerId">The Google Ads customer ID for which the call is made.</param> /// <param name="adGroupResourceName">The resource name of ad group that a new ad group /// ad will belong to</param> private static void AddHotelAdGroupAd(GoogleAdsClient client, long customerId, string adGroupResourceName) { // Get the AdGroupAdService. AdGroupAdServiceClient service = client.GetService(Services.V4.AdGroupAdService); // Create a new ad group ad and sets the hotel ad to it. AdGroupAd adGroupAd = new AdGroupAd() { // Create a new hotel ad. Ad = new Ad() { HotelAd = new HotelAdInfo(), }, // Set the ad group. AdGroup = adGroupResourceName, // Set the ad group ad to enabled. Setting this to paused will cause an error // for hotel campaigns. For hotels pausing should happen at either the ad group or // campaign level. Status = AdGroupAdStatus.Enabled }; // Create an ad group ad operation. AdGroupAdOperation adGroupAdOperation = new AdGroupAdOperation() { Create = adGroupAd }; // Issue a mutate request to add an ad group ad. MutateAdGroupAdsResponse response = service.MutateAdGroupAds(customerId.ToString(), new AdGroupAdOperation[] { adGroupAdOperation }); MutateAdGroupAdResult addedAdGroupAd = response.Results[0]; Console.WriteLine($"Added a hotel ad group ad with resource name " + $"{addedAdGroupAd.ResourceName}."); }
/// <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) { AddGoogleMyBusinessLocationExtensions codeExample = new AddGoogleMyBusinessLocationExtensions(); Console.WriteLine(codeExample.Description); GoogleAdsClient client = new GoogleAdsClient(); // The customer ID for which the call is made. int customerId = int.Parse("INSERT_CUSTOMER_ID_HERE"); // The email address of either an owner or a manager of the GMB account. string gmbEmailAddress = "INSERT_GMB_EMAIL_ADDRESS_HERE"; // If the gmbEmailAddress above is the same user you used to generate // your Google Ads API refresh token, leave the assignment below unchanged. // Otherwise, to obtain an access token for your GMB account, run the // AuthenticateInStandaloneApplication code example while logged in as the same // user as gmbEmailAddress. Copy and paste the AccessToken value into the // assignment below and delete the line after it. // string gmbAccessToken = "INSERT_GMB_ACCESS_TOKEN_HERE"; string gmbAccessToken = client.Config.OAuth2AccessToken; // If the gmbEmailAddress above is for a GMB manager instead of the GMB // account owner, then set businessAccountIdentifier to the Google+ Page ID of // a location for which the manager has access. This information is available // through the Google My Business API. See // https://developers.google.com/my-business/reference/rest/v4/accounts.locations#locationkey // for details. string businessAccountId = null; codeExample.Run(new GoogleAdsClient(), customerId, gmbEmailAddress, businessAccountId, gmbAccessToken); }
/// <summary> /// Runs the code example. /// </summary> /// <param name="client">The Google Ads client.</param> /// <param name="customerId">The Google Ads customer ID for which the call is made.</param> /// <param name="merchantCenterAccountId">The Merchant Center account ID.</param> /// <param name="createDefaultListingGroup">The boolean to indicate if a default listing /// group should be created for the ad group. Set to false if the listing group will be /// constructed elsewhere. /// /// See AddShoppingListingGroupTree for a more comprehensive example.</param> public void Run(GoogleAdsClient client, long customerId, long merchantCenterAccountId, bool createDefaultListingGroup) { try { // Creates a budget to be used by the campaign that will be created below. string budgetResourceName = AddCampaignBudget(client, customerId); // Creates a standard shopping campaign. string campaignResourceName = AddStandardShoppingCampaign( client, customerId, budgetResourceName, merchantCenterAccountId); // Creates a product shopping ad group. string adGroupResourceName = AddProductShoppingAdGroup( client, customerId, campaignResourceName); // Creates a product shopping ad group ad. AddProductShoppingAdGroupAd(client, customerId, adGroupResourceName); if (createDefaultListingGroup) { // Creates an ad group criterion containing a listing group. // This will be the listing group tree for 'All products' and will contain // a single biddable unit node. AddDefaultShoppingListingGroup(client, customerId, adGroupResourceName); } } catch (GoogleAdsException e) { Console.WriteLine("Failure:"); Console.WriteLine($"Message: {e.Message}"); Console.WriteLine($"Failure: {e.Failure}"); Console.WriteLine($"Request ID: {e.RequestId}"); throw; } }
/// <summary> /// Updates a campaign to set the DSA feed. /// </summary> /// <param name="client">The Google Ads client.</param> /// <param name="customerId">The Google Ads customer ID for which the call is made.</param> /// <param name="feedResourceName">The DSA feed resource name</param> /// <param name="campaignId">ID of the campaign for which DSA settings are updated.</param> private void UpdateCampaignDsaSetting(GoogleAdsClient client, long customerId, string feedResourceName, long campaignId) { // Get the CampaignService. CampaignServiceClient campaignService = client.GetService( Services.V3.CampaignService); DynamicSearchAdsSetting dsaSetting = GetDsaSetting(client, customerId, campaignId); dsaSetting.Feeds.Add(feedResourceName); // Create the campaign. Campaign campaign = new Campaign() { ResourceName = ResourceNames.Campaign(customerId, campaignId), DynamicSearchAdsSetting = dsaSetting }; // Create the operation. CampaignOperation operation = new CampaignOperation() { Update = campaign, UpdateMask = FieldMasks.AllSetFieldsOf(campaign) }; // Update the campaign. MutateCampaignsResponse response = campaignService.MutateCampaigns(customerId.ToString(), new[] { operation }); // Display the results. foreach (MutateCampaignResult mutateCampaignResult in response.Results) { Console.WriteLine($"Updated campaign with resourceName: " + $"'{mutateCampaignResult.ResourceName}'."); } }
/// <summary> /// Runs the examples from command line arguments. /// </summary> /// <param name="args">The command line arguments.</param> private static void RunExamplesFromCommandLineArguments(string[] args) { ExampleRunner runner = new ExampleRunner(); runner.LoadCodeExamples(Assembly.GetExecutingAssembly()); if (args.Length == 0) { ShowUsage(runner); return; } GoogleAdsClient session = new GoogleAdsClient(); string exampleName = args[0]; try { runner.Run(exampleName, session, args.Skip(1)); } catch (KeyNotFoundException) { ShowUsage(runner); } }
/// <summary> /// Fetches the draft campaign associated with a campaign draft. /// </summary> /// <param name="client">The Google Ads client.</param> /// <param name="customerId">The Google Ads customer ID for which the call is made.</param> /// <param name="draftResourceName">Resource name of the draft.</param> /// <returns></returns> private static string FetchDraftCampaign(GoogleAdsClient client, long customerId, string draftResourceName) { // Get the GoogleAdsService. GoogleAdsServiceClient googleAdsService = client.GetService(Services.V10.GoogleAdsService); // Once the draft is created, you can modify the draft campaign as if it were // a real campaign. For example, you may add criteria, adjust bids, or even // include additional ads. Adding a criterion is shown here. string query = $@" SELECT campaign_draft.draft_campaign FROM campaign_draft WHERE campaign_draft.resource_name = '{draftResourceName}'"; // Get the draft campaign resource name. string draftCampaignResourceName = googleAdsService.Search( customerId.ToString(), query).First().CampaignDraft.DraftCampaign; return(draftCampaignResourceName); }
/// <summary> /// Creates the budget. /// </summary> /// <param name="client">The Google Ads client.</param> /// <param name="customerId">The Google Ads customer ID for which the call is made.</param> /// <returns>The newly created budget instance.</returns> private static gagvr::CampaignBudget CreateBudget(GoogleAdsClient client, long customerId) { // Get the CampaignBudgetService. gagvs::CampaignBudgetServiceClient budgetService = client.GetService( Services.V6.CampaignBudgetService); // Create the campaign budget. gagvr::CampaignBudget budget = new gagvr::CampaignBudget() { Name = "Interplanetary Cruise Budget #" + ExampleUtilities.GetRandomString(), DeliveryMethod = gag__BudgetDeliveryMethod.Standard, AmountMicros = 500000 }; // Create the operation. gagvs::CampaignBudgetOperation budgetOperation = new gagvs::CampaignBudgetOperation() { Create = budget }; // Create the campaign budget. gagvs::MutateCampaignBudgetsResponse response = budgetService.MutateCampaignBudgets( customerId.ToString(), new gagvs::CampaignBudgetOperation[] { budgetOperation }); // Retrieve the newly created budget. string newResourceName = response.Results[0].ResourceName; gagvr::CampaignBudget newCampaignBudget = GetBudget(client, customerId, newResourceName); // Display the results. Console.WriteLine($"Budget with ID={newCampaignBudget.Id} and name=" + $"'{newCampaignBudget.Name}' was created."); // Return the newly created budget. return(newCampaignBudget); }
/// <summary> /// Creates the campaign experiment. /// </summary> /// <param name="client">The Google Ads client.</param> /// <param name="customerId">The Google Ads customer ID for which the call is made.</param> /// <param name="campaignDraftResourceName">The campaign draft resource name.</param> /// <returns>The resource name of the newly created campaign experiment.</returns> internal static string CreateCampaignExperiment(GoogleAdsClient client, long customerId, string campaignDraftResourceName) { // Get the CampaignExperimentService. CampaignExperimentServiceClient campaignExperimentService = client.GetService(Services.V6.CampaignExperimentService); CampaignExperiment experiment = new CampaignExperiment() { CampaignDraft = campaignDraftResourceName, Name = "Campaign Experiment - " + ExampleUtilities.GetRandomString(), TrafficSplitPercent = 50, TrafficSplitType = CampaignExperimentTrafficSplitType.RandomQuery }; Operation <Empty, CreateCampaignExperimentMetadata> operation = campaignExperimentService.CreateCampaignExperiment( customerId.ToString(), experiment); string experimentResourceName = operation.Metadata.CampaignExperiment; operation.PollUntilCompleted(); return(experimentResourceName); }
/// <summary> /// Targets the feed items to the given ad group. /// </summary> /// <param name="client">The Google Ads client.</param> /// <param name="customerId">The customer ID for which the call is made.</param> /// <param name="adGroupId">The ID of the Ad Group being targeted.</param> /// <param name="feedItem">The feed item that was added to the feed.</param> private void CreateAdGroupTargeting(GoogleAdsClient client, long customerId, long adGroupId, string feedItem) { FeedItemTargetServiceClient feedItemTargetServiceClient = client.GetService(Services.V4.FeedItemTargetService); FeedItemTarget feedItemTarget = new FeedItemTarget() { FeedItem = feedItem, AdGroup = ResourceNames.AdGroup(customerId, adGroupId) }; FeedItemTargetOperation operation = new FeedItemTargetOperation() { Create = feedItemTarget }; MutateFeedItemTargetsResponse response = feedItemTargetServiceClient .MutateFeedItemTargets(customerId.ToString(), new[] { operation }); Console.WriteLine( $"Created feed item target '{response.Results.First().ResourceName}' " + $"for feed item '{feedItem}'."); }
/// <summary> /// Runs the code example. /// </summary> /// <param name="client">The Google Ads client.</param> /// <param name="customerId">The Google Ads customer ID for which the call is made.</param> public void Run(GoogleAdsClient client, long customerId) { // Gets the BatchJobService. BatchJobServiceClient batchJobService = client.GetService(Services.V4.BatchJobService); try { string batchJobResourceName = CreateBatchJob(batchJobService, customerId); AddAllBatchJobOperations(batchJobService, customerId, batchJobResourceName); Operation <Empty, BatchJobMetadata> operationResponse = RunBatchJob(batchJobService, batchJobResourceName); PollBatchJob(operationResponse); FetchAndPrintResults(batchJobService, batchJobResourceName); } catch (GoogleAdsException e) { Console.WriteLine("Failure:"); Console.WriteLine($"Message: {e.Message}"); Console.WriteLine($"Failure: {e.Failure}"); Console.WriteLine($"Request ID: {e.RequestId}"); throw; } }
// [END migrate_promotion_feed_to_asset_2] /// <summary> /// Associates the specified Promotion asset with the specified ad groups. /// </summary> /// <param name="client">The Google Ads client.</param> /// <param name="customerId">The customer ID for which the call is made.</param> /// <param name="promotionAssetResourceName">The string resource name of the Promotion /// Asset.</param> /// <param name="adGroupIds">A list of ad group IDs with which the Asset should be /// associated.</param> private void AssociateAssetWithAdGroups(GoogleAdsClient client, long customerId, string promotionAssetResourceName, List <long> adGroupIds) { if (adGroupIds.Count == 0) { Console.WriteLine("Asset was not associated with any ad groups."); return; } AdGroupAssetServiceClient adGroupAssetServiceClient = client.GetService(Services.V10 .AdGroupAssetService); List <AdGroupAssetOperation> operations = new List <AdGroupAssetOperation>(); foreach (long adGroupId in adGroupIds) { operations.Add(new AdGroupAssetOperation { Create = new AdGroupAsset { Asset = promotionAssetResourceName, FieldType = AssetFieldTypeEnum.Types.AssetFieldType.Promotion, AdGroup = ResourceNames.AdGroup(customerId, adGroupId), } }); } MutateAdGroupAssetsResponse response = adGroupAssetServiceClient.MutateAdGroupAssets( customerId.ToString(), operations); foreach (MutateAdGroupAssetResult result in response.Results) { Console.WriteLine($"Created ad group asset with resource name " + $"{result.ResourceName}."); } }
// [END setup_remarketing] /// <summary> /// Creates an ad group criterion that targets a user list with an ad group. /// </summary> /// <param name="client">The Google Ads API client.</param> /// <param name="customerId">The Google Ads customer ID for which the call is made.</param> /// <param name="adGroupId">The ad group on which the user list will be targeted.</param> /// <param name="userListResourceName">The resource name of the user list to be /// targeted.</param> /// <returns>The resource name of the newly created ad group criterion.</returns> // [START setup_remarketing_1] private string TargetAdsInAdGroupToUserList( GoogleAdsClient client, long customerId, long adGroupId, string userListResourceName) { // Get the AdGroupCriterionService client. AdGroupCriterionServiceClient adGroupCriterionServiceClient = client.GetService (Services.V10.AdGroupCriterionService); // Create the ad group criterion targeting members of the user list. AdGroupCriterion adGroupCriterion = new AdGroupCriterion { AdGroup = ResourceNames.AdGroup(customerId, adGroupId), UserList = new UserListInfo { UserList = userListResourceName } }; // Create the operation. AdGroupCriterionOperation adGroupCriterionOperation = new AdGroupCriterionOperation { Create = adGroupCriterion }; // Add the ad group criterion, then print and return the new criterion's resource name. MutateAdGroupCriteriaResponse mutateAdGroupCriteriaResponse = adGroupCriterionServiceClient.MutateAdGroupCriteria(customerId.ToString(), new[] { adGroupCriterionOperation }); string adGroupCriterionResourceName = mutateAdGroupCriteriaResponse.Results.First().ResourceName; Console.WriteLine("Successfully created ad group criterion with resource name " + $"'{adGroupCriterionResourceName}' targeting user list with resource name " + $"'{userListResourceName}' with ad group with ID {adGroupId}."); return(adGroupCriterionResourceName); }
/// <summary> /// Runs the code example. /// </summary> /// <param name="client">The Google Ads client.</param> /// <param name="customerId">The customer ID for which the call is made.</param> /// <param name="chainId">The retail chain ID.</param> /// <param name="campaignId">The campaign ID for which the affiliate location extensions /// are added.</param> public void Run(GoogleAdsClient client, long customerId, long chainId, long campaignId) { try { string feedResourceName = CreateAffiliateLocationExtensionFeed( client, customerId, chainId); // After the completion of the feed creation operation above the added feed will not // be available for usage in a campaign feed until the feed mappings are created. // We will wait with an exponential back-off policy until the feed mappings have // been created. FeedMapping feedMapping = WaitForFeedToBeReady(client, customerId, feedResourceName); CreateCampaignFeed(client, customerId, campaignId, feedMapping, feedResourceName, chainId); } catch (GoogleAdsException e) { Console.WriteLine("Failure:"); Console.WriteLine($"Message: {e.Message}"); Console.WriteLine($"Failure: {e.Failure}"); Console.WriteLine($"Request ID: {e.RequestId}"); throw; } }
/// <summary> /// Creates an image extension. /// </summary> /// <param name="client">The Google Ads API client.</param> /// <param name="customerId">The client customer ID.</param> /// <param name="imageAssetId">The ID of the image asset to be used for creating image /// extension.</param> /// <returns>Resource name of the newly created image extension.</returns> private static string CreateImageExtension(GoogleAdsClient client, long customerId, long imageAssetId) { // Get the ExtensionFeedItemServiceClient. ExtensionFeedItemServiceClient extensionFeedItemService = client.GetService(Services.V10.ExtensionFeedItemService); // Creates the image feed item using the provided image. ImageFeedItem imageFeedItem = new ImageFeedItem() { ImageAsset = ResourceNames.Asset(customerId, imageAssetId) }; // Creates an ExtensionFeedItem from the ImageFeedItem. ExtensionFeedItem extensionFeedItem = new ExtensionFeedItem() { ImageFeedItem = imageFeedItem }; ExtensionFeedItemOperation operation = new ExtensionFeedItemOperation() { Create = extensionFeedItem }; // Adds the ExtensionFeedItem. MutateExtensionFeedItemsResponse response = extensionFeedItemService.MutateExtensionFeedItems(customerId.ToString(), new[] { operation }); // Displays the result. string resourceName = response.Results.First().ResourceName; Console.WriteLine($"Created an image extension with resource name '{resourceName}'."); return(resourceName); }
// [END migrate_promotion_feed_to_asset] /// <summary> /// Associates the specified Promotion asset with the specified campaigns. /// </summary> /// <param name="client">The Google Ads client.</param> /// <param name="customerId">The customer ID for which the call is made.</param> /// <param name="promotionAssetResourceName">The string resource name of the Promotion /// Asset.</param> /// <param name="campaignIds">A list of campaign IDs with which the Asset should be /// associated.</param> // [START migrate_promotion_feed_to_asset_2] private void AssociateAssetWithCampaigns(GoogleAdsClient client, long customerId, string promotionAssetResourceName, List <long> campaignIds) { if (campaignIds.Count == 0) { Console.WriteLine("Asset was not associated with any campaigns."); return; } CampaignAssetServiceClient campaignAssetServiceClient = client.GetService(Services.V10 .CampaignAssetService); List <CampaignAssetOperation> operations = new List <CampaignAssetOperation>(); foreach (long campaignId in campaignIds) { operations.Add(new CampaignAssetOperation { Create = new CampaignAsset { Asset = promotionAssetResourceName, FieldType = AssetFieldTypeEnum.Types.AssetFieldType.Promotion, Campaign = ResourceNames.Campaign(customerId, campaignId), } }); } MutateCampaignAssetsResponse response = campaignAssetServiceClient.MutateCampaignAssets( customerId.ToString(), operations); foreach (MutateCampaignAssetResult result in response.Results) { Console.WriteLine($"Created campaign asset with resource name " + $"{result.ResourceName}."); } }
/// <summary> /// Runs the code example. /// </summary> /// <param name="client">The Google Ads client.</param> /// <param name="customerId">The Google Ads customer ID for which the call is made.</param> public void Run(GoogleAdsClient client, long customerId) { // Get the GoogleAdsServiceClient. GoogleAdsServiceClient googleAdsService = client.GetService( Services.V4.GoogleAdsService); // Construct a GAQL query which will retrieve AccountBudgetProposals. String searchQuery = @"SELECT account_budget_proposal.id, account_budget_proposal.account_budget, account_budget_proposal.billing_setup, account_budget_proposal.status, account_budget_proposal.proposed_name, account_budget_proposal.proposed_notes, account_budget_proposal.proposed_purchase_order_number, account_budget_proposal.proposal_type, account_budget_proposal.approval_date_time, account_budget_proposal.creation_date_time FROM account_budget_proposal"; // Creates a request that will retrieve all account budget proposals using pages of the // specified page size. SearchGoogleAdsRequest request = new SearchGoogleAdsRequest() { PageSize = PAGE_SIZE, Query = searchQuery, CustomerId = customerId.ToString() }; try { // Issues the search request. PagedEnumerable <SearchGoogleAdsResponse, GoogleAdsRow> searchPagedResponse = googleAdsService.Search(request); // Iterates over all rows in all pages and prints the requested field values for // the account budget in each row. foreach (GoogleAdsRow googleAdsRow in searchPagedResponse) { AccountBudgetProposal proposal = googleAdsRow.AccountBudgetProposal; Console.WriteLine($"Account budget proposal with ID '{proposal.Id}' " + $"status '{proposal.Status}', account_budget '{proposal.AccountBudget}' " + $"billing_setup '{proposal.BillingSetup}', " + $"proposed_name '{proposal.ProposedName}', " + $"proposed_notes '{proposal.ProposedNotes}', " + $"proposed_po_number '{proposal.ProposedPurchaseOrderNumber}', " + $"proposal_type '{proposal.ProposalType}', " + $"approval_date_time '{proposal.ApprovalDateTime}', " + $"creation_date_time '{proposal.CreationDateTime}'."); } } catch (GoogleAdsException e) { Console.WriteLine("Failure:"); Console.WriteLine($"Message: {e.Message}"); Console.WriteLine($"Failure: {e.Failure}"); Console.WriteLine($"Request ID: {e.RequestId}"); throw; } }
/// <summary> /// Runs the code example. /// </summary> /// <param name="client">The Google Ads client.</param> /// <param name="customerId">The Google Ads customer ID for which the call is made.</param> /// <param name="adGroupId">The ad group to which bid modifiers are set.</param> public void Run(GoogleAdsClient client, long customerId, long adGroupId) { // Get the AdGroupBidModifierService. AdGroupBidModifierServiceClient service = client.GetService( Services.V2.AdGroupBidModifierService); // Constructs the ad group resource name to use for each bid modifier. string adGroupResourceName = ResourceNames.AdGroup(customerId, adGroupId); // 1) Create an ad group bid modifier based on the hotel check-in day. AdGroupBidModifier checkInDayAdGroupBidModifier = new AdGroupBidModifier() { // Sets the resource name to the ad group resource name joined with the criterion // ID whose value corresponds to the desired check-in day. AdGroup = adGroupResourceName, HotelCheckInDay = new HotelCheckInDayInfo() { DayOfWeek = DayOfWeek.Monday }, // Set the bid modifier value to 150%. BidModifier = 1.5, }; // Creates an ad group bid modifier operation. var checkInDayAdGroupBidModifierOperation = new AdGroupBidModifierOperation() { Create = checkInDayAdGroupBidModifier }; // 2) Create an ad group bid modifier based on the hotel length of stay. AdGroupBidModifier lengthOfStayAdGroupBidModifier = new AdGroupBidModifier() { // Set the ad group. AdGroup = ResourceNames.AdGroup(customerId, adGroupId), // Set the hotel length of stay info. HotelLengthOfStay = new HotelLengthOfStayInfo() { MinNights = 3, MaxNights = 7 }, // Set the bid modifier value to 170%. BidModifier = 1.7 }; // Create an ad group bid modifier operation. var lengthOfStayAdGroupBidModifierOperation = new AdGroupBidModifierOperation() { Create = lengthOfStayAdGroupBidModifier }; try { // Issue a mutate request to add an ad group bid modifiers. MutateAdGroupBidModifiersResponse response = service.MutateAdGroupBidModifiers( customerId.ToString(), new AdGroupBidModifierOperation[] { checkInDayAdGroupBidModifierOperation, lengthOfStayAdGroupBidModifierOperation } ); // Display the resource names of the added ad group bid modifiers. Console.WriteLine($"Added {response.Results.Count} hotel ad group bid modifiers:"); foreach (MutateAdGroupBidModifierResult result in response.Results) { Console.WriteLine($"- {result.ResourceName}"); } } catch (GoogleAdsException e) { Console.WriteLine("Failure:"); Console.WriteLine($"Message: {e.Message}"); Console.WriteLine($"Failure: {e.Failure}"); Console.WriteLine($"Request ID: {e.RequestId}"); } }