Ejemplo n.º 1
0
        public void MutateCampaignCriteria()
        {
            moq::Mock <CampaignCriterionService.CampaignCriterionServiceClient> mockGrpcClient = new moq::Mock <CampaignCriterionService.CampaignCriterionServiceClient>(moq::MockBehavior.Strict);
            MutateCampaignCriteriaRequest request = new MutateCampaignCriteriaRequest
            {
                CustomerId = "customer_id3b3724cb",
                Operations =
                {
                    new CampaignCriterionOperation(),
                },
            };
            MutateCampaignCriteriaResponse expectedResponse = new MutateCampaignCriteriaResponse
            {
                Results =
                {
                    new MutateCampaignCriterionResult(),
                },
                PartialFailureError = new gr::Status(),
            };

            mockGrpcClient.Setup(x => x.MutateCampaignCriteria(request, moq::It.IsAny <grpccore::CallOptions>())).Returns(expectedResponse);
            CampaignCriterionServiceClient client   = new CampaignCriterionServiceClientImpl(mockGrpcClient.Object, null);
            MutateCampaignCriteriaResponse response = client.MutateCampaignCriteria(request.CustomerId, request.Operations);

            Assert.AreEqual(expectedResponse, response);
            mockGrpcClient.VerifyAll();
        }
Ejemplo n.º 2
0
        public void MutateCampaignCriteriaRequestObject()
        {
            moq::Mock <CampaignCriterionService.CampaignCriterionServiceClient> mockGrpcClient = new moq::Mock <CampaignCriterionService.CampaignCriterionServiceClient>(moq::MockBehavior.Strict);
            MutateCampaignCriteriaRequest request = new MutateCampaignCriteriaRequest
            {
                CustomerId = "customer_id3b3724cb",
                Operations =
                {
                    new CampaignCriterionOperation(),
                },
                PartialFailure      = false,
                ValidateOnly        = true,
                ResponseContentType = gagve::ResponseContentTypeEnum.Types.ResponseContentType.ResourceNameOnly,
            };
            MutateCampaignCriteriaResponse expectedResponse = new MutateCampaignCriteriaResponse
            {
                Results =
                {
                    new MutateCampaignCriterionResult(),
                },
                PartialFailureError = new gr::Status(),
            };

            mockGrpcClient.Setup(x => x.MutateCampaignCriteria(request, moq::It.IsAny <grpccore::CallOptions>())).Returns(expectedResponse);
            CampaignCriterionServiceClient client   = new CampaignCriterionServiceClientImpl(mockGrpcClient.Object, null);
            MutateCampaignCriteriaResponse response = client.MutateCampaignCriteria(request);

            xunit::Assert.Same(expectedResponse, response);
            mockGrpcClient.VerifyAll();
        }
Ejemplo n.º 3
0
        // [END setup_remarketing_4]

        /// <summary>
        /// Updates the bid modifier on a campaign criterion.
        /// </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="campaignCriterionResourceName">The resource name of the campaign criterion to update.</param>
        /// <param name="bidModifierValue">The bid modifier value.</param>
        private void ModifyCampaignBids(
            GoogleAdsClient client,
            long customerId,
            string campaignCriterionResourceName,
            double bidModifierValue)
        {
            // Get the CampaignCriterionService client.
            CampaignCriterionServiceClient campaignCriterionServiceClient =
                client.GetService(Services.V10.CampaignCriterionService);

            // Create the campaign criterion to update.
            CampaignCriterion campaignCriterion = new CampaignCriterion
            {
                ResourceName = campaignCriterionResourceName,
                BidModifier  = (float)bidModifierValue
            };

            // Create the update operation.
            CampaignCriterionOperation campaignCriterionOperation = new CampaignCriterionOperation
            {
                Update     = campaignCriterion,
                UpdateMask = FieldMasks.AllSetFieldsOf(campaignCriterion)
            };

            // Update the campaign criterion and print the results.
            MutateCampaignCriteriaResponse mutateCampaignCriteriaResponse =
                campaignCriterionServiceClient.MutateCampaignCriteria(customerId.ToString(),
                                                                      new[] { campaignCriterionOperation });

            Console.WriteLine("Successfully updated the bid for campaign criterion with resource " +
                              $"name '{mutateCampaignCriteriaResponse.Results.First().CampaignCriterion}'.");
        }
Ejemplo n.º 4
0
        public async stt::Task MutateCampaignCriteriaAsync()
        {
            moq::Mock <CampaignCriterionService.CampaignCriterionServiceClient> mockGrpcClient = new moq::Mock <CampaignCriterionService.CampaignCriterionServiceClient>(moq::MockBehavior.Strict);
            MutateCampaignCriteriaRequest request = new MutateCampaignCriteriaRequest
            {
                CustomerId = "customer_id3b3724cb",
                Operations =
                {
                    new CampaignCriterionOperation(),
                },
            };
            MutateCampaignCriteriaResponse expectedResponse = new MutateCampaignCriteriaResponse
            {
                Results =
                {
                    new MutateCampaignCriterionResult(),
                },
                PartialFailureError = new gr::Status(),
            };

            mockGrpcClient.Setup(x => x.MutateCampaignCriteriaAsync(request, moq::It.IsAny <grpccore::CallOptions>())).Returns(new grpccore::AsyncUnaryCall <MutateCampaignCriteriaResponse>(stt::Task.FromResult(expectedResponse), null, null, null, null));
            CampaignCriterionServiceClient client = new CampaignCriterionServiceClientImpl(mockGrpcClient.Object, null);
            MutateCampaignCriteriaResponse responseCallSettings = await client.MutateCampaignCriteriaAsync(request.CustomerId, request.Operations, gaxgrpc::CallSettings.FromCancellationToken(st::CancellationToken.None));

            Assert.AreEqual(expectedResponse, responseCallSettings);
            MutateCampaignCriteriaResponse responseCancellationToken = await client.MutateCampaignCriteriaAsync(request.CustomerId, request.Operations, st::CancellationToken.None);

            Assert.AreEqual(expectedResponse, responseCancellationToken);
            mockGrpcClient.VerifyAll();
        }
Ejemplo n.º 5
0
        /// <summary>
        /// Adds a language criterion to the draft campaign.
        /// </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="draftCampaignResourceName">Resource name of the draft campaign.</param>
        private static void AddLanguageCriteria(GoogleAdsClient client, long customerId,
                                                string draftCampaignResourceName)
        {
            // Get the CampaignCriterionService.
            CampaignCriterionServiceClient campaignCriterionService =
                client.GetService(Services.V4.CampaignCriterionService);

            // Add a language criterion.
            CampaignCriterionOperation criterionOperation = new CampaignCriterionOperation()
            {
                Create = new CampaignCriterion()
                {
                    Language = new LanguageInfo()
                    {
                        // Spanish
                        LanguageConstant = ResourceNames.LanguageConstant(1003)
                    },
                    Campaign = draftCampaignResourceName
                }
            };

            MutateCampaignCriteriaResponse campaignCriteriaResponse =
                campaignCriterionService.MutateCampaignCriteria(
                    customerId.ToString(),
                    new CampaignCriterionOperation[] { criterionOperation });

            string newCampaignCriterionResource = campaignCriteriaResponse.Results[0].ResourceName;

            Console.WriteLine($"Campaign Criterion with resource ID = " +
                              $"'{newCampaignCriterionResource}' was added to campaign with resource ID = " +
                              $"'{draftCampaignResourceName}'.");
        }
Ejemplo n.º 6
0
 /// <summary>Snippet for MutateCampaignCriteria</summary>
 /// <remarks>
 /// This snippet has been automatically generated for illustrative purposes only.
 /// It may require modifications to work in your environment.
 /// </remarks>
 public void MutateCampaignCriteria()
 {
     // Create client
     CampaignCriterionServiceClient campaignCriterionServiceClient = CampaignCriterionServiceClient.Create();
     // Initialize request argument(s)
     string customerId = "";
     IEnumerable <CampaignCriterionOperation> operations = new CampaignCriterionOperation[]
     {
         new CampaignCriterionOperation(),
     };
     // Make the request
     MutateCampaignCriteriaResponse response = campaignCriterionServiceClient.MutateCampaignCriteria(customerId, operations);
 }
        /// <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="campaignId">ID of the campaign that contains the criterion.</param>
        /// <param name="criterionId">ID of the criterion for which bid modifier is updated.</param>
        /// <param name="bidModifierValue">The new value of the bid modifier to update.</param>
        public void Run(GoogleAdsClient client, long customerId, long campaignId, long criterionId,
                        float?bidModifierValue)
        {
            // Get the CampaignCriterionServiceClient .
            CampaignCriterionServiceClient campaignCriterionService =
                client.GetService(Services.V10.CampaignCriterionService);

            string criterionResourceName = ResourceNames.CampaignCriteria(customerId,
                                                                          campaignId, criterionId);

            // Construct a campaign bid modifier.
            CampaignCriterion campaignCriterion = new CampaignCriterion()
            {
                ResourceName = criterionResourceName,
                BidModifier  = (bidModifierValue != null) ? bidModifierValue.Value : 1.5f,
            };

            // Construct an operation to create the campaign criterion.
            CampaignCriterionOperation op = new CampaignCriterionOperation()
            {
                Update     = campaignCriterion,
                UpdateMask = FieldMasks.AllSetFieldsOf(campaignCriterion)
            };

            // Send the operation in a mutate request.
            try
            {
                MutateCampaignCriteriaResponse response =
                    campaignCriterionService.MutateCampaignCriteria(customerId.ToString(),
                                                                    new CampaignCriterionOperation[] { op });
                foreach (MutateCampaignCriterionResult result in response.Results)
                {
                    Console.WriteLine($"Campaign criterion with resource name" +
                                      $" '{result.ResourceName}' was modified.");
                }
            }
            catch (GoogleAdsException e)
            {
                Console.WriteLine("Failure:");
                Console.WriteLine($"Message: {e.Message}");
                Console.WriteLine($"Failure: {e.Failure}");
                Console.WriteLine($"Request ID: {e.RequestId}");
                throw;
            }
        }
        public async Task MutateCampaignCriteriaAsync3()
        {
            Mock <CampaignCriterionService.CampaignCriterionServiceClient> mockGrpcClient = new Mock <CampaignCriterionService.CampaignCriterionServiceClient>(MockBehavior.Strict);
            MutateCampaignCriteriaRequest request = new MutateCampaignCriteriaRequest
            {
                CustomerId = "customerId-1772061412",
                Operations = { },
            };
            MutateCampaignCriteriaResponse expectedResponse = new MutateCampaignCriteriaResponse();

            mockGrpcClient.Setup(x => x.MutateCampaignCriteriaAsync(request, It.IsAny <CallOptions>()))
            .Returns(new Grpc.Core.AsyncUnaryCall <MutateCampaignCriteriaResponse>(Task.FromResult(expectedResponse), null, null, null, null));
            CampaignCriterionServiceClient client   = new CampaignCriterionServiceClientImpl(mockGrpcClient.Object, null);
            MutateCampaignCriteriaResponse response = await client.MutateCampaignCriteriaAsync(request);

            Assert.AreEqual(expectedResponse, response);
            mockGrpcClient.VerifyAll();
        }
        public void MutateCampaignCriteria3()
        {
            Mock <CampaignCriterionService.CampaignCriterionServiceClient> mockGrpcClient = new Mock <CampaignCriterionService.CampaignCriterionServiceClient>(MockBehavior.Strict);
            MutateCampaignCriteriaRequest request = new MutateCampaignCriteriaRequest
            {
                CustomerId = "customerId-1772061412",
                Operations = { },
            };
            MutateCampaignCriteriaResponse expectedResponse = new MutateCampaignCriteriaResponse();

            mockGrpcClient.Setup(x => x.MutateCampaignCriteria(request, It.IsAny <CallOptions>()))
            .Returns(expectedResponse);
            CampaignCriterionServiceClient client   = new CampaignCriterionServiceClientImpl(mockGrpcClient.Object, null);
            MutateCampaignCriteriaResponse response = client.MutateCampaignCriteria(request);

            Assert.AreEqual(expectedResponse, response);
            mockGrpcClient.VerifyAll();
        }
Ejemplo n.º 10
0
 /// <summary>Snippet for MutateCampaignCriteria</summary>
 /// <remarks>
 /// This snippet has been automatically generated for illustrative purposes only.
 /// It may require modifications to work in your environment.
 /// </remarks>
 public void MutateCampaignCriteriaRequestObject()
 {
     // Create client
     CampaignCriterionServiceClient campaignCriterionServiceClient = CampaignCriterionServiceClient.Create();
     // Initialize request argument(s)
     MutateCampaignCriteriaRequest request = new MutateCampaignCriteriaRequest
     {
         CustomerId = "",
         Operations =
         {
             new CampaignCriterionOperation(),
         },
         PartialFailure = false,
         ValidateOnly   = false,
     };
     // Make the request
     MutateCampaignCriteriaResponse response = campaignCriterionServiceClient.MutateCampaignCriteria(request);
 }
        /// <summary>Snippet for MutateCampaignCriteriaAsync</summary>
        public async Task MutateCampaignCriteriaAsync()
        {
            // Snippet: MutateCampaignCriteriaAsync(string, IEnumerable<CampaignCriterionOperation>, CallSettings)
            // Additional: MutateCampaignCriteriaAsync(string, IEnumerable<CampaignCriterionOperation>, CancellationToken)
            // Create client
            CampaignCriterionServiceClient campaignCriterionServiceClient = await CampaignCriterionServiceClient.CreateAsync();

            // Initialize request argument(s)
            string customerId = "";
            IEnumerable <CampaignCriterionOperation> operations = new CampaignCriterionOperation[]
            {
                new CampaignCriterionOperation(),
            };
            // Make the request
            MutateCampaignCriteriaResponse response = await campaignCriterionServiceClient.MutateCampaignCriteriaAsync(customerId, operations);

            // End snippet
        }
        /// <summary>Snippet for MutateCampaignCriteriaAsync</summary>
        /// <remarks>
        /// This snippet has been automatically generated for illustrative purposes only.
        /// It may require modifications to work in your environment.
        /// </remarks>
        public async Task MutateCampaignCriteriaRequestObjectAsync()
        {
            // Create client
            CampaignCriterionServiceClient campaignCriterionServiceClient = await CampaignCriterionServiceClient.CreateAsync();

            // Initialize request argument(s)
            MutateCampaignCriteriaRequest request = new MutateCampaignCriteriaRequest
            {
                CustomerId = "",
                Operations =
                {
                    new CampaignCriterionOperation(),
                },
                PartialFailure      = false,
                ValidateOnly        = false,
                ResponseContentType = ResponseContentTypeEnum.Types.ResponseContentType.Unspecified,
            };
            // Make the request
            MutateCampaignCriteriaResponse response = await campaignCriterionServiceClient.MutateCampaignCriteriaAsync(request);
        }
 /// <summary>Snippet for MutateCampaignCriteria</summary>
 public void MutateCampaignCriteriaRequestObject()
 {
     // Snippet: MutateCampaignCriteria(MutateCampaignCriteriaRequest, CallSettings)
     // Create client
     CampaignCriterionServiceClient campaignCriterionServiceClient = CampaignCriterionServiceClient.Create();
     // Initialize request argument(s)
     MutateCampaignCriteriaRequest request = new MutateCampaignCriteriaRequest
     {
         CustomerId = "",
         Operations =
         {
             new CampaignCriterionOperation(),
         },
         PartialFailure      = false,
         ValidateOnly        = false,
         ResponseContentType = ResponseContentTypeEnum.Types.ResponseContentType.Unspecified,
     };
     // Make the request
     MutateCampaignCriteriaResponse response = campaignCriterionServiceClient.MutateCampaignCriteria(request);
     // End snippet
 }
        /// <summary>Snippet for MutateCampaignCriteriaAsync</summary>
        public async Task MutateCampaignCriteriaRequestObjectAsync()
        {
            // Snippet: MutateCampaignCriteriaAsync(MutateCampaignCriteriaRequest, CallSettings)
            // Additional: MutateCampaignCriteriaAsync(MutateCampaignCriteriaRequest, CancellationToken)
            // Create client
            CampaignCriterionServiceClient campaignCriterionServiceClient = await CampaignCriterionServiceClient.CreateAsync();

            // Initialize request argument(s)
            MutateCampaignCriteriaRequest request = new MutateCampaignCriteriaRequest
            {
                CustomerId = "",
                Operations =
                {
                    new CampaignCriterionOperation(),
                },
                PartialFailure = false,
                ValidateOnly   = false,
            };
            // Make the request
            MutateCampaignCriteriaResponse response = await campaignCriterionServiceClient.MutateCampaignCriteriaAsync(request);

            // End snippet
        }
Ejemplo n.º 15
0
        // [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);
        }
        public async Task MutateCampaignCriteriaAsync()
        {
            Mock <CampaignCriterionService.CampaignCriterionServiceClient> mockGrpcClient = new Mock <CampaignCriterionService.CampaignCriterionServiceClient>(MockBehavior.Strict);
            MutateCampaignCriteriaRequest expectedRequest = new MutateCampaignCriteriaRequest
            {
                CustomerId     = "customerId-1772061412",
                Operations     = { },
                PartialFailure = true,
                ValidateOnly   = false,
            };
            MutateCampaignCriteriaResponse expectedResponse = new MutateCampaignCriteriaResponse();

            mockGrpcClient.Setup(x => x.MutateCampaignCriteriaAsync(expectedRequest, It.IsAny <CallOptions>()))
            .Returns(new Grpc.Core.AsyncUnaryCall <MutateCampaignCriteriaResponse>(Task.FromResult(expectedResponse), null, null, null, null));
            CampaignCriterionServiceClient client = new CampaignCriterionServiceClientImpl(mockGrpcClient.Object, null);
            string customerId = "customerId-1772061412";
            IEnumerable <CampaignCriterionOperation> operations = new List <CampaignCriterionOperation>();
            bool partialFailure = true;
            bool validateOnly   = false;
            MutateCampaignCriteriaResponse response = await client.MutateCampaignCriteriaAsync(customerId, operations, partialFailure, validateOnly);

            Assert.AreEqual(expectedResponse, response);
            mockGrpcClient.VerifyAll();
        }
Ejemplo n.º 17
0
        /// <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="campaignId">ID of the campaign to which targeting criteria are added.
        /// </param>
        /// <param name="keywordText">the keyword text for which to add a criterion.</param>
        /// <param name="locationId">the locationId for which to add a criterion.</param>
        public void Run(GoogleAdsClient client, long customerId, long campaignId,
                        string keywordText, long locationId)
        {
            // Get the CampaignCriterionService.
            CampaignCriterionServiceClient campaignCriterionService =
                client.GetService(Services.V1.CampaignCriterionService);

            // Set the Campaign Resource Name
            string campaignResourceName = ResourceNames.Campaign(customerId, campaignId);

            // Add a campaign level negative keyword from keywordText.
            CampaignCriterion keywordCriterion = buildNegativeKeywordCriterion(keywordText,
                                                                               campaignResourceName);

            // Creates a location constant (provided by GeoTargetConstantService) as a campaign
            // targeting criterion. Please refer to GetGeoTargetConstantsByName.cs for retrieval
            // of location constants.
            CampaignCriterion locationCriterion = buildLocationCriterion(locationId,
                                                                         campaignResourceName);

            // Add a proximity criterion
            CampaignCriterion proximityCriterion = buildProximityCriterion(campaignResourceName);

            // Create the operations.
            CampaignCriterionOperation negativeCriterionOperation =
                new CampaignCriterionOperation()
            {
                Create = keywordCriterion
            };

            CampaignCriterionOperation locationCriterionOperation =
                new CampaignCriterionOperation()
            {
                Create = locationCriterion
            };

            CampaignCriterionOperation proximityCriterionOperation =
                new CampaignCriterionOperation()
            {
                Create = proximityCriterion
            };

            CampaignCriterionOperation[] operations = new CampaignCriterionOperation[] {
                negativeCriterionOperation,
                locationCriterionOperation,
                proximityCriterionOperation
            };

            try
            {
                // Create the campaign criterion.
                MutateCampaignCriteriaResponse response =
                    campaignCriterionService.MutateCampaignCriteria(customerId.ToString(),
                                                                    operations);

                // Display the results.
                foreach (MutateCampaignCriterionResult criterionResult in response.Results)
                {
                    Console.WriteLine($"New campaign criterion with resource name = " +
                                      $"'{criterionResult.ResourceName}' was added to campaign " +
                                      "ID {campaignId}.");
                }
            }
            catch (GoogleAdsException e)
            {
                Console.WriteLine("Failure:");
                Console.WriteLine($"Message: {e.Message}");
                Console.WriteLine($"Failure: {e.Failure}");
                Console.WriteLine($"Request ID: {e.RequestId}");
            }
        }
Ejemplo n.º 18
0
        /// <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="campaignId">The campaign to which listing scope is added.</param>
        public void Run(GoogleAdsClient client, long customerId, long campaignId)
        {
            // Get the CampaignCriterionService.
            CampaignCriterionServiceClient campaignCriterionService =
                client.GetService(Services.V3.CampaignCriterionService);

            // A listing scope allows you to filter the products that will be included in a given
            // campaign. You can specify multiple dimensions with conditions that must be met for
            // a product to be included in a campaign.
            // A typical ListingScope might only have a few dimensions. This example demonstrates
            // a range of different dimensions you could use.
            ListingScopeInfo listingScope = new ListingScopeInfo()
            {
                Dimensions =
                {
                    // Creates a ProductBrand dimension set to "google".
                    new ListingDimensionInfo()
                    {
                        ProductBrand = new ProductBrandInfo()
                        {
                            Value = "google"
                        }
                    },

                    // Creates a ProductCustomAttribute dimension for INDEX0 set to
                    // "top_selling_products".
                    new ListingDimensionInfo()
                    {
                        ProductCustomAttribute = new ProductCustomAttributeInfo()
                        {
                            Index = ProductCustomAttributeIndex.Index0,
                            Value = "top_selling_products"
                        }
                    },

                    // Creates a ProductType dimension for LEVEL1 set to "electronics".
                    new ListingDimensionInfo()
                    {
                        ProductType = new ProductTypeInfo()
                        {
                            Level = ProductTypeLevel.Level1,
                            Value = "electronics"
                        }
                    },

                    // Creates a ProductType dimension for LEVEL2 set to "smartphones".
                    new ListingDimensionInfo()
                    {
                        ProductType = new ProductTypeInfo()
                        {
                            Level = ProductTypeLevel.Level2,
                            Value = "smartphones"
                        }
                    },
                }
            };

            string campaignResourceName = ResourceNames.Campaign(customerId, campaignId);

            // Creates a campaign criterion to store the listing scope.
            CampaignCriterion campaignCriterion = new CampaignCriterion()
            {
                Campaign     = campaignResourceName,
                ListingScope = listingScope
            };

            CampaignCriterionOperation operation = new CampaignCriterionOperation()
            {
                Create = campaignCriterion
            };

            try
            {
                // Calls the mutate method to add the campaign criterion.
                MutateCampaignCriteriaResponse response =
                    campaignCriterionService.MutateCampaignCriteria(
                        customerId.ToString(), new[] { operation });
                Console.WriteLine($"Added {response.Results.Count} campaign criteria:");
                foreach (MutateCampaignCriterionResult 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}");
                throw;
            }
        }
Ejemplo n.º 19
0
        /// <summary>
        /// Sets campaign targeting criteria for a given campaign. Both location and language
        /// targeting are illustrated.
        /// </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="campaignResourceName">The resource name of the campaign to apply
        /// targeting to.</param>
        private void SetCampaignTargetingCriteria(GoogleAdsClient client, long customerId,
                                                  string campaignResourceName)
        {
            // Get the CampaignCriterionService.
            CampaignCriterionServiceClient campaignCriterionService = client.GetService(
                Services.V4.CampaignCriterionService);

            List <CampaignCriterionOperation> operations = new List <CampaignCriterionOperation>();

            // Creates the location campaign criteria.
            // Besides using location_id, you can also search by location names from
            // GeoTargetConstantService.suggestGeoTargetConstants() and directly
            // apply GeoTargetConstant.resource_name here. An example can be found
            // in GetGeoTargetConstantByNames.cs.
            int[] locationIds = new int[]
            {
                21137, // California
                2484   // Mexico
            };

            foreach (int locationId in locationIds)
            {
                // Creates a campaign criterion.
                CampaignCriterion campaignCriterion = new CampaignCriterion()
                {
                    Campaign = campaignResourceName,
                    Type     = CriterionType.Location,
                    Location = new LocationInfo()
                    {
                        GeoTargetConstant = ResourceNames.GeoTargetConstant(locationId)
                    }
                };

                // Creates a campaign criterion operation.
                CampaignCriterionOperation operation = new CampaignCriterionOperation()
                {
                    Create = campaignCriterion
                };

                operations.Add(operation);
            }

            // Creates the language campaign criteria.
            int[] languageIds = new int[]
            {
                1000, // English
                1003  // Spanish
            };

            foreach (int languageId in languageIds)
            {
                // Creates a campaign criterion.
                CampaignCriterion campaignCriterion = new CampaignCriterion()
                {
                    Campaign = campaignResourceName,
                    Type     = CriterionType.Language,
                    Language = new LanguageInfo()
                    {
                        LanguageConstant = ResourceNames.LanguageConstant(languageId)
                    }
                };

                // Creates a campaign criterion operation.
                CampaignCriterionOperation operation = new CampaignCriterionOperation()
                {
                    Create = campaignCriterion
                };

                operations.Add(operation);
            }

            // Submits the criteria operations and prints their information.
            MutateCampaignCriteriaResponse response =
                campaignCriterionService.MutateCampaignCriteria(customerId.ToString(), operations);

            Console.WriteLine($"Created {response.Results.Count} campaign criteria with " +
                              $"resource names:");

            foreach (MutateCampaignCriterionResult result in response.Results)
            {
                Console.WriteLine(result.ResourceName);
            }
        }