Sprache

Codebeispiel für Remarketing-Listen

In diesem Beispiel wird veranschaulicht, wie Remarketing-Listen einer neuen Anzeigengruppe zugeordnet werden.

Tipp

Verwenden Sie die Sprachauswahl im Dokumentationsheader, um zwischen C#, Java, PHP oder Python zu wählen.

Informationen dazu, wie Sie Zugriffs- und Aktualisierungstoken für Ihren Microsoft Advertising-Benutzer erhalten und Ihren ersten Dienstanruf mithilfe der Bing Ads-API tätigen können, finden Sie im Schnellstarthandbuch . Lesen Sie den Leitfaden für erste Schritte und exemplarische Vorgehensweisen für Ihre bevorzugte Sprache, z. B. C#, Java, Php und Python.

Unterstützende Dateien für C#-, Java- , PHP- und Python-Beispiele sind auf GitHub verfügbar. Sie können jedes Repository klonen oder Snippets nach Bedarf wiederverwenden.

using System;
using System.Collections.Generic;
using System.Linq;
using System.ServiceModel;
using System.Threading.Tasks;
using Microsoft.BingAds.V13.CampaignManagement;
using Microsoft.BingAds;

namespace BingAdsExamplesLibrary.V13
{
    /// <summary>
    /// How to associate remarketing lists with a new ad group.
    /// </summary>
    public class RemarketingLists : ExampleBase
    {
        public static ServiceClient<ICampaignManagementService> Service;

        public override string Description
        {
            get { return "Remarketing Lists | Campaign Management V13"; }
        }

        public async override Task RunAsync(AuthorizationData authorizationData)
        {
            try
            {
                ApiEnvironment environment = ((OAuthDesktopMobileAuthCodeGrant)authorizationData.Authentication).Environment;

                CampaignManagementExampleHelper CampaignManagementExampleHelper = new CampaignManagementExampleHelper(
                    OutputStatusMessageDefault: this.OutputStatusMessage);
                CampaignManagementExampleHelper.CampaignManagementService = new ServiceClient<ICampaignManagementService>(
                    authorizationData: authorizationData,
                    environment: environment);

                // Before you can track conversions or target audiences using a remarketing list 
                // you need to create a UET tag, and then add the UET tag tracking code to every page of your website.
                // For more information, please see Universal Event Tracking at https://go.microsoft.com/fwlink/?linkid=829965.

                // First you should call the GetUetTagsByIds operation to check whether a tag has already been created. 
                // You can leave the TagIds element null or empty to request all UET tags available for the customer.

                OutputStatusMessage("-----\nGetUetTagsByIds:");
                var uetTags = (await CampaignManagementExampleHelper.GetUetTagsByIdsAsync(
                    tagIds: null))?.UetTags;

                // If you do not already have a UET tag that can be used, or if you need another UET tag, 
                // call the AddUetTags service operation to create a new UET tag. If the call is successful, 
                // the tracking script that you should add to your website is included in a corresponding 
                // UetTag within the response message. 

                if (uetTags == null || uetTags.Count < 1)
                {
                    var uetTag = new UetTag
                    {
                        Description = "My First Uet Tag",
                        Name = "New Uet Tag",
                    };
                    OutputStatusMessage("-----\nAddUetTags:");
                    uetTags = (await CampaignManagementExampleHelper.AddUetTagsAsync(
                        uetTags: new[] { uetTag })).UetTags;
                }

                if (uetTags == null || uetTags.Count < 1)
                {
                    OutputStatusMessage(
                        string.Format("You do not have any UET tags registered for CustomerId {0}.", authorizationData.CustomerId)
                    );
                    return;
                }

                OutputStatusMessage("List of all UET Tags:");
                CampaignManagementExampleHelper.OutputArrayOfUetTag(uetTags);

                // After you retreive the tracking script from the AddUetTags or GetUetTagsByIds operation, 
                // the next step is to add the UET tag tracking code to your website. 

                // We will use the same UET tag for the remainder of this example.
                var tagId = uetTags[0].Id;
                
                // Add remarketing lists that depend on the UET Tag Id retreived above.

                var addAudiences = new[] {
                    new RemarketingList
                    {
                        Description = "New list with CustomEventsRule",
                        MembershipDuration = 30,
                        Name = "Remarketing List with CustomEventsRule " + DateTime.UtcNow,
                        ParentId = authorizationData.AccountId,
                        // The rule definition is translated to the following logical expression: 
                        // (Category Equals video) and (Action Equals play) and (Label Equals trailer) 
                        // and (Value Equals 5)
                        Rule = new CustomEventsRule
                        {
                            // The type of user interaction you want to track.
                            Action = "play",
                            ActionOperator = StringOperator.Equals,
                            // The category of event you want to track. 
                            Category = "video",
                            CategoryOperator = StringOperator.Equals,
                            // The name of the element that caused the action.
                            Label = "trailer",
                            LabelOperator = StringOperator.Equals,
                            // A numerical value associated with that event. 
                            // Could be length of the video played etc.
                            Value = 5.00m,
                            ValueOperator = NumberOperator.Equals,
                        },
                        Scope = EntityScope.Account,
                        TagId = tagId
                    },
                    new RemarketingList
                    {
                        Description = "New list with PageVisitorsRule",
                        MembershipDuration = 30,
                        Name = "Remarketing List with PageVisitorsRule " + DateTime.UtcNow,
                        ParentId = authorizationData.AccountId,
                        // The rule definition is translated to the following logical expression: 
                        // ((Url Contains X) and (ReferrerUrl DoesNotContain Z)) or ((Url DoesNotBeginWith Y)) 
                        // or ((ReferrerUrl Equals Z))
                        Rule = new PageVisitorsRule
                        {
                            RuleItemGroups = new []
                            {
                                new RuleItemGroup
                                {
                                    Items = new []
                                    {
                                        new StringRuleItem
                                        {
                                            Operand = "Url",
                                            Operator = StringOperator.Contains,
                                            Value = "X"
                                        },
                                        new StringRuleItem
                                        {
                                            Operand = "ReferrerUrl",
                                            Operator = StringOperator.DoesNotContain,
                                            Value = "Z"
                                        },
                                    }
                                },
                                new RuleItemGroup
                                {
                                    Items = new []
                                    {
                                        new StringRuleItem
                                        {
                                            Operand = "Url",
                                            Operator = StringOperator.DoesNotBeginWith,
                                            Value = "Y"
                                        },
                                    }
                                },
                                new RuleItemGroup
                                {
                                    Items = new []
                                    {
                                        new StringRuleItem
                                        {
                                            Operand = "ReferrerUrl",
                                            Operator = StringOperator.Equals,
                                            Value = "Z"
                                        },
                                    }
                                },
                            },
                        },
                        Scope = EntityScope.Account,
                        TagId = tagId
                    },
                    new RemarketingList
                    {
                        Description = "New list with PageVisitorsWhoDidNotVisitAnotherPageRule",
                        MembershipDuration = 30,
                        Name = "Remarketing List with PageVisitorsWhoDidNotVisitAnotherPageRule " + DateTime.UtcNow,
                        ParentId = authorizationData.AccountId,
                        // The rule definition is translated to the following logical expression: 
                        // (((Url Contains X) and (ReferrerUrl DoesNotContain Z)) or ((Url DoesNotBeginWith Y)) 
                        // or ((ReferrerUrl Equals Z))) 
                        // and not (((Url BeginsWith A) and (ReferrerUrl BeginsWith B)) or ((Url Contains C)))
                        Rule = new PageVisitorsWhoDidNotVisitAnotherPageRule
                        {
                            ExcludeRuleItemGroups = new []
                            {
                                new RuleItemGroup
                                {
                                    Items = new []
                                    {
                                        new StringRuleItem
                                        {
                                            Operand = "Url",
                                            Operator = StringOperator.BeginsWith,
                                            Value = "A"
                                        },
                                        new StringRuleItem
                                        {
                                            Operand = "ReferrerUrl",
                                            Operator = StringOperator.BeginsWith,
                                            Value = "B"
                                        },
                                    }
                                },
                                new RuleItemGroup
                                {
                                    Items = new []
                                    {
                                        new StringRuleItem
                                        {
                                            Operand = "Url",
                                            Operator = StringOperator.Contains,
                                            Value = "C"
                                        },
                                    }
                                },
                            },
                            IncludeRuleItemGroups = new []
                            {
                                new RuleItemGroup
                                {
                                    Items = new []
                                    {
                                        new StringRuleItem
                                        {
                                            Operand = "Url",
                                            Operator = StringOperator.Contains,
                                            Value = "X"
                                        },
                                        new StringRuleItem
                                        {
                                            Operand = "ReferrerUrl",
                                            Operator = StringOperator.DoesNotContain,
                                            Value = "Z"
                                        },
                                    }
                                },
                                new RuleItemGroup
                                {
                                    Items = new []
                                    {
                                        new StringRuleItem
                                        {
                                            Operand = "Url",
                                            Operator = StringOperator.DoesNotBeginWith,
                                            Value = "Y"
                                        },
                                    }
                                },
                                new RuleItemGroup
                                {
                                    Items = new []
                                    {
                                        new StringRuleItem
                                        {
                                            Operand = "ReferrerUrl",
                                            Operator = StringOperator.Equals,
                                            Value = "Z"
                                        },
                                    }
                                },
                            },
                        },
                        Scope = EntityScope.Account,
                        TagId = tagId
                    },
                    new RemarketingList
                    {
                        Description = "New list with PageVisitorsWhoVisitedAnotherPageRule",
                        MembershipDuration = 30,
                        Name = "Remarketing List with PageVisitorsWhoVisitedAnotherPageRule " + DateTime.UtcNow,
                        ParentId = authorizationData.AccountId,
                        // The rule definition is translated to the following logical expression: 
                        // (((Url Contains X) and (ReferrerUrl NotEquals Z)) or ((Url DoesNotBeginWith Y)) or 
                        // ((ReferrerUrl Equals Z))) 
                        // and (((Url BeginsWith A) and (ReferrerUrl BeginsWith B)) or ((Url Contains C)))
                        Rule = new PageVisitorsWhoVisitedAnotherPageRule
                        {
                            AnotherRuleItemGroups = new []
                            {
                                new RuleItemGroup
                                {
                                    Items = new []
                                    {
                                        new StringRuleItem
                                        {
                                            Operand = "Url",
                                            Operator = StringOperator.BeginsWith,
                                            Value = "A"
                                        },
                                        new StringRuleItem
                                        {
                                            Operand = "ReferrerUrl",
                                            Operator = StringOperator.BeginsWith,
                                            Value = "B"
                                        },
                                    }
                                },
                                new RuleItemGroup
                                {
                                    Items = new []
                                    {
                                        new StringRuleItem
                                        {
                                            Operand = "Url",
                                            Operator = StringOperator.Contains,
                                            Value = "C"
                                        },
                                    }
                                },
                            },
                            RuleItemGroups = new []
                            {
                                new RuleItemGroup
                                {
                                    Items = new []
                                    {
                                        new StringRuleItem
                                        {
                                            Operand = "Url",
                                            Operator = StringOperator.Contains,
                                            Value = "X"
                                        },
                                        new StringRuleItem
                                        {
                                            Operand = "ReferrerUrl",
                                            Operator = StringOperator.DoesNotContain,
                                            Value = "Z"
                                        },
                                    }
                                },
                                new RuleItemGroup
                                {
                                    Items = new []
                                    {
                                        new StringRuleItem
                                        {
                                            Operand = "Url",
                                            Operator = StringOperator.DoesNotBeginWith,
                                            Value = "Y"
                                        },
                                    }
                                },
                                new RuleItemGroup
                                {
                                    Items = new []
                                    {
                                        new StringRuleItem
                                        {
                                            Operand = "ReferrerUrl",
                                            Operator = StringOperator.Equals,
                                            Value = "Z"
                                        },
                                    }
                                },
                            },
                        },
                        Scope = EntityScope.Account,
                        TagId = tagId
                    },
                };

                // RemarketingList extends the Audience base class. 
                // We manage remarketing lists with Audience operations.

                OutputStatusMessage("-----\nAddAudiences:");
                var addAudiencesResponse = await CampaignManagementExampleHelper.AddAudiencesAsync(
                    audiences: addAudiences);
                long?[] audienceIds = addAudiencesResponse.AudienceIds.ToArray();
                BatchError[] audienceErrors = addAudiencesResponse.PartialErrors.ToArray();
                OutputStatusMessage("AudienceIds:");
                CampaignManagementExampleHelper.OutputArrayOfLong(audienceIds);
                OutputStatusMessage("PartialErrors:");
                CampaignManagementExampleHelper.OutputArrayOfBatchError(audienceErrors);
                
                // Add an ad group in a campaign. The ad group will later be associated with remarketing lists. 

                var campaigns = new[]{
                    new Campaign
                    {
                        BudgetType = BudgetLimitType.DailyBudgetStandard,
                        DailyBudget = 50,
                        Languages = new string[] { "All" },
                        Name = "Everyone's Shoes " + DateTime.UtcNow,
                        TimeZone = "PacificTimeUSCanadaTijuana",
                    },
                };

                OutputStatusMessage("-----\nAddCampaigns:");
                AddCampaignsResponse addCampaignsResponse = await CampaignManagementExampleHelper.AddCampaignsAsync(
                    accountId: authorizationData.AccountId,
                    campaigns: campaigns);
                long?[] campaignIds = addCampaignsResponse.CampaignIds.ToArray();
                BatchError[] campaignErrors = addCampaignsResponse.PartialErrors.ToArray();
                OutputStatusMessage("CampaignIds:");
                CampaignManagementExampleHelper.OutputArrayOfLong(campaignIds);
                OutputStatusMessage("PartialErrors:");
                CampaignManagementExampleHelper.OutputArrayOfBatchError(campaignErrors);
                
                var adGroups = new[] {
                    new AdGroup
                    {
                        Name = "Everyone's Red Shoe Sale",
                        StartDate = null,
                        EndDate = new Date {
                            Month = 12,
                            Day = 31,
                            Year = DateTime.UtcNow.Year + 1
                        },
                        CpcBid = new Bid { Amount = 0.09 },

                        // Applicable for all remarketing lists that are associated with this ad group. TargetAndBid indicates 
                        // that you want to show ads only to people included in the remarketing list, with the option to change
                        // the bid amount. Ads in this ad group will only show to people included in the remarketing list.
                        Settings = new[]
                        {
                            new TargetSetting
                            {
                                Details = new []
                                {
                                    new TargetSettingDetail
                                    {
                                        CriterionTypeGroup = CriterionTypeGroup.Audience,
                                        TargetAndBid = true
                                    }
                                }
                            }
                        },
                    }
                };
                
                OutputStatusMessage("-----\nAddAdGroups:");
                AddAdGroupsResponse addAdGroupsResponse = await CampaignManagementExampleHelper.AddAdGroupsAsync(
                    campaignId: (long)campaignIds[0],
                    adGroups: adGroups,
                    returnInheritedBidStrategyTypes: false);
                long?[] adGroupIds = addAdGroupsResponse.AdGroupIds.ToArray();
                BatchError[] adGroupErrors = addAdGroupsResponse.PartialErrors.ToArray();
                OutputStatusMessage("AdGroupIds:");
                CampaignManagementExampleHelper.OutputArrayOfLong(adGroupIds);
                OutputStatusMessage("PartialErrors:");
                CampaignManagementExampleHelper.OutputArrayOfBatchError(adGroupErrors);

                // Associate all of the remarketing lists created above with the new ad group.

                var adGroupRemarketingListAssociations = new List<AdGroupCriterion>();                               
                
                foreach (var audienceId in audienceIds)
                {
                    if(audienceId != null)
                    {
                        var biddableAdGroupCriterion = new BiddableAdGroupCriterion
                        {
                            AdGroupId = (long)adGroupIds[0],
                            Criterion = new AudienceCriterion
                            {
                                AudienceId = audienceId,
                                AudienceType = AudienceType.RemarketingList,
                            },
                            CriterionBid = new BidMultiplier
                            {
                                Multiplier = 20.00,
                            },
                            Status = AdGroupCriterionStatus.Active,
                        };

                        adGroupRemarketingListAssociations.Add(biddableAdGroupCriterion);
                    }
                }
                
                OutputStatusMessage("-----\nAddAdGroupCriterions:");
                CampaignManagementExampleHelper.OutputArrayOfAdGroupCriterion(adGroupRemarketingListAssociations);
                AddAdGroupCriterionsResponse addAdGroupCriterionsResponse = await CampaignManagementExampleHelper.AddAdGroupCriterionsAsync(
                        adGroupCriterions: adGroupRemarketingListAssociations,
                        criterionType: AdGroupCriterionType.Audience);
                long?[] nullableAdGroupCriterionIds = addAdGroupCriterionsResponse.AdGroupCriterionIds.ToArray();
                OutputStatusMessage("AdGroupCriterionIds:");
                CampaignManagementExampleHelper.OutputArrayOfLong(nullableAdGroupCriterionIds);
                BatchErrorCollection[] adGroupCriterionErrors =
                    addAdGroupCriterionsResponse.NestedPartialErrors.ToArray();
                OutputStatusMessage("NestedPartialErrors:");
                CampaignManagementExampleHelper.OutputArrayOfBatchErrorCollection(adGroupCriterionErrors);
                
                // Delete the campaign and everything it contains e.g., ad groups and ads.

                OutputStatusMessage("-----\nDeleteCampaigns:");
                await CampaignManagementExampleHelper.DeleteCampaignsAsync(
                    accountId: authorizationData.AccountId,
                    campaignIds: new[] { (long)campaignIds[0] });
                OutputStatusMessage(string.Format("Deleted Campaign Id {0}", campaignIds[0]));

                // Delete the remarketing lists.

                OutputStatusMessage("-----\nDeleteAudiences:");
                await CampaignManagementExampleHelper.DeleteAudiencesAsync(
                    audienceIds: new[] { (long)audienceIds[0] });
                OutputStatusMessage(string.Format("Deleted Audience Id {0}", audienceIds[0]));
            }
            // Catch authentication exceptions
            catch (OAuthTokenRequestException ex)
            {
                OutputStatusMessage(string.Format("Couldn't get OAuth tokens. Error: {0}. Description: {1}", ex.Details.Error, ex.Details.Description));
            }
            // Catch Campaign Management service exceptions
            catch (FaultException<Microsoft.BingAds.V13.CampaignManagement.AdApiFaultDetail> ex)
            {
                OutputStatusMessage(string.Join("; ", ex.Detail.Errors.Select(error => string.Format("{0}: {1}", error.Code, error.Message))));
            }
            catch (FaultException<Microsoft.BingAds.V13.CampaignManagement.ApiFaultDetail> ex)
            {
                OutputStatusMessage(string.Join("; ", ex.Detail.OperationErrors.Select(error => string.Format("{0}: {1}", error.Code, error.Message))));
                OutputStatusMessage(string.Join("; ", ex.Detail.BatchErrors.Select(error => string.Format("{0}: {1}", error.Code, error.Message))));
            }
            catch (FaultException<Microsoft.BingAds.V13.CampaignManagement.EditorialApiFaultDetail> ex)
            {
                OutputStatusMessage(string.Join("; ", ex.Detail.OperationErrors.Select(error => string.Format("{0}: {1}", error.Code, error.Message))));
                OutputStatusMessage(string.Join("; ", ex.Detail.BatchErrors.Select(error => string.Format("{0}: {1}", error.Code, error.Message))));
            }
            catch (Exception ex)
            {
                OutputStatusMessage(ex.Message);
            }
        }

    }
}
package com.microsoft.bingads.examples.v13;

import java.util.ArrayList;
import java.util.Calendar;

import com.microsoft.bingads.*;
import com.microsoft.bingads.v13.campaignmanagement.*;
import java.math.BigDecimal;

// How to associate remarketing lists with a new ad group.

public class RemarketingLists extends ExampleBase {
    
    public static void main(java.lang.String[] args) {
     
        try
        {
            authorizationData = getAuthorizationData();
             
            CampaignManagementExampleHelper.CampaignManagementService = new ServiceClient<ICampaignManagementService>(
                        authorizationData, 
                        API_ENVIRONMENT,
                        ICampaignManagementService.class);

            // Before you can track conversions or target audiences using a remarketing list 
            // you need to create a UET tag, and then add the UET tag tracking code to every page of your website.
            // For more information, please see Universal Event Tracking at https://go.microsoft.com/fwlink/?linkid=829965.

            // First you should call the GetUetTagsByIds operation to check whether a tag has already been created. 
            // You can leave the TagIds element null or empty to request all UET tags available for the customer.

            outputStatusMessage("-----\nGetUetTagsByIds:");
            GetUetTagsByIdsResponse getUetTagsByIdsResponse = CampaignManagementExampleHelper.getUetTagsByIds(
                    null);
            ArrayOfUetTag uetTags = getUetTagsByIdsResponse.getUetTags();

            // If you do not already have a UET tag that can be used, or if you need another UET tag, 
            // call the AddUetTags service operation to create a new UET tag. If the call is successful, 
            // the tracking script that you should add to your website is included in a corresponding 
            // UetTag within the response message. 

            if (uetTags == null || uetTags.getUetTags().size() < 1)
            {
                UetTag uetTag = new UetTag();
                uetTag.setDescription("My First Uet Tag");
                uetTag.setName("New Uet Tag");
                uetTags.getUetTags().add(uetTag);
                outputStatusMessage("-----\nAddUetTags:");
                uetTags = CampaignManagementExampleHelper.addUetTags(
                    uetTags).getUetTags();
            }

            if (uetTags == null || uetTags.getUetTags().size() < 1)
            {
                outputStatusMessage(
                    String.format("You do not have any UET tags registered for CustomerId {0}.", authorizationData.getCustomerId())
                );
                return;
            }

            outputStatusMessage("List of all UET Tags:");
            CampaignManagementExampleHelper.outputArrayOfUetTag(uetTags);

            // After you retreive the tracking script from the AddUetTags or GetUetTagsByIds operation, 
            // the next step is to add the UET tag tracking code to your website. 

            // We will use the same UET tag for the remainder of this example.
            java.lang.Long tagId = uetTags.getUetTags().get(0).getId();

            // Add remarketing lists that depend on the UET Tag Id retreived above.

            ArrayOfAudience addAudiences = new ArrayOfAudience();
            RemarketingList customEventsList = new RemarketingList();
            customEventsList.setDescription("New list with CustomEventsRule");
            customEventsList.setMembershipDuration(30);
            customEventsList.setName("Remarketing List with CustomEventsRule " + System.currentTimeMillis());
            customEventsList.setParentId(authorizationData.getAccountId());
            // The rule definition is translated to the following logical expression: 
            // (Category Equals video) and (Action Equals play) and (Label Equals trailer) 
            // and (Value Equals 5)
            CustomEventsRule customEventsRule = new CustomEventsRule();
            // The type of user interaction you want to track.
            customEventsRule.setAction("play");
            customEventsRule.setActionOperator(StringOperator.EQUALS);
            // The category of event you want to track. 
            customEventsRule.setCategory("video");
            customEventsRule.setCategoryOperator(StringOperator.EQUALS);
            // The name of the element that caused the action.
            customEventsRule.setLabel("trailer");
            customEventsRule.setLabelOperator(StringOperator.EQUALS);
            // A numerical value associated with that event. 
            // Could be length of the video played etc.
            customEventsRule.setValue(new BigDecimal(5.00));
            customEventsRule.setValueOperator(NumberOperator.EQUALS);
            customEventsList.setRule(customEventsRule);
            customEventsList.setScope(EntityScope.ACCOUNT);
            customEventsList.setTagId(tagId);            
            addAudiences.getAudiences().add(customEventsList);
                        
            RemarketingList pageVisitorsList = new RemarketingList();  
            pageVisitorsList.setDescription("New list with PageVisitorsRule");
            pageVisitorsList.setMembershipDuration(30);
            pageVisitorsList.setName("Remarketing List with PageVisitorsRule " + System.currentTimeMillis());
            pageVisitorsList.setParentId(authorizationData.getAccountId());
            // The rule definition is translated to the following logical expression: 
            // ((Url Contains X) and (ReferrerUrl DoesNotContain Z)) or ((Url DoesNotBeginWith Y)) 
            // or ((ReferrerUrl Equals Z))
            PageVisitorsRule pageVisitorsRule = new PageVisitorsRule();
            ArrayOfRuleItemGroup pageVisitorsRuleItemGroups = new ArrayOfRuleItemGroup();
            RuleItemGroup pageVisitorsRuleItemGroupA = new RuleItemGroup();
            ArrayOfRuleItem pageVisitorsRuleItemsA = new ArrayOfRuleItem();
            StringRuleItem pageVisitorsRuleItemA = new StringRuleItem();
            pageVisitorsRuleItemA.setOperand("Url");
            pageVisitorsRuleItemA.setOperator(StringOperator.CONTAINS);
            pageVisitorsRuleItemA.setValue("X");
            pageVisitorsRuleItemsA.getRuleItems().add(pageVisitorsRuleItemA);   
            StringRuleItem pageVisitorsRuleItemAA = new StringRuleItem();
            pageVisitorsRuleItemAA.setOperand("ReferrerUrl");
            pageVisitorsRuleItemAA.setOperator(StringOperator.DOES_NOT_CONTAIN);
            pageVisitorsRuleItemAA.setValue("Z");
            pageVisitorsRuleItemsA.getRuleItems().add(pageVisitorsRuleItemAA);    
            pageVisitorsRuleItemGroupA.setItems(pageVisitorsRuleItemsA);
            pageVisitorsRuleItemGroups.getRuleItemGroups().add(pageVisitorsRuleItemGroupA);
            RuleItemGroup pageVisitorsRuleItemGroupB = new RuleItemGroup();
            ArrayOfRuleItem pageVisitorsRuleItemsB = new ArrayOfRuleItem();
            StringRuleItem pageVisitorsRuleItemB = new StringRuleItem();
            pageVisitorsRuleItemB.setOperand("Url");
            pageVisitorsRuleItemB.setOperator(StringOperator.DOES_NOT_BEGIN_WITH);
            pageVisitorsRuleItemB.setValue("Y");
            pageVisitorsRuleItemsB.getRuleItems().add(pageVisitorsRuleItemB);            
            pageVisitorsRuleItemGroupB.setItems(pageVisitorsRuleItemsB);
            pageVisitorsRuleItemGroups.getRuleItemGroups().add(pageVisitorsRuleItemGroupB);
            RuleItemGroup pageVisitorsRuleItemGroupC = new RuleItemGroup();
            ArrayOfRuleItem pageVisitorsRuleItemsC = new ArrayOfRuleItem();
            StringRuleItem pageVisitorsRuleItemC = new StringRuleItem();
            pageVisitorsRuleItemC.setOperand("ReferrerUrl");
            pageVisitorsRuleItemC.setOperator(StringOperator.EQUALS);
            pageVisitorsRuleItemC.setValue("Z");
            pageVisitorsRuleItemsC.getRuleItems().add(pageVisitorsRuleItemC);            
            pageVisitorsRuleItemGroupC.setItems(pageVisitorsRuleItemsC);
            pageVisitorsRuleItemGroups.getRuleItemGroups().add(pageVisitorsRuleItemGroupC);
            pageVisitorsRule.setRuleItemGroups(pageVisitorsRuleItemGroups);
            pageVisitorsList.setRule(pageVisitorsRule);
            pageVisitorsList.setScope(EntityScope.ACCOUNT);
            pageVisitorsList.setTagId(tagId); 
            addAudiences.getAudiences().add(pageVisitorsList);
            
            RemarketingList pageVisitorsWhoDidNotVisitAnotherPageList = new RemarketingList();        
            pageVisitorsWhoDidNotVisitAnotherPageList.setDescription("New list with PageVisitorsWhoDidNotVisitAnotherPageRule");
            pageVisitorsWhoDidNotVisitAnotherPageList.setMembershipDuration(30);
            pageVisitorsWhoDidNotVisitAnotherPageList.setName("Remarketing List with PageVisitorsWhoDidNotVisitAnotherPageRule " + System.currentTimeMillis());
            pageVisitorsWhoDidNotVisitAnotherPageList.setParentId(authorizationData.getAccountId());
            // The rule definition is translated to the following logical expression: 
            // (((Url Contains X) and (ReferrerUrl DoesNotContain Z)) or ((Url DoesNotBeginWith Y)) 
            // or ((ReferrerUrl Equals Z))) 
            // and not (((Url BeginsWith A) and (ReferrerUrl BeginsWith B)) or ((Url Contains C)))
            PageVisitorsWhoDidNotVisitAnotherPageRule pageVisitorsWhoDidNotVisitAnotherPageRule = new PageVisitorsWhoDidNotVisitAnotherPageRule();            
            ArrayOfRuleItemGroup pageVisitorsWhoDidNotVisitAnotherPageExcludeRuleItemGroups = new ArrayOfRuleItemGroup();
            RuleItemGroup pageVisitorsWhoDidNotVisitAnotherPageExcludeRuleItemGroupA = new RuleItemGroup();
            ArrayOfRuleItem pageVisitorsWhoDidNotVisitAnotherPageExcludeRuleItemsA = new ArrayOfRuleItem();
            StringRuleItem pageVisitorsWhoDidNotVisitAnotherPageExcludeRuleItemA = new StringRuleItem();
            pageVisitorsWhoDidNotVisitAnotherPageExcludeRuleItemA.setOperand("Url");
            pageVisitorsWhoDidNotVisitAnotherPageExcludeRuleItemA.setOperator(StringOperator.BEGINS_WITH);
            pageVisitorsWhoDidNotVisitAnotherPageExcludeRuleItemA.setValue("A");
            pageVisitorsWhoDidNotVisitAnotherPageExcludeRuleItemsA.getRuleItems().add(pageVisitorsWhoDidNotVisitAnotherPageExcludeRuleItemA);   
            StringRuleItem pageVisitorsWhoDidNotVisitAnotherPageExcludeRuleItemAA = new StringRuleItem();
            pageVisitorsWhoDidNotVisitAnotherPageExcludeRuleItemAA.setOperand("ReferrerUrl");
            pageVisitorsWhoDidNotVisitAnotherPageExcludeRuleItemAA.setOperator(StringOperator.BEGINS_WITH);
            pageVisitorsWhoDidNotVisitAnotherPageExcludeRuleItemAA.setValue("B");
            pageVisitorsWhoDidNotVisitAnotherPageExcludeRuleItemsA.getRuleItems().add(pageVisitorsWhoDidNotVisitAnotherPageExcludeRuleItemAA);    
            pageVisitorsWhoDidNotVisitAnotherPageExcludeRuleItemGroupA.setItems(pageVisitorsWhoDidNotVisitAnotherPageExcludeRuleItemsA);
            pageVisitorsWhoDidNotVisitAnotherPageExcludeRuleItemGroups.getRuleItemGroups().add(pageVisitorsWhoDidNotVisitAnotherPageExcludeRuleItemGroupA);
            RuleItemGroup pageVisitorsWhoDidNotVisitAnotherPageExcludeRuleItemGroupB = new RuleItemGroup();
            ArrayOfRuleItem pageVisitorsWhoDidNotVisitAnotherPageExcludeRuleItemsB = new ArrayOfRuleItem();
            StringRuleItem pageVisitorsWhoDidNotVisitAnotherPageExcludeRuleItemB = new StringRuleItem();
            pageVisitorsWhoDidNotVisitAnotherPageExcludeRuleItemB.setOperand("Url");
            pageVisitorsWhoDidNotVisitAnotherPageExcludeRuleItemB.setOperator(StringOperator.CONTAINS);
            pageVisitorsWhoDidNotVisitAnotherPageExcludeRuleItemB.setValue("C");
            pageVisitorsWhoDidNotVisitAnotherPageExcludeRuleItemsB.getRuleItems().add(pageVisitorsWhoDidNotVisitAnotherPageExcludeRuleItemB);            
            pageVisitorsWhoDidNotVisitAnotherPageExcludeRuleItemGroupB.setItems(pageVisitorsWhoDidNotVisitAnotherPageExcludeRuleItemsB);
            pageVisitorsWhoDidNotVisitAnotherPageExcludeRuleItemGroups.getRuleItemGroups().add(pageVisitorsWhoDidNotVisitAnotherPageExcludeRuleItemGroupB);
            pageVisitorsWhoDidNotVisitAnotherPageRule.setExcludeRuleItemGroups(pageVisitorsWhoDidNotVisitAnotherPageExcludeRuleItemGroups);            
            ArrayOfRuleItemGroup pageVisitorsWhoDidNotVisitAnotherPageIncludeRuleItemGroups = new ArrayOfRuleItemGroup();
            RuleItemGroup pageVisitorsWhoDidNotVisitAnotherPageIncludeRuleItemGroupA = new RuleItemGroup();
            ArrayOfRuleItem pageVisitorsWhoDidNotVisitAnotherPageIncludeRuleItemsA = new ArrayOfRuleItem();
            StringRuleItem pageVisitorsWhoDidNotVisitAnotherPageIncludeRuleItemA = new StringRuleItem();
            pageVisitorsWhoDidNotVisitAnotherPageIncludeRuleItemA.setOperand("Url");
            pageVisitorsWhoDidNotVisitAnotherPageIncludeRuleItemA.setOperator(StringOperator.CONTAINS);
            pageVisitorsWhoDidNotVisitAnotherPageIncludeRuleItemA.setValue("X");
            pageVisitorsWhoDidNotVisitAnotherPageIncludeRuleItemsA.getRuleItems().add(pageVisitorsWhoDidNotVisitAnotherPageIncludeRuleItemA);   
            StringRuleItem pageVisitorsWhoDidNotVisitAnotherPageIncludeRuleItemAA = new StringRuleItem();
            pageVisitorsWhoDidNotVisitAnotherPageIncludeRuleItemAA.setOperand("ReferrerUrl");
            pageVisitorsWhoDidNotVisitAnotherPageIncludeRuleItemAA.setOperator(StringOperator.DOES_NOT_CONTAIN);
            pageVisitorsWhoDidNotVisitAnotherPageIncludeRuleItemAA.setValue("Z");
            pageVisitorsWhoDidNotVisitAnotherPageIncludeRuleItemsA.getRuleItems().add(pageVisitorsWhoDidNotVisitAnotherPageIncludeRuleItemAA);    
            pageVisitorsWhoDidNotVisitAnotherPageIncludeRuleItemGroupA.setItems(pageVisitorsWhoDidNotVisitAnotherPageIncludeRuleItemsA);
            pageVisitorsWhoDidNotVisitAnotherPageIncludeRuleItemGroups.getRuleItemGroups().add(pageVisitorsWhoDidNotVisitAnotherPageIncludeRuleItemGroupA);
            RuleItemGroup pageVisitorsWhoDidNotVisitAnotherPageIncludeRuleItemGroupB = new RuleItemGroup();
            ArrayOfRuleItem pageVisitorsWhoDidNotVisitAnotherPageIncludeRuleItemsB = new ArrayOfRuleItem();
            StringRuleItem pageVisitorsWhoDidNotVisitAnotherPageIncludeRuleItemB = new StringRuleItem();
            pageVisitorsWhoDidNotVisitAnotherPageIncludeRuleItemB.setOperand("Url");
            pageVisitorsWhoDidNotVisitAnotherPageIncludeRuleItemB.setOperator(StringOperator.DOES_NOT_BEGIN_WITH);
            pageVisitorsWhoDidNotVisitAnotherPageIncludeRuleItemB.setValue("Y");
            pageVisitorsWhoDidNotVisitAnotherPageIncludeRuleItemsB.getRuleItems().add(pageVisitorsWhoDidNotVisitAnotherPageIncludeRuleItemB);            
            pageVisitorsWhoDidNotVisitAnotherPageIncludeRuleItemGroupB.setItems(pageVisitorsWhoDidNotVisitAnotherPageIncludeRuleItemsB);
            pageVisitorsWhoDidNotVisitAnotherPageIncludeRuleItemGroups.getRuleItemGroups().add(pageVisitorsWhoDidNotVisitAnotherPageIncludeRuleItemGroupB);
            RuleItemGroup pageVisitorsWhoDidNotVisitAnotherPageIncludeRuleItemGroupC = new RuleItemGroup();
            ArrayOfRuleItem pageVisitorsWhoDidNotVisitAnotherPageIncludeRuleItemsC = new ArrayOfRuleItem();
            StringRuleItem pageVisitorsWhoDidNotVisitAnotherPageIncludeRuleItemC = new StringRuleItem();
            pageVisitorsWhoDidNotVisitAnotherPageIncludeRuleItemC.setOperand("ReferrerUrl");
            pageVisitorsWhoDidNotVisitAnotherPageIncludeRuleItemC.setOperator(StringOperator.EQUALS);
            pageVisitorsWhoDidNotVisitAnotherPageIncludeRuleItemC.setValue("Z");
            pageVisitorsWhoDidNotVisitAnotherPageIncludeRuleItemsC.getRuleItems().add(pageVisitorsWhoDidNotVisitAnotherPageIncludeRuleItemC);            
            pageVisitorsWhoDidNotVisitAnotherPageIncludeRuleItemGroupC.setItems(pageVisitorsWhoDidNotVisitAnotherPageIncludeRuleItemsC);
            pageVisitorsWhoDidNotVisitAnotherPageIncludeRuleItemGroups.getRuleItemGroups().add(pageVisitorsWhoDidNotVisitAnotherPageIncludeRuleItemGroupC);
            pageVisitorsWhoDidNotVisitAnotherPageRule.setIncludeRuleItemGroups(pageVisitorsWhoDidNotVisitAnotherPageIncludeRuleItemGroups);
            pageVisitorsWhoDidNotVisitAnotherPageList.setRule(pageVisitorsWhoDidNotVisitAnotherPageRule);
            pageVisitorsWhoDidNotVisitAnotherPageList.setScope(EntityScope.ACCOUNT);
            pageVisitorsWhoDidNotVisitAnotherPageList.setTagId(tagId);   
            addAudiences.getAudiences().add(pageVisitorsWhoDidNotVisitAnotherPageList);

            RemarketingList pageVisitorsWhoVisitedAnotherPageList = new RemarketingList();  
            pageVisitorsWhoVisitedAnotherPageList.setDescription("New list with PageVisitorsWhoVisitedAnotherPageRule");
            pageVisitorsWhoVisitedAnotherPageList.setMembershipDuration(30);
            pageVisitorsWhoVisitedAnotherPageList.setName("Remarketing List with PageVisitorsWhoVisitedAnotherPageRule " + System.currentTimeMillis());
            pageVisitorsWhoVisitedAnotherPageList.setParentId(authorizationData.getAccountId());
            // The rule definition is translated to the following logical expression: 
            // (((Url Contains X) and (ReferrerUrl NotEquals Z)) or ((Url DoesNotBeginWith Y)) or 
            // ((ReferrerUrl Equals Z))) 
            // and (((Url BeginsWith A) and (ReferrerUrl BeginsWith B)) or ((Url Contains C)))
            PageVisitorsWhoVisitedAnotherPageRule pageVisitorsWhoVisitedAnotherPageRule = new PageVisitorsWhoVisitedAnotherPageRule();            
            ArrayOfRuleItemGroup pageVisitorsWhoVisitedAnotherPageAnotherRuleItemGroups = new ArrayOfRuleItemGroup();
            RuleItemGroup pageVisitorsWhoVisitedAnotherPageAnotherRuleItemGroupA = new RuleItemGroup();
            ArrayOfRuleItem pageVisitorsWhoVisitedAnotherPageAnotherRuleItemsA = new ArrayOfRuleItem();
            StringRuleItem pageVisitorsWhoVisitedAnotherPageAnotherRuleItemA = new StringRuleItem();
            pageVisitorsWhoVisitedAnotherPageAnotherRuleItemA.setOperand("Url");
            pageVisitorsWhoVisitedAnotherPageAnotherRuleItemA.setOperator(StringOperator.BEGINS_WITH);
            pageVisitorsWhoVisitedAnotherPageAnotherRuleItemA.setValue("A");
            pageVisitorsWhoVisitedAnotherPageAnotherRuleItemsA.getRuleItems().add(pageVisitorsWhoVisitedAnotherPageAnotherRuleItemA);   
            StringRuleItem pageVisitorsWhoVisitedAnotherPageAnotherRuleItemAA = new StringRuleItem();
            pageVisitorsWhoVisitedAnotherPageAnotherRuleItemAA.setOperand("ReferrerUrl");
            pageVisitorsWhoVisitedAnotherPageAnotherRuleItemAA.setOperator(StringOperator.BEGINS_WITH);
            pageVisitorsWhoVisitedAnotherPageAnotherRuleItemAA.setValue("B");
            pageVisitorsWhoVisitedAnotherPageAnotherRuleItemsA.getRuleItems().add(pageVisitorsWhoVisitedAnotherPageAnotherRuleItemAA);    
            pageVisitorsWhoVisitedAnotherPageAnotherRuleItemGroupA.setItems(pageVisitorsWhoVisitedAnotherPageAnotherRuleItemsA);
            pageVisitorsWhoVisitedAnotherPageAnotherRuleItemGroups.getRuleItemGroups().add(pageVisitorsWhoVisitedAnotherPageAnotherRuleItemGroupA);
            RuleItemGroup pageVisitorsWhoVisitedAnotherPageAnotherRuleItemGroupB = new RuleItemGroup();
            ArrayOfRuleItem pageVisitorsWhoVisitedAnotherPageAnotherRuleItemsB = new ArrayOfRuleItem();
            StringRuleItem pageVisitorsWhoVisitedAnotherPageAnotherRuleItemB = new StringRuleItem();
            pageVisitorsWhoVisitedAnotherPageAnotherRuleItemB.setOperand("Url");
            pageVisitorsWhoVisitedAnotherPageAnotherRuleItemB.setOperator(StringOperator.CONTAINS);
            pageVisitorsWhoVisitedAnotherPageAnotherRuleItemB.setValue("C");
            pageVisitorsWhoVisitedAnotherPageAnotherRuleItemsB.getRuleItems().add(pageVisitorsWhoVisitedAnotherPageAnotherRuleItemB);            
            pageVisitorsWhoVisitedAnotherPageAnotherRuleItemGroupB.setItems(pageVisitorsWhoVisitedAnotherPageAnotherRuleItemsB);
            pageVisitorsWhoVisitedAnotherPageAnotherRuleItemGroups.getRuleItemGroups().add(pageVisitorsWhoVisitedAnotherPageAnotherRuleItemGroupB);
            pageVisitorsWhoVisitedAnotherPageRule.setAnotherRuleItemGroups(pageVisitorsWhoVisitedAnotherPageAnotherRuleItemGroups);            
            ArrayOfRuleItemGroup pageVisitorsWhoVisitedAnotherPageRuleItemGroups = new ArrayOfRuleItemGroup();
            RuleItemGroup pageVisitorsWhoVisitedAnotherPageRuleItemGroupA = new RuleItemGroup();
            ArrayOfRuleItem pageVisitorsWhoVisitedAnotherPageRuleItemsA = new ArrayOfRuleItem();
            StringRuleItem pageVisitorsWhoVisitedAnotherPageRuleItemA = new StringRuleItem();
            pageVisitorsWhoVisitedAnotherPageRuleItemA.setOperand("Url");
            pageVisitorsWhoVisitedAnotherPageRuleItemA.setOperator(StringOperator.CONTAINS);
            pageVisitorsWhoVisitedAnotherPageRuleItemA.setValue("X");
            pageVisitorsWhoVisitedAnotherPageRuleItemsA.getRuleItems().add(pageVisitorsWhoVisitedAnotherPageRuleItemA);   
            StringRuleItem pageVisitorsWhoVisitedAnotherPageRuleItemAA = new StringRuleItem();
            pageVisitorsWhoVisitedAnotherPageRuleItemAA.setOperand("ReferrerUrl");
            pageVisitorsWhoVisitedAnotherPageRuleItemAA.setOperator(StringOperator.DOES_NOT_CONTAIN);
            pageVisitorsWhoVisitedAnotherPageRuleItemAA.setValue("Z");
            pageVisitorsWhoVisitedAnotherPageRuleItemsA.getRuleItems().add(pageVisitorsWhoVisitedAnotherPageRuleItemAA);    
            pageVisitorsWhoVisitedAnotherPageRuleItemGroupA.setItems(pageVisitorsWhoVisitedAnotherPageRuleItemsA);
            pageVisitorsWhoVisitedAnotherPageRuleItemGroups.getRuleItemGroups().add(pageVisitorsWhoVisitedAnotherPageRuleItemGroupA);
            RuleItemGroup pageVisitorsWhoVisitedAnotherPageRuleItemGroupB = new RuleItemGroup();
            ArrayOfRuleItem pageVisitorsWhoVisitedAnotherPageRuleItemsB = new ArrayOfRuleItem();
            StringRuleItem pageVisitorsWhoVisitedAnotherPageRuleItemB = new StringRuleItem();
            pageVisitorsWhoVisitedAnotherPageRuleItemB.setOperand("Url");
            pageVisitorsWhoVisitedAnotherPageRuleItemB.setOperator(StringOperator.DOES_NOT_BEGIN_WITH);
            pageVisitorsWhoVisitedAnotherPageRuleItemB.setValue("Y");
            pageVisitorsWhoVisitedAnotherPageRuleItemsB.getRuleItems().add(pageVisitorsWhoVisitedAnotherPageRuleItemB);            
            pageVisitorsWhoVisitedAnotherPageRuleItemGroupB.setItems(pageVisitorsWhoVisitedAnotherPageRuleItemsB);
            pageVisitorsWhoVisitedAnotherPageRuleItemGroups.getRuleItemGroups().add(pageVisitorsWhoVisitedAnotherPageRuleItemGroupB);
            RuleItemGroup pageVisitorsWhoVisitedAnotherPageRuleItemGroupC = new RuleItemGroup();
            ArrayOfRuleItem pageVisitorsWhoVisitedAnotherPageRuleItemsC = new ArrayOfRuleItem();
            StringRuleItem pageVisitorsWhoVisitedAnotherPageRuleItemC = new StringRuleItem();
            pageVisitorsWhoVisitedAnotherPageRuleItemC.setOperand("ReferrerUrl");
            pageVisitorsWhoVisitedAnotherPageRuleItemC.setOperator(StringOperator.EQUALS);
            pageVisitorsWhoVisitedAnotherPageRuleItemC.setValue("Z");
            pageVisitorsWhoVisitedAnotherPageRuleItemsC.getRuleItems().add(pageVisitorsWhoVisitedAnotherPageRuleItemC);            
            pageVisitorsWhoVisitedAnotherPageRuleItemGroupC.setItems(pageVisitorsWhoVisitedAnotherPageRuleItemsC);
            pageVisitorsWhoVisitedAnotherPageRuleItemGroups.getRuleItemGroups().add(pageVisitorsWhoVisitedAnotherPageRuleItemGroupC);
            pageVisitorsWhoVisitedAnotherPageRule.setRuleItemGroups(pageVisitorsWhoVisitedAnotherPageRuleItemGroups);  
            pageVisitorsWhoVisitedAnotherPageList.setRule(pageVisitorsWhoVisitedAnotherPageRule);
            pageVisitorsWhoVisitedAnotherPageList.setScope(EntityScope.ACCOUNT);
            pageVisitorsWhoVisitedAnotherPageList.setTagId(tagId);   
            addAudiences.getAudiences().add(pageVisitorsWhoVisitedAnotherPageList);    

            // RemarketingList extends the Audience base class. 
            // We manage remarketing lists with Audience operations.

            outputStatusMessage("-----\nAddAudiences:");
            AddAudiencesResponse addAudiencesResponse = CampaignManagementExampleHelper.addAudiences(
                addAudiences);
            ArrayOfNullableOflong audienceIds = addAudiencesResponse.getAudienceIds();
            ArrayOfBatchError audienceErrors = addAudiencesResponse.getPartialErrors();
            outputStatusMessage("AudienceIds:");
            CampaignManagementExampleHelper.outputArrayOfNullableOflong(audienceIds);
            outputStatusMessage("PartialErrors:");
            CampaignManagementExampleHelper.outputArrayOfBatchError(audienceErrors);
                            
            // Add an ad group in a campaign. The ad group will later be associated with remarketing lists.

            ArrayOfCampaign campaigns = new ArrayOfCampaign();
            Campaign campaign = new Campaign();
            campaign.setBudgetType(BudgetLimitType.DAILY_BUDGET_STANDARD);
            campaign.setDailyBudget(50.00);
            ArrayOfstring languages = new ArrayOfstring();
            languages.getStrings().add("All");
            campaign.setLanguages(languages);
            campaign.setName("Everyone's Shoes " + System.currentTimeMillis());
            campaign.setTimeZone("PacificTimeUSCanadaTijuana");
            campaigns.getCampaigns().add(campaign);

            outputStatusMessage("-----\nAddCampaigns:");
            AddCampaignsResponse addCampaignsResponse = CampaignManagementExampleHelper.addCampaigns(
                    authorizationData.getAccountId(), 
                    campaigns);            
            ArrayOfNullableOflong campaignIds = addCampaignsResponse.getCampaignIds();
            ArrayOfBatchError campaignErrors = addCampaignsResponse.getPartialErrors();
            outputStatusMessage("CampaignIds:");
            CampaignManagementExampleHelper.outputArrayOfNullableOflong(campaignIds);
            outputStatusMessage("PartialErrors:");
            CampaignManagementExampleHelper.outputArrayOfBatchError(campaignErrors);
            
            ArrayOfAdGroup adGroups = new ArrayOfAdGroup();
            AdGroup adGroup = new AdGroup();
            adGroup.setName("Everyone's Red Shoe Sale");
            adGroup.setStartDate(null);
            Calendar calendar = Calendar.getInstance();
            adGroup.setEndDate(new com.microsoft.bingads.v13.campaignmanagement.Date());
            adGroup.getEndDate().setDay(31);
            adGroup.getEndDate().setMonth(12);
            adGroup.getEndDate().setYear(calendar.get(Calendar.YEAR));
            Bid CpcBid = new Bid();
            CpcBid.setAmount(0.09);
            adGroup.setCpcBid(CpcBid);
            // Applicable for all remarketing lists that are associated with this ad group. TargetAndBid indicates 
            // that you want to show ads only to people included in the remarketing list, with the option to change
            // the bid amount. Ads in this ad group will only show to people included in the remarketing list.
            ArrayOfSetting settings = new ArrayOfSetting();
            TargetSetting targetSetting = new TargetSetting();
            ArrayOfTargetSettingDetail targetSettingDetails = new ArrayOfTargetSettingDetail();
            TargetSettingDetail adGroupAudienceTargetSettingDetail = new TargetSettingDetail();
            adGroupAudienceTargetSettingDetail.setCriterionTypeGroup(CriterionTypeGroup.AUDIENCE);
            adGroupAudienceTargetSettingDetail.setTargetAndBid(Boolean.TRUE);
            targetSettingDetails.getTargetSettingDetails().add(adGroupAudienceTargetSettingDetail);
            targetSetting.setDetails(targetSettingDetails);
            settings.getSettings().add(targetSetting);
            adGroup.setSettings(settings);
            adGroups.getAdGroups().add(adGroup);

            outputStatusMessage("-----\nAddAdGroups:");
            AddAdGroupsResponse addAdGroupsResponse = CampaignManagementExampleHelper.addAdGroups(
                    campaignIds.getLongs().get(0), 
                    adGroups, 
                    false);
            ArrayOfNullableOflong adGroupIds = addAdGroupsResponse.getAdGroupIds();
            ArrayOfBatchError adGroupErrors = addAdGroupsResponse.getPartialErrors();
            outputStatusMessage("AdGroupIds:");
            CampaignManagementExampleHelper.outputArrayOfNullableOflong(adGroupIds);
            outputStatusMessage("PartialErrors:");
            CampaignManagementExampleHelper.outputArrayOfBatchError(adGroupErrors); 
            
            // Associate all of the remarketing lists created above with the new ad group.

            ArrayOfAdGroupCriterion adGroupRemarketingListAssociations = new ArrayOfAdGroupCriterion();
            ArrayList<AudienceType> audienceTypes = new ArrayList<AudienceType>();
            audienceTypes.add(AudienceType.REMARKETING_LIST);
            
            for (java.lang.Long audienceId : audienceIds.getLongs())
            {
                if (audienceId != null)
                {
                    BiddableAdGroupCriterion biddableAdGroupCriterion = new BiddableAdGroupCriterion();
                    biddableAdGroupCriterion.setAdGroupId(adGroupIds.getLongs().get(0));
                    AudienceCriterion audienceCriterion = new AudienceCriterion();
                    audienceCriterion.setAudienceId(audienceId);
                    audienceCriterion.setAudienceType(audienceTypes);
                    biddableAdGroupCriterion.setCriterion(audienceCriterion);
                    BidMultiplier bidMultiplier = new BidMultiplier();
                    bidMultiplier.setMultiplier(20D);
                    biddableAdGroupCriterion.setCriterionBid(bidMultiplier);
                    biddableAdGroupCriterion.setStatus(AdGroupCriterionStatus.ACTIVE);                                        
                    adGroupRemarketingListAssociations.getAdGroupCriterions().add(biddableAdGroupCriterion);
                }
            }
            
            ArrayList<AdGroupCriterionType> criterionType = new ArrayList<AdGroupCriterionType>();
            criterionType.add(AdGroupCriterionType.AUDIENCE);
            
            ArrayList<AdGroupCriterionType> getCriterionType = new ArrayList<AdGroupCriterionType>();
            getCriterionType.add(AdGroupCriterionType.REMARKETING_LIST);

            outputStatusMessage("-----\nAddAdGroupCriterions:");
            AddAdGroupCriterionsResponse addAdGroupCriterionsResponse = CampaignManagementExampleHelper.addAdGroupCriterions(
                    adGroupRemarketingListAssociations,
                    criterionType);
            outputStatusMessage("AdGroupCriterionIds:");
            CampaignManagementExampleHelper.outputArrayOfNullableOflong(addAdGroupCriterionsResponse.getAdGroupCriterionIds());
            ArrayOfBatchErrorCollection adGroupCriterionErrors = addAdGroupCriterionsResponse.getNestedPartialErrors();
            outputStatusMessage("NestedPartialErrors:");
            CampaignManagementExampleHelper.outputArrayOfBatchErrorCollection(adGroupCriterionErrors);

            // Delete the campaign and everything it contains e.g., ad groups and ads.

            outputStatusMessage("-----\nDeleteCampaigns:");
            ArrayOflong deleteCampaignIds = new ArrayOflong();
            deleteCampaignIds.getLongs().add(campaignIds.getLongs().get(0));
            CampaignManagementExampleHelper.deleteCampaigns(
                    authorizationData.getAccountId(), 
                    deleteCampaignIds);
            outputStatusMessage(String.format("Deleted CampaignId %s", deleteCampaignIds.getLongs().get(0))); 

            // Delete the remarketing lists.

            outputStatusMessage("-----\nDeleteAudiences:");
            ArrayOflong deleteAudienceIds = new ArrayOflong();
            deleteAudienceIds.getLongs().add(audienceIds.getLongs().get(0));
            CampaignManagementExampleHelper.deleteAudiences(
                deleteAudienceIds);
            outputStatusMessage(String.format("Deleted Audience Id %s", deleteAudienceIds.getLongs().get(0)));
        } 
        catch (Exception ex) {
            String faultXml = ExampleExceptionHelper.getBingAdsExceptionFaultXml(ex, System.out);
            outputStatusMessage(faultXml);
            String message = ExampleExceptionHelper.handleBingAdsSDKException(ex, System.out);
            outputStatusMessage(message);
        }
    }
 }
<?php

namespace Microsoft\MsAds\Rest\Test\Services;

use Exception;
use Microsoft\MsAds\Rest\Model\CampaignManagementService\AddAudiencesRequest;
use Microsoft\MsAds\Rest\Model\CampaignManagementService\AddAdGroupCriterionsRequest;
use Microsoft\MsAds\Rest\Model\CampaignManagementService\AddUetTagsRequest;
use Microsoft\MsAds\Rest\Model\CampaignManagementService\AdGroup;
use Microsoft\MsAds\Rest\Model\CampaignManagementService\AdGroupCriterionStatus;
use Microsoft\MsAds\Rest\Model\CampaignManagementService\AdGroupCriterionType;
use Microsoft\MsAds\Rest\Model\CampaignManagementService\AudienceCriterion;
use Microsoft\MsAds\Rest\Model\CampaignManagementService\AudienceType;
use Microsoft\MsAds\Rest\Model\CampaignManagementService\Bid;
use Microsoft\MsAds\Rest\Model\CampaignManagementService\BiddableAdGroupCriterion;
use Microsoft\MsAds\Rest\Model\CampaignManagementService\BidMultiplier;
use Microsoft\MsAds\Rest\Model\CampaignManagementService\BudgetLimitType;
use Microsoft\MsAds\Rest\Model\CampaignManagementService\Campaign;
use Microsoft\MsAds\Rest\Model\CampaignManagementService\CriterionTypeGroup;
use Microsoft\MsAds\Rest\Model\CampaignManagementService\CustomEventsRule;
use Microsoft\MsAds\Rest\Model\CampaignManagementService\Date;
use Microsoft\MsAds\Rest\Model\CampaignManagementService\EntityScope;
use Microsoft\MsAds\Rest\Model\CampaignManagementService\GetUetTagsByIdsRequest;
use Microsoft\MsAds\Rest\Model\CampaignManagementService\PageVisitorsRule;
use Microsoft\MsAds\Rest\Model\CampaignManagementService\PageVisitorsWhoDidNotVisitAnotherPageRule;
use Microsoft\MsAds\Rest\Model\CampaignManagementService\PageVisitorsWhoVisitedAnotherPageRule;
use Microsoft\MsAds\Rest\Model\CampaignManagementService\RemarketingList;
use Microsoft\MsAds\Rest\Model\CampaignManagementService\RuleItemGroup;
use Microsoft\MsAds\Rest\Model\CampaignManagementService\StringOperator;
use Microsoft\MsAds\Rest\Model\CampaignManagementService\StringRuleItem;
use Microsoft\MsAds\Rest\Model\CampaignManagementService\TargetSetting;
use Microsoft\MsAds\Rest\Model\CampaignManagementService\TargetSettingDetail;
use Microsoft\MsAds\Rest\Model\CampaignManagementService\UetTag;
use Microsoft\MsAds\Rest\Test\RestApiTestBase;

class RemarketingListsTest extends RestApiTestBase
{

    /**
     * @throws Exception
     */
    public function testAddUetTags()
    {
        // Before you can track conversions or target audiences using a remarketing list
        // you need to create a UET tag, and then add the UET tag tracking code to every page of your website.
        // For more information, please see Universal Event Tracking at https://go.microsoft.com/fwlink/?linkid=829965.

        // First you should call the GetUetTagsByIds operation to check whether a tag has already been created.
        // You can leave the TagIds element null or empty to request all UET tags available for the customer.
        print("-----\r\nGetUetTagsByIds:\r\n");
        $request = new GetUetTagsByIdsRequest([
            'TagIds' => null
        ]);
        $response = self::$campaignManagementServiceApi->getUetTagsByIds($request);
        $uetTags = $response->getUetTags() ?? [];
        print("UetTags:\r\n");
        print_r($uetTags);
        print("PartialErrors:\r\n");
        print_r($response->getPartialErrors());
        self::assertEmpty($response->getPartialErrors());

        // If you do not already have a UET tag that can be used, or if you need another UET tag,
        // call the AddUetTags service operation to create a new UET tag. If the call is successful,
        // the tracking script that you should add to your website is included in a corresponding
        // UetTag within the response message.

        if (count($uetTags) == 0) {
            print("-----\r\nAdding UET Tags:\r\n");

            $uetTag = new UetTag();
            $uetTag->setName("New UET Tag".self::generateRandomAlphaNumeric());
            $uetTag->setDescription("My First UET Tag".self::generateRandomAlphaNumeric());

            $request = new AddUetTagsRequest([
                'UetTags' => [$uetTag]
            ]);

            $response = self::$campaignManagementServiceApi->addUetTags($request);
            $uetTags = $response->getUetTags() ?? [];
            print("UetTags:\r\n");
            print_r($uetTags);
            print("PartialErrors:\r\n");
            print_r($response->getPartialErrors());
            self::assertEmpty($response->getPartialErrors());
        } else {
            print("-----\r\nUET Tag already exists\r\n");
        }
        self::assertNotEmpty($uetTags);

        return $uetTags[0]->getId();
    }

    /**
     * @depends testAddUetTags
     * @throws Exception
     */
    public function testAddRemarketingLists($tagId)
    {
        // Add remarketing lists that depend on the UET Tag Id retrieved above.
        print("-----\r\nAdding Remarketing Lists:\r\n");
        $audiences = [];

        // Custom Events Rule
        $customEventsList = (new RemarketingList())
            ->setDescription("New list with CustomEventsRule")
            ->setMembershipDuration(30)
            ->setName("Remarketing List with CustomEventsRule ".self::generateRandomAlphaNumeric())
            ->setParentId(self::CUSTOMER_ACCOUNT_ID)
            ->setScope(EntityScope::ACCOUNT)
            ->setTagId($tagId);

        // The rule definition is translated to the following logical expression:
        // (Category Equals video) and (Action Equals play) and (Label Equals trailer)
        // and (Value Equals 5)
        $customEventsRule = (new CustomEventsRule())
            ->setAction("play")
            ->setActionOperator(StringOperator::EQUALS)
            ->setCategory("video")
            ->setCategoryOperator(StringOperator::EQUALS)
            ->setLabel("trailer")
            ->setLabelOperator(StringOperator::EQUALS)
            ->setValue(5.00)
            ->setValueOperator(StringOperator::EQUALS);

        $customEventsList->setRule($customEventsRule);
        $audiences[] = $customEventsList;

        // Page Visitors Rule
        $pageVisitorsList = (new RemarketingList())
            ->setDescription("New list with PageVisitorsRule")
            ->setMembershipDuration(30)
            ->setName("Remarketing List with PageVisitorsRule ".self::generateRandomAlphaNumeric())
            ->setParentId(self::CUSTOMER_ACCOUNT_ID)
            ->setScope(EntityScope::ACCOUNT)
            ->setTagId($tagId);

        $pageVisitorsRule = (new PageVisitorsRule())
            ->setRuleItemGroups([
                (new RuleItemGroup())->setItems([
                    (new StringRuleItem())
                        ->setOperand("Url")
                        ->setOperator(StringOperator::CONTAINS)
                        ->setValue("X"),
                    (new StringRuleItem())
                        ->setOperand("ReferrerUrl")
                        ->setOperator(StringOperator::DOES_NOT_CONTAIN)
                        ->setValue("Z")
                ]),
                (new RuleItemGroup())->setItems([
                    (new StringRuleItem())
                        ->setOperand("Url")
                        ->setOperator(StringOperator::DOES_NOT_BEGIN_WITH)
                        ->setValue("Y")
                ]),
                (new RuleItemGroup())->setItems([
                    (new StringRuleItem())
                        ->setOperand("ReferrerUrl")
                        ->setOperator(StringOperator::EQUALS)
                        ->setValue("Z")
                ])
            ]);

        $pageVisitorsList->setRule($pageVisitorsRule);
        $audiences[] = $pageVisitorsList;

        // Page Visitors Who Did Not Visit Another Page Rule
        $pageVisitorsWhoDidNotVisitAnotherPageList = (new RemarketingList())
            ->setDescription("New list with PageVisitorsWhoDidNotVisitAnotherPageRule")
            ->setMembershipDuration(30)
            ->setName("Remarketing List with PageVisitorsWhoDidNotVisitAnotherPageRule ".self::generateRandomAlphaNumeric())
            ->setParentId(self::CUSTOMER_ACCOUNT_ID)
            ->setScope(EntityScope::ACCOUNT)
            ->setTagId($tagId);

        $pageVisitorsWhoDidNotVisitAnotherPageRule = (new PageVisitorsWhoDidNotVisitAnotherPageRule())
            ->setIncludeRuleItemGroups([
                (new RuleItemGroup())->setItems([
                    (new StringRuleItem())
                        ->setOperand("Url")
                        ->setOperator(StringOperator::CONTAINS)
                        ->setValue("X"),
                    (new StringRuleItem())
                        ->setOperand("ReferrerUrl")
                        ->setOperator(StringOperator::DOES_NOT_CONTAIN)
                        ->setValue("Z")
                ]),
                (new RuleItemGroup())->setItems([
                    (new StringRuleItem())
                        ->setOperand("ReferrerUrl")
                        ->setOperator(StringOperator::EQUALS)
                        ->setValue("Z")
                ]),
            ])
            ->setExcludeRuleItemGroups([
                (new RuleItemGroup())->setItems([
                    (new StringRuleItem())
                        ->setOperand("Url")
                        ->setOperator(StringOperator::BEGINS_WITH)
                        ->setValue("A"),
                    (new StringRuleItem())
                        ->setOperand("ReferrerUrl")
                        ->setOperator(StringOperator::BEGINS_WITH)
                        ->setValue("B")
                ]),
                (new RuleItemGroup())->setItems([
                    (new StringRuleItem())
                        ->setOperand("Url")
                        ->setOperator(StringOperator::CONTAINS)
                        ->setValue("C")
                ]),
            ]);

        $pageVisitorsWhoDidNotVisitAnotherPageList->setRule($pageVisitorsWhoDidNotVisitAnotherPageRule);
        $audiences[] = $pageVisitorsWhoDidNotVisitAnotherPageList;

        // Page Visitors Who Visited Another Page Rule
        $pageVisitorsWhoVisitedAnotherPageList = (new RemarketingList())
            ->setDescription("New list with PageVisitorsWhoVisitedAnotherPageRule")
            ->setMembershipDuration(30)
            ->setName("Remarketing List with PageVisitorsWhoVisitedAnotherPageRule ".self::generateRandomAlphaNumeric())
            ->setParentId(self::CUSTOMER_ACCOUNT_ID)
            ->setScope(EntityScope::ACCOUNT)
            ->setTagId($tagId);

        $pageVisitorsWhoVisitedAnotherPageRule = (new PageVisitorsWhoVisitedAnotherPageRule())
            ->setRuleItemGroups([
                (new RuleItemGroup())->setItems([
                    (new StringRuleItem())
                        ->setOperand("Url")
                        ->setOperator(StringOperator::CONTAINS)
                        ->setValue("X"),
                    (new StringRuleItem())
                        ->setOperand("ReferrerUrl")
                        ->setOperator(StringOperator::DOES_NOT_CONTAIN)
                        ->setValue("Z")
                ]),
                (new RuleItemGroup())->setItems([
                    (new StringRuleItem())
                        ->setOperand("ReferrerUrl")
                        ->setOperator(StringOperator::EQUALS)
                        ->setValue("Z"),
                    (new StringRuleItem())
                        ->setOperand("Url")
                        ->setOperator(StringOperator::DOES_NOT_BEGIN_WITH)
                        ->setValue("Y")
                ]),
            ])
            ->setAnotherRuleItemGroups([
                (new RuleItemGroup())->setItems([
                    (new StringRuleItem())
                        ->setOperand("Url")
                        ->setOperator(StringOperator::BEGINS_WITH)
                        ->setValue("A"),
                    (new StringRuleItem())
                        ->setOperand("ReferrerUrl")
                        ->setOperator(StringOperator::BEGINS_WITH)
                        ->setValue("B")
                ]),
                (new RuleItemGroup())->setItems([
                    (new StringRuleItem())
                        ->setOperand("Url")
                        ->setOperator(StringOperator::CONTAINS)
                        ->setValue("C")
                ])
            ]);

        $pageVisitorsWhoVisitedAnotherPageList->setRule($pageVisitorsWhoVisitedAnotherPageRule);
        $audiences[] = $pageVisitorsWhoVisitedAnotherPageList;

        $request = (new AddAudiencesRequest())->setAudiences($audiences);
        $response = self::$campaignManagementServiceApi->addAudiences($request);
        print("AudienceIds:\r\n");
        print_r($response->getAudienceIds());
        print("PartialErrors:\r\n");
        print_r($response->getPartialErrors());
        self::assertEmpty($response->getPartialErrors());
        self::assertNotEmpty($response->getAudienceIds());

        return $response->getAudienceIds();
    }

    /**
     * @depends testAddRemarketingLists
     * @throws Exception
     */
    public function testAddCampaign()
    {
        $campaign = (new Campaign())
            ->setName("Remarketing Campaign ".self::generateRandomAlphaNumeric())
            ->setBudgetType(BudgetLimitType::DAILY_BUDGET_STANDARD)
            ->setDailyBudget(50.00)
            ->setLanguages(["All"])
            ->setTimeZone("PacificTimeUSCanadaTijuana");
        return self::addCampaignsRequest([$campaign]);
    }

    /**
     * @depends testAddCampaign
     * @throws Exception
     */
    public function testAddAdGroup(array $campaignIds)
    {
        $adGroup = (new AdGroup())
            ->setName("Remarketing Ad Group".self::generateRandomAlphaNumeric())
            ->setCpcBid((new Bid())->setAmount(0.09))
            ->setStartDate(null)
            ->setEndDate((new Date())->setMonth(12)->setDay(31)->setYear(date("Y")))
            ->setSettings([
                (new TargetSetting())
                    ->setDetails([
                        (new TargetSettingDetail())
                            ->setCriterionTypeGroup(CriterionTypeGroup::AUDIENCE)
                            ->setTargetAndBid(true)
                    ])
            ]);
        return self::addAdGroupsRequest($campaignIds[0], [$adGroup]);
    }

    /**
     * @depends testAddRemarketingLists
     * @depends testAddAdGroup
     * @throws Exception
     */
    public function testAddAdGroupCriterions(array $audienceIds, $adGroupIds)
    {
        // Associate all of the remarketing lists created above with the new ad group.
        print("-----\r\nAdding Ad Group Criterions:\r\n");

        $adGroupCriterions = array();

        foreach ($audienceIds as $audienceId) {
            $adGroupCriterions[] = (new BiddableAdGroupCriterion())
                ->setCriterion(
                    (new AudienceCriterion())
                        ->setAudienceId($audienceId)
                        ->setAudienceType(AudienceType::REMARKETING_LIST)
                )
                ->setCriterionBid((new BidMultiplier())->setMultiplier(20.00))
                ->setAdGroupId($adGroupIds[0])
                ->setStatus(AdGroupCriterionStatus::ACTIVE);
        }
        $request = new AddAdGroupCriterionsRequest([
            'AdGroupCriterions' => $adGroupCriterions,
            'CriterionType' => AdGroupCriterionType::AUDIENCE,
        ]);
        $response = self::$campaignManagementServiceApi->addAdGroupCriterions($request);
        print("AdGroupCriterions:\r\n");
        print_r($response->getAdGroupCriterionIds());
        print("NestedPartialErrors:\r\n");
        print_r($response->getNestedPartialErrors());
        self::assertEmpty($response->getNestedPartialErrors());
        self::assertNotEmpty($response->getAdGroupCriterionIds());
    }

    /**
     * @depends testAddCampaign
     * @throws Exception
     */
    public function testDeleteCampaign(array $campaignIds)
    {
        self::deleteCampaignsRequest($campaignIds);
    }
}
import uuid
from auth_helper import *
from openapi_client.models.campaign import *

def main(authorization_data):
    try:
        # Check if UET tags already exist
        print("Checking for existing UET tags...")
        
        get_uet_tags_request = GetUetTagsByIdsRequest(
            tag_ids=None  # Get all UET tags
        )
        
        get_uet_tags_response = campaign_service.get_uet_tags_by_ids(
            get_uet_tags_by_ids_request=get_uet_tags_request
        )
        
        uet_tags = get_uet_tags_response.UetTags if get_uet_tags_response.UetTags else []
        
        print(f"Found {len(uet_tags)} existing UET tags")
        
        if get_uet_tags_response.PartialErrors:
            print(f"Partial Errors: {get_uet_tags_response.PartialErrors}")
        
        # Create a new UET tag if none exist
        if len(uet_tags) == 0:
            print("\nCreating new UET tag...")
            print("Before you can track conversions or target audiences using a remarketing list,")
            print("you need to create a UET tag, and then add the UET tag tracking code to every page of your website.")
            
            uet_tag = UetTag(
                name="New UET Tag" + str(uuid.uuid4())[:8],
                description="My First UET Tag" + str(uuid.uuid4())[:8]
            )
            
            add_uet_tags_request = AddUetTagsRequest(
                uet_tags=[uet_tag]
            )
            
            add_uet_tags_response = campaign_service.add_uet_tags(
                add_uet_tags_request=add_uet_tags_request
            )
            
            uet_tags = add_uet_tags_response.UetTags
            print(f"Created UET Tag ID: {uet_tags[0].Id}")
            
            if add_uet_tags_response.PartialErrors:
                print(f"Partial Errors: {add_uet_tags_response.PartialErrors}")
        else:
            print("Using existing UET tag")
        
        tag_id = uet_tags[0].Id
        print(f"\nUsing UET Tag ID: {tag_id}")
        
        # Create remarketing lists with different rule types
        print("\nCreating remarketing lists...")
        
        audiences = []
        
        # 1. Custom Events Rule
        custom_events_rule = CustomEventsRule(
            action="play",
            action_operator=StringOperator.EQUALS,
            category="video",
            category_operator=StringOperator.EQUALS,
            label="trailer",
            label_operator=StringOperator.EQUALS,
            value=5.0,
            value_operator=StringOperator.EQUALS
        )
        
        custom_events_list = RemarketingList(
            description="New list with CustomEventsRule",
            membership_duration=30,
            name="Remarketing List with CustomEventsRule " + str(uuid.uuid4())[:8],
            parent_id=authorization_data.account_id,
            scope=EntityScope.ACCOUNT,
            tag_id=tag_id,
            rule=custom_events_rule
        )
        audiences.append(custom_events_list)
        
        # 2. Page Visitors Rule
        page_visitors_rule = PageVisitorsRule(
            rule_item_groups=[
                RuleItemGroup(
                    items=[
                        StringRuleItem(
                            operand="Url",
                            operator=StringOperator.CONTAINS,
                            value="X"
                        ),
                        StringRuleItem(
                            operand="ReferrerUrl",
                            operator=StringOperator.DOESNOTCONTAIN,
                            value="Z"
                        )
                    ]
                ),
                RuleItemGroup(
                    items=[
                        StringRuleItem(
                            operand="Url",
                            operator=StringOperator.DOESNOTBEGINWITH,
                            value="Y"
                        )
                    ]
                ),
                RuleItemGroup(
                    items=[
                        StringRuleItem(
                            operand="ReferrerUrl",
                            operator=StringOperator.EQUALS,
                            value="Z"
                        )
                    ]
                )
            ]
        )
        
        page_visitors_list = RemarketingList(
            description="New list with PageVisitorsRule",
            membership_duration=30,
            name="Remarketing List with PageVisitorsRule " + str(uuid.uuid4())[:8],
            parent_id=authorization_data.account_id,
            scope=EntityScope.ACCOUNT,
            tag_id=tag_id,
            rule=page_visitors_rule
        )
        audiences.append(page_visitors_list)
        
        # 3. Page Visitors Who Did Not Visit Another Page Rule
        page_visitors_who_did_not_visit_rule = PageVisitorsWhoDidNotVisitAnotherPageRule(
            include_rule_item_groups=[
                RuleItemGroup(
                    items=[
                        StringRuleItem(
                            operand="Url",
                            operator=StringOperator.CONTAINS,
                            value="X"
                        ),
                        StringRuleItem(
                            operand="ReferrerUrl",
                            operator=StringOperator.DOESNOTCONTAIN,
                            value="Z"
                        )
                    ]
                ),
                RuleItemGroup(
                    items=[
                        StringRuleItem(
                            operand="ReferrerUrl",
                            operator=StringOperator.EQUALS,
                            value="Z"
                        )
                    ]
                )
            ],
            exclude_rule_item_groups=[
                RuleItemGroup(
                    items=[
                        StringRuleItem(
                            operand="Url",
                            operator=StringOperator.BEGINSWITH,
                            value="A"
                        ),
                        StringRuleItem(
                            operand="ReferrerUrl",
                            operator=StringOperator.BEGINSWITH,
                            value="B"
                        )
                    ]
                ),
                RuleItemGroup(
                    items=[
                        StringRuleItem(
                            operand="Url",
                            operator=StringOperator.CONTAINS,
                            value="C"
                        )
                    ]
                )
            ]
        )
        
        page_visitors_who_did_not_visit_list = RemarketingList(
            description="New list with PageVisitorsWhoDidNotVisitAnotherPageRule",
            membership_duration=30,
            name="Remarketing List with PageVisitorsWhoDidNotVisitAnotherPageRule " + str(uuid.uuid4())[:8],
            parent_id=authorization_data.account_id,
            scope=EntityScope.ACCOUNT,
            tag_id=tag_id,
            rule=page_visitors_who_did_not_visit_rule
        )
        audiences.append(page_visitors_who_did_not_visit_list)
        
        # 4. Page Visitors Who Visited Another Page Rule
        page_visitors_who_visited_rule = PageVisitorsWhoVisitedAnotherPageRule(
            rule_item_groups=[
                RuleItemGroup(
                    items=[
                        StringRuleItem(
                            operand="Url",
                            operator=StringOperator.CONTAINS,
                            value="X"
                        ),
                        StringRuleItem(
                            operand="ReferrerUrl",
                            operator=StringOperator.DOESNOTCONTAIN,
                            value="Z"
                        )
                    ]
                ),
                RuleItemGroup(
                    items=[
                        StringRuleItem(
                            operand="ReferrerUrl",
                            operator=StringOperator.EQUALS,
                            value="Z"
                        ),
                        StringRuleItem(
                            operand="Url",
                            operator=StringOperator.DOESNOTBEGINWITH,
                            value="Y"
                        )
                    ]
                )
            ],
            another_rule_item_groups=[
                RuleItemGroup(
                    items=[
                        StringRuleItem(
                            operand="Url",
                            operator=StringOperator.BEGINSWITH,
                            value="A"
                        ),
                        StringRuleItem(
                            operand="ReferrerUrl",
                            operator=StringOperator.BEGINSWITH,
                            value="B"
                        )
                    ]
                ),
                RuleItemGroup(
                    items=[
                        StringRuleItem(
                            operand="Url",
                            operator=StringOperator.CONTAINS,
                            value="C"
                        )
                    ]
                )
            ]
        )
        
        page_visitors_who_visited_list = RemarketingList(
            description="New list with PageVisitorsWhoVisitedAnotherPageRule",
            membership_duration=30,
            name="Remarketing List with PageVisitorsWhoVisitedAnotherPageRule " + str(uuid.uuid4())[:8],
            parent_id=authorization_data.account_id,
            scope=EntityScope.ACCOUNT,
            tag_id=tag_id,
            rule=page_visitors_who_visited_rule
        )
        audiences.append(page_visitors_who_visited_list)
        
        # Add all remarketing lists
        add_audiences_request = AddAudiencesRequest(
            audiences=audiences
        )
        
        add_audiences_response = campaign_service.add_audiences(
            add_audiences_request=add_audiences_request
        )
        
        audience_ids = add_audiences_response.AudienceIds
        print(f"Created Audience IDs: {audience_ids}")
        
        if add_audiences_response.PartialErrors:
            print(f"Partial Errors: {add_audiences_response.PartialErrors}")
        else:
            print(f"Successfully created {len(audience_ids)} remarketing lists")
        
        # Create a campaign for remarketing
        print("\nCreating remarketing campaign...")
        
        campaign = Campaign(
            name="Remarketing Campaign " + str(uuid.uuid4())[:8],
            budget_type=BudgetLimitType.DAILYBUDGETSTANDARD,
            daily_budget=50.00,
            languages=['All'],
            time_zone='PacificTimeUSCanadaTijuana'
        )
        
        add_campaigns_request = AddCampaignsRequest(
            account_id=authorization_data.account_id,
            campaigns=[campaign]
        )
        
        add_campaigns_response = campaign_service.add_campaigns(
            add_campaigns_request=add_campaigns_request
        )
        
        campaign_ids = add_campaigns_response.CampaignIds
        print(f"Created Campaign ID: {campaign_ids[0]}")
        
        # Create an ad group with audience targeting
        print("\nCreating ad group with audience targeting...")
        
        current_year = datetime.now().year
        
        target_setting = TargetSetting(
            details=[
                TargetSettingDetail(
                    criterion_type_group=CriterionTypeGroup.AUDIENCE,
                    target_and_bid=True
                )
            ]
        )
        
        ad_group = AdGroup(
            name="Remarketing Ad Group" + str(uuid.uuid4())[:8],
            cpc_bid=Bid(amount=0.09),
            start_date=None,
            end_date=Date(day=31, month=12, year=current_year),
            settings=[target_setting]
        )
        
        add_ad_groups_request = AddAdGroupsRequest(
            campaign_id=campaign_ids[0],
            ad_groups=[ad_group]
        )
        
        add_ad_groups_response = campaign_service.add_ad_groups(
            add_ad_groups_request=add_ad_groups_request
        )
        
        ad_group_ids = add_ad_groups_response.AdGroupIds
        print(f"Created Ad Group ID: {ad_group_ids[0]}")
        
        # Associate remarketing lists with ad group
        print("\nAssociating remarketing lists with ad group...")
        
        ad_group_criterions = []
        
        for audience_id in audience_ids:
            criterion = AudienceCriterion(
                audience_id=audience_id,
                audience_type=AudienceType.REMARKETINGLIST
            )
            
            ad_group_criterion = BiddableAdGroupCriterion(
                ad_group_id=ad_group_ids[0],
                criterion=criterion,
                criterion_bid=BidMultiplier(multiplier=20.0),
                status=AdGroupCriterionStatus.ACTIVE
            )
            
            ad_group_criterions.append(ad_group_criterion)
        
        add_ad_group_criterions_request = AddAdGroupCriterionsRequest(
            ad_group_criterions=ad_group_criterions,
            criterion_type=AdGroupCriterionType.AUDIENCE
        )
        
        add_ad_group_criterions_response = campaign_service.add_ad_group_criterions(
            add_ad_group_criterions_request=add_ad_group_criterions_request
        )
        
        criterion_ids = add_ad_group_criterions_response.AdGroupCriterionIds
        print(f"Created Ad Group Criterion IDs: {criterion_ids}")
        
        if add_ad_group_criterions_response.NestedPartialErrors:
            print(f"Nested Partial Errors: {add_ad_group_criterions_response.NestedPartialErrors}")
        else:
            print("Successfully associated remarketing lists with ad group")
        
        # Delete campaign
        print("\nDeleting campaign...")
        
        delete_campaigns_request = DeleteCampaignsRequest(
            account_id=authorization_data.account_id,
            campaign_ids=campaign_ids
        )
        
        campaign_service.delete_campaigns(
            delete_campaigns_request=delete_campaigns_request
        )
        
        print(f"Deleted Campaign ID {campaign_ids[0]}")
        
        print("\n" + "="*80)
        print("Test completed successfully!")
        print(f"Note: The remarketing lists and UET tag remain in your account and can be reused.")
        print("="*80)
        
    except Exception as ex:
        print(f"Error occurred: {str(ex)}")
        import traceback
        traceback.print_exc()

if __name__ == '__main__':
    print("Loading the web service client...")
    
    authorization_data = AuthorizationData(
        account_id=None,
        customer_id=None,
        developer_token=DEVELOPER_TOKEN,
        authentication=None,
    )
    
    authenticate(authorization_data)
    
    campaign_service = ServiceClient(
        service='CampaignManagementService',
        version=13,
        authorization_data=authorization_data,
        environment=ENVIRONMENT,
    )
    
    main(authorization_data)

Siehe auch

Erste Schritte mit der Bing Ads-API