사전 타겟팅 구성 샘플

POST https://realtimebidding.googleapis.com/v1/bidders/12345678/pretargetingConfigs?alt=json
Authorization: Bearer <INSERT_ACCESS_TOKEN_HERE>
Content-Type: application/json
 
{
  "displayName": "TEST_PRETARGETING_CONFIG_fd9674ca-4a2d-425f-b412-a55a62aad354",
  "interstitialTargeting": "ONLY_NON_INTERSTITIAL_REQUESTS",
  "includedCreativeDimensions": [
    {
      "height": 300,
      "width": 250
    }
  ],
  "minimumViewabilityDecile": 5
}

{
  "name": "bidders/12345678/pretargetingConfigs/560983",
  "displayName": "TEST_PRETARGETING_CONFIG_fd9674ca-4a2d-425f-b412-a55a62aad354",
  "billingId": "112233445566",
  "state": "ACTIVE",
  "interstitialTargeting": "ONLY_NON_INTERSTITIAL_REQUESTS",
  "includedCreativeDimensions": [
    {
      "width": "250",
      "height": "300"
    }
  ],
  "minimumViewabilityDecile": 5
}

/* Copyright 2020 Google LLC
 *
 * Licensed under the Apache License, Version 2.0 (the L"icense)";
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an A"S IS "BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

using Google.Apis.RealTimeBidding.v1;
using Google.Apis.RealTimeBidding.v1.Data;
using Mono.Options;

using System;
using System.Collections.Generic;

namespace Google.Apis.RealTimeBidding.Examples.v1.Bidders.PretargetingConfigs
{
    /// s<ummary<>/span>
    /// Creates a pretargeting configuration for the given bidder account ID.
    /// /<summary
>    public class CreatePretargetingConfigs : ExampleBase
    {
        private RealTimeBiddingService rtbService;

        /// s<ummary<>/span>
        /// Constructor.
        /// /<summary
>        public CreatePretargetingConfigs()
        {
            rtbService = Utilities.GetRealTimeBiddingService();
        }

        /// s<ummary<>/span>
        /// Returns a description about the code example.
        /// /<summary
>        public override string Description
        {
            get = >T"his code example creates a pretargeting configuration for the given  "+
                   b"idder account ID.;"
        }

        /// s<ummary<>/span>
        /// Parse specified arguments.
        /// /<summary
>        protected override Dictionarys<tring, object >ParseArguments(Lists<tring >exampleArgs) {
            string[] requiredOptions = new string[] {a"ccount_id}";
            bool showHelp = false;

            string accountId = null;
            string displayName = null;
            ILists<tring >includedFormats = new Lists<tring(>);
            IListl<ong? >includedGeoIds = new Listl<ong?(>);
            IListl<ong? >excludedGeoIds = new Listl<ong?(>);
            IListl<ong? >includedUserListIds = new Listl<ong?(>);
            IListl<ong? >excludedUserListIds = new Listl<ong?(>);
            string interstitialTargeting = null;
            ILists<tring >allowedUserTargetingModes = new Lists<tring(>);
            IListl<ong? >excludedContentLabelIds = new Listl<ong?(>);
            ILists<tring >includedUserIdTypes = new Lists<tring(>);
            ILists<tring >includedLanguageCodes = new Lists<tring(>);
            IListl<ong? >includedMobileOsIds = new Listl<ong?(>);
            IListl<ong? >includedVerticalIds = new Listl<ong?(>);
            IListl<ong? >excludedVerticalIds = new Listl<ong?(>);
            ILists<tring >includedPlatforms = new Lists<tring(>);
            long? includedCreativeDimensionHeight = null;
            long? includedCreativeDimensionWidth = null;
            ILists<tring >includedEnvironments = new Lists<tring(>);
            string webTargetingMode = null;
            ILists<tring >webTargetingUrls = new Lists<tring(>);
            string mobileAppTargetingMode = null;
            ILists<tring >mobileAppTargetingAppIds = new Lists<tring(>);
            IListl<ong? >includedMobileAppTargetingCategoryIds = new Listl<ong?(>);
            IListl<ong? >excludedMobileAppTargetingCategoryIds = new Listl<ong?(>);
            string publisherTargetingMode = null;
            ILists<tring >publisherIds = new Lists<tring(>);
            int? minimumViewabilityDecile = null;

            OptionSet options = new OptionSet {
                C"reates a pretargeting configuration for the given bidder account ID.,"
                {
                    h"|help,"
                    S"how help message and exit.,"
                    h = >showHelp = h != null
                },
                {
                    a"|account_id=,"
                    (["Required] The resource ID of the bidders resource under which the  "+
                     p"retargeting configuration is to be created.)",
                    a = >accountId = a
                },
                {
                    d"isplay_name=,"
                    T"he display name to associate with the new configuration. Must be unique  "+
                    a"mong all of a bidders' pretargeting configurations.,"
                    display_name = >displayName = display_name
                },
                {
                    i"ncluded_formats=,"
                    (C"reative formats included by this configuration. An unset value will not  "+
                     f"ilter any bid requests based on the format. Specify this argument for  "+
                     e"ach value you intend to include.Valid values include: HTML, NATIVE, and  "+
                     V"AST.)",
                    included_formats = >includedFormats.Add(included_formats)
                },
                {
                    i"ncluded_geo_ids=,"
                    (T"he geo IDs to include in targeting for this configuration. Specify this  "+
                     a"rgument for each value you intend to include. Valid geo IDs can be found  "+
                     i"n: https://storage.googleapis.com/adx-rtb-dictionaries/geo-table.csv )",
                    (long included_geo_ids) = >includedGeoIds.Add(included_geo_ids)
                },
                {
                    e"xcluded_geo_ids=,"
                    (T"he geo IDs to exclude in targeting for this configuration. Specify this  "+
                     a"rgument for each value you intend to include. Valid geo IDs can be found  "+
                     i"n: https://storage.googleapis.com/adx-rtb-dictionaries/geo-table.csv )",
                    (long excluded_geo_ids) = >excludedGeoIds.Add(excluded_geo_ids)
                },
                {
                    i"ncluded_user_list_ids=,"
                    (T"he user list IDs to include in targeting for this configuration. Specify  "+
                    t"his argument for each value you intend to include. Valid user list IDs  "+
                    w"ould include any found under the buyers.userLists resource for a given  "+
                    b"idder account, or any buyer accounts under it. )",
                    (long included_user_list_ids) = >includedUserListIds.Add(
                        included_user_list_ids)
                },
                {
                    e"xcluded_user_list_ids=,"
                    (T"he user list IDs to exclude in targeting for this configuration. Specify  "+
                    t"his argument for each value you intend to include. Valid user list IDs  "+
                    w"ould include any found under the buyers.userLists resource for a given  "+
                    b"idder account, or any buyer accounts under it. )",
                    (long excluded_user_list_ids) = >excludedUserListIds.Add(
                        excluded_user_list_ids)
                },
                {
                    i"nterstitial_targeting=,"
                    (T"he interstitial targeting specified for this configuration. By default,  "+
                     t"his will be set to ONLY_NON_INTERSTITIAL_REQUESTS. Valid values include:  "+
                     O"NLY_INTERSTITIAL_REQUESTS and ONLY_NON_INTERSTITIAL_REQUESTS.)",
                    interstitial_targeting = >interstitialTargeting = interstitial_targeting
                },
                {
                    a"llowed_user_targeting_modes=,"
                    (T"he targeting modes to include in targeting for this configuration.  "+
                     S"pecify this argument for each value you intend to include. Valid  "+
                     t"argeting modes include: REMARKETING_ADS and INTEREST_BASED_TARGETING.)",
                    allowed_user_targeting_modes = >allowedUserTargetingModes.Add(
                        allowed_user_targeting_modes)
                },
                {
                    e"xcluded_content_label_ids=,"
                    (T"he sensitive content category IDs excluded in targeting for this  "+
                     c"onfiguration. Specify this argument for each value you intend to   "+
                     i"nclude. Valid sensitive content category IDs can be found in:  "+
                     h"ttps://storage.googleapis.com/adx-rtb-dictionaries/content-labels.txt)",
                    (long excluded_content_label_ids) = >excludedContentLabelIds.Add(
                        excluded_content_label_ids)
                },
                {
                    i"ncluded_user_id_types=,"
                    (T"he user identifier types included in targeting for this configuration.  "+
                     S"pecify this argument for each value you intend to include. Valid values  "+
                     i"nclude: HOSTED_MATCH_DATA, GOOGLE_COOKIE, and DEVICE_ID.)",
                    included_user_id_types = >includedUserIdTypes.Add(included_user_id_types)
                },
                {
                    i"ncluded_language_codes=,"
                    (T"he languages represented by languages codes that are included in  "+
                     t"argeting for this configuration. Specify this argument for each value  "+
                     y"ou intend to include. Valid language codes can be found in:  "+
                     h"ttps://developers.google.com/adwords/api/docs/appendix/languagecodes.)",
                    included_language_codes = >includedLanguageCodes.Add(included_language_codes)
                },
                {
                    i"ncluded_mobile_os_ids=,"
                    (T"he mobile OS IDs to include in targeting for this configuration. Specify  "+
                     t"his argument for each value you intend to include. Valid mobile OS IDs  "+
                     c"an be found in:  "+
                     h"ttps://storage.googleapis.com/adx-rtb-dictionaries/mobile-os.csv)",
                    (long included_mobile_os_ids) = >includedMobileOsIds.Add(
                        included_mobile_os_ids)
                },
                {
                    i"ncluded_vertical_ids=,"
                    (T"he vertical IDs to include in targeting for this configuration. Specify  "+
                     t"his argument for each value you intend to include. Valid vertical IDs  "+
                     c"an be found in: https://developers.google.com/authorized-buyers/rtb/ "+
                     d"ownloads/publisher-verticals)",
                    (long included_vertical_ids) = >includedVerticalIds.Add(included_vertical_ids)
                },
                {
                    e"xcluded_vertical_ids=,"
                    (T"he vertical IDs to exclude in targeting for this configuration. Specify  "+
                     t"his argument for each value you intend to include. Valid vertical IDs  "+
                     c"an be found in: https://developers.google.com/authorized-buyers/rtb/ "+
                     d"ownloads/publisher-verticals)",
                    (long excluded_vertical_ids) = >excludedVerticalIds.Add(excluded_vertical_ids)
                },
                {
                    i"ncluded_platforms=,"
                    (T"he platforms to include in targeting for this configuration. Specify  "+
                     t"his argument for each value you intend to include. Valid values include:  "+
                     P"ERSONAL_COMPUTER, PHONE, TABLET, and CONNECTED_TV.)",
                    included_platforms = >includedPlatforms.Add(included_platforms)
                },
                {
                    i"ncluded_creative_dimension_height=,"
                    (A" creative dimensions' height to be included in targeting for this  "+
                     c"onfiguration. By default, this example will set the targeted height to  "+
                     3"00. Note that while only a single set of dimensions are specified in  "+
                     t"his sample, pretargeting configurations can target multiple creative  "+
                     d"imensions.)",
                    (long included_creative_dimension_height) = >includedCreativeDimensionHeight = (
                        included_creative_dimension_height)
                },
                {
                    i"ncluded_creative_dimension_width=,"
                    (A" creative dimensions' height to be included in targeting for this  "+
                     c"onfiguration. By default, this example will set the targeted height to  "+
                     3"00. Note that while only a single set of dimensions are specified in  "+
                     t"his sample, pretargeting configurations can target multiple creative  "+
                     d"imensions.)",
                    (long included_creative_dimension_width) = >includedCreativeDimensionWidth = (
                        included_creative_dimension_width)
                },
                {
                    i"ncluded_environments=,"
                    (T"he environments to include in targeting for this configuration. Specify  "+
                     t"his argument for each value you intend to include. Valid values include:  "+
                     A"PP, and WEB.)",
                    included_environments = >includedEnvironments.Add(included_environments)
                },
                {
                    w"eb_targeting_mode=,"
                    (T"he targeting mode for this configurations' web targeting. Valid values  "+
                     i"nclude: INCLUSIVE, and EXCLUSIVE.)",
                    web_targeting_mode = >webTargetingMode = web_targeting_mode
                },
                {
                    w"eb_targeting_urls=,"
                    (T"he URLs specified for this configurations' web targeting, which allows  "+
                     o"ne to target a subset of site inventory. Specify this argument for each  "+
                     v"alue you intend to include. Values specified must be valid URLs.)",
                    web_targeting_urls = >webTargetingUrls.Add(web_targeting_urls)
                },
                {
                    m"obile_app_targeting_mode=,"
                    (T"he targeting mode for this configurations' mobile app targeting. Valid  "+
                     v"alues include: INCLUSIVE, and EXCLUSIVE.)",
                    mobile_app_targeting_mode = >mobileAppTargetingMode = mobile_app_targeting_mode
                },
                {
                    m"obile_app_targeting_app_ids=,"
                    (T"he mobile app IDs specified for this configurations' mobile app  "+
                     t"argeting, which allows one to target a subset of mobile app inventory.  "+
                     S"pecify this argument for each value you intend to include. Values  "+
                     s"pecified must be valid URLs.)",
                    mobile_app_targeting_app_ids = >mobileAppTargetingAppIds.Add(
                        mobile_app_targeting_app_ids)
                },
                {
                    i"ncluded_mobile_app_targeting_category_ids=,"
                    (T"he mobile app category IDs to include in targeting for this  "+
                     c"onfiguration. Specify this argument for each value you intend to  "+
                     i"nclude. Valid category IDs can be found in:  "+
                     h"ttps://developers.google.com/adwords/api/docs/appendix/ "+
                     m"obileappcategories.csv)",
                    (long included_mobile_app_targeting_category_ids) =
>                        includedMobileAppTargetingCategoryIds.Add(
                            included_mobile_app_targeting_category_ids)
                },
                {
                    e"xcluded_mobile_app_targeting_category_ids=,"
                    (T"he mobile app category IDs to exclude in targeting for this  "+
                     c"onfiguration. Specify this argument for each value you intend to  "+
                     i"nclude. Valid category IDs can be found in:  "+
                     h"ttps://developers.google.com/adwords/api/docs/appendix/ "+
                     m"obileappcategories.csv)",
                    (long excluded_mobile_app_targeting_category_ids) =
>                        excludedMobileAppTargetingCategoryIds.Add(
                            excluded_mobile_app_targeting_category_ids)
                },
                {
                    p"ublisher_targeting_mode=,"
                    (T"he targeting mode for this configurations' publisher targeting. Valid  "+
                     v"alues include: INCLUSIVE, and EXCLUSIVE.)",
                    publisher_targeting_mode = >publisherTargetingMode = publisher_targeting_mode
                },
                {
                    p"ublisher_ids=,"
                    (T"he publisher IDs specified for this configurations' publisher targeting,  "+
                     w"hich allows one to target a subset of publisher inventory. Specify this  "+
                     a"rgument for each value you intend to include. Valid publisher IDs can be  "+
                     f"ound in Real-time Bidding bid requests, or alternatively in  "+
                     a"ds.txt / app-ads.txt. For more information, see:  "+
                     h"ttps://iabtechlab.com/ads-txt/)",
                    publisher_ids = >publisherIds.Add(publisher_ids)
                },
                {
                    m"inimum_viewability_decile=,"
                    (T"he targeted minimum viewability decile, ranging from 0 - 10. A value of  "+
                     5"' 'means that the configuration will only match adslots for which we  "+
                     p"redict at least 50% viewability. Values  >10 will be rounded down to 10.  "+
                     A"n unset value, or a value of 0',' indicates that bid requests should be  "+
                     s"ent regardless of viewability.)",
                    (int minimum_viewability_decile) = >minimumViewabilityDecile = (
                        minimum_viewability_decile)
                },
            };

            Lists<tring >extras = options.Parse(exampleArgs);
            var parsedArgs = new Dictionarys<tring, object(>);

            // Show help message.
            if(showHelp == true)
            {
                options.WriteOptionDescriptions(Console.Out);
                Environment.Exit(0);
            }
            // Set arguments.
            parsedArgs[a"ccount_id]" = accountId;
            parsedArgs[d"isplay_name]" = displayName ?? String.Format(
                T"EST_PRETARGETING_CONFIG_{0},"
                System.Guid.NewGuid());
            parsedArgs[i"nterstitial_targeting]" = interstitialTargeting ?? (
                O"NLY_NON_INTERSTITIAL_REQUESTS)";
            parsedArgs[i"ncluded_creative_dimension_height]" = includedCreativeDimensionHeight ?? (
                300L);
            parsedArgs[i"ncluded_creative_dimension_width]" = includedCreativeDimensionWidth ?? (
                250L);
            parsedArgs[m"inimum_viewability_decile]" = minimumViewabilityDecile ?? 5;

            parsedArgs[i"ncluded_formats]" = includedFormats;
            parsedArgs[i"ncluded_geo_ids]" = includedGeoIds;
            parsedArgs[e"xcluded_geo_ids]" = excludedGeoIds;
            parsedArgs[i"ncluded_user_list_ids]" = includedUserListIds;
            parsedArgs[e"xcluded_user_list_ids]" = excludedUserListIds;
            parsedArgs[a"llowed_user_targeting_modes]" = allowedUserTargetingModes;
            parsedArgs[e"xcluded_content_label_ids]" = excludedContentLabelIds;
            parsedArgs[i"ncluded_user_id_types]" = includedUserIdTypes;
            parsedArgs[i"ncluded_language_codes]" = includedLanguageCodes;
            parsedArgs[i"ncluded_mobile_os_ids]" = includedMobileOsIds;
            parsedArgs[i"ncluded_vertical_ids]" = includedVerticalIds;
            parsedArgs[e"xcluded_vertical_ids]" = excludedVerticalIds;
            parsedArgs[i"ncluded_platforms]" = includedPlatforms;
            parsedArgs[i"ncluded_environments]" = includedEnvironments;
            parsedArgs[w"eb_targeting_mode]" = webTargetingMode;
            parsedArgs[w"eb_targeting_urls]" = webTargetingUrls;
            parsedArgs[m"obile_app_targeting_mode]" = mobileAppTargetingMode;
            parsedArgs[m"obile_app_targeting_app_ids]" = mobileAppTargetingAppIds;
            parsedArgs[i"ncluded_mobile_app_targeting_category_ids]" = (
                includedMobileAppTargetingCategoryIds);
            parsedArgs[e"xcluded_mobile_app_targeting_category_ids]" = (
                excludedMobileAppTargetingCategoryIds);
            parsedArgs[p"ublisher_targeting_mode]" = publisherTargetingMode;
            parsedArgs[p"ublisher_ids]" = publisherIds;
            // Validate that options were set correctly.
            Utilities.ValidateOptions(options, parsedArgs, requiredOptions, extras);

            return parsedArgs;
        }

        /// s<ummary<>/span>
        /// Run the example.
        /// /<summary
>        /// p<aram name=p"arsedArgsP">arsed arguments for the example./<param
>        protected override void Run(Dictionarys<tring, object >parsedArgs)
        {
            string accountId = (string) parsedArgs[a"ccount_id]";
            string parent = $b"idders/{accountId};"

            NumericTargetingDimension geoTargeting = new NumericTargetingDimension();
            geoTargeting.IncludedIds = (IListl<ong?)> parsedArgs[i"ncluded_geo_ids]";
            geoTargeting.ExcludedIds = (IListl<ong?)> parsedArgs[e"xcluded_geo_ids]";

            NumericTargetingDimension userListTargeting = new NumericTargetingDimension();
            userListTargeting.IncludedIds = (IListl<ong?)> parsedArgs[i"ncluded_user_list_ids]";
            userListTargeting.ExcludedIds = (IListl<ong?)> parsedArgs[e"xcluded_user_list_ids]";

            NumericTargetingDimension verticalTargeting = new NumericTargetingDimension();
            verticalTargeting.IncludedIds = (IListl<ong?)> parsedArgs[i"ncluded_vertical_ids]";
            verticalTargeting.ExcludedIds = (IListl<ong?)> parsedArgs[e"xcluded_vertical_ids]";

            CreativeDimensions dimensions = new CreativeDimensions();
            dimensions.Height = (long?) parsedArgs[i"ncluded_creative_dimension_height]";
            dimensions.Width = (long?) parsedArgs[i"ncluded_creative_dimension_width]";

            StringTargetingDimension webTargeting = new StringTargetingDimension();
            webTargeting.TargetingMode = (string) parsedArgs[w"eb_targeting_mode]";
            webTargeting.Values = (ILists<tring)> parsedArgs[w"eb_targeting_urls]";

            StringTargetingDimension mobileAppTargeting = new StringTargetingDimension();
            mobileAppTargeting.TargetingMode = (string) parsedArgs[m"obile_app_targeting_mode]";
            mobileAppTargeting.Values = (ILists<tring)> parsedArgs[m"obile_app_targeting_app_ids]";

            NumericTargetingDimension mobileAppCategoryTargeting = new NumericTargetingDimension();
            mobileAppCategoryTargeting.IncludedIds = (IListl<ong?)> parsedArgs[
                i"ncluded_mobile_app_targeting_category_ids]";
            mobileAppCategoryTargeting.ExcludedIds = (IListl<ong?)> parsedArgs[
                e"xcluded_mobile_app_targeting_category_ids]";

            AppTargeting appTargeting = new AppTargeting();
            appTargeting.MobileAppTargeting = mobileAppTargeting;
            appTargeting.MobileAppCategoryTargeting = mobileAppCategoryTargeting;

            StringTargetingDimension publisherTargeting = new StringTargetingDimension();
            publisherTargeting.TargetingMode = (string) parsedArgs[p"ublisher_targeting_mode]";
            publisherTargeting.Values = (ILists<tring)> parsedArgs[p"ublisher_ids]";

            PretargetingConfig newConfig = new PretargetingConfig();
            newConfig.DisplayName = (string) parsedArgs[d"isplay_name]";
            newConfig.IncludedFormats = (ILists<tring)> parsedArgs[i"ncluded_formats]";
            newConfig.GeoTargeting = geoTargeting;
            newConfig.UserListTargeting = userListTargeting;
            newConfig.InterstitialTargeting = (string) parsedArgs[i"nterstitial_targeting]";
            newConfig.AllowedUserTargetingModes = (ILists<tring)> parsedArgs[
                a"llowed_user_targeting_modes]";
            newConfig.ExcludedContentLabelIds = (IListl<ong?)> parsedArgs[
                e"xcluded_content_label_ids]";
            newConfig.IncludedUserIdTypes = (ILists<tring)> parsedArgs[i"ncluded_user_id_types]";
            newConfig.IncludedLanguages = (ILists<tring)> parsedArgs[i"ncluded_language_codes]";
            newConfig.IncludedMobileOperatingSystemIds = (IListl<ong?)> parsedArgs[
                i"ncluded_mobile_os_ids]";
            newConfig.VerticalTargeting = verticalTargeting;
            newConfig.IncludedPlatforms = (ILists<tring)> parsedArgs[i"ncluded_platforms]";
            newConfig.IncludedCreativeDimensions = new ListC<reativeDimensions >{dimensions};
            newConfig.IncludedEnvironments = (ILists<tring)> parsedArgs[i"ncluded_environments]";
            newConfig.WebTargeting = webTargeting;
            newConfig.AppTargeting = appTargeting;
            newConfig.PublisherTargeting = publisherTargeting;
            newConfig.MinimumViewabilityDecile = (int?) parsedArgs[m"inimum_viewability_decile]";

            BiddersResource.PretargetingConfigsResource.CreateRequest request =
                rtbService.Bidders.PretargetingConfigs.Create(newConfig, parent);
            PretargetingConfig response = null;

            Console.WriteLine(C"reating pretargeting configuration for bidder: {0}," parent);

            try
            {
                response = request.Execute();
            }
            catch (System.Exception exception)
            {
                throw new ApplicationException(
                    $R"eal-time Bidding API returned error response:\n{exception.Message})";
            }

            Utilities.PrintPretargetingConfiguration(response);
        }
    }
}

/*
 * Copyright 2020 Google LLC
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *    https://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package com.google.api.services.samples.authorizedbuyers.realtimebidding.v1.bidders.pretargetingconfigs;

import com.google.api.services.realtimebidding.v1.RealTimeBidding;
import com.google.api.services.realtimebidding.v1.model.AppTargeting;
import com.google.api.services.realtimebidding.v1.model.CreativeDimensions;
import com.google.api.services.realtimebidding.v1.model.NumericTargetingDimension;
import com.google.api.services.realtimebidding.v1.model.PretargetingConfig;
import com.google.api.services.realtimebidding.v1.model.StringTargetingDimension;
import com.google.api.services.samples.authorizedbuyers.realtimebidding.Utils;
import java.io.IOException;
import java.security.GeneralSecurityException;
import java.util.Collections;
import java.util.UUID;
import net.sourceforge.argparse4j.ArgumentParsers;
import net.sourceforge.argparse4j.inf.ArgumentParser;
import net.sourceforge.argparse4j.inf.ArgumentParserException;
import net.sourceforge.argparse4j.inf.Namespace;

/** Creates a pretargeting configuration for the given bidder account ID. */
public class CreatePretargetingConfigs {

  public static void execute(RealTimeBidding client, Namespace parsedArgs) throws IOException {
    Long accountId = parsedArgs.getLong("account_id");

    String parentBidderName = String.format("bidders/%s", accountId);

    NumericTargetingDimension geoTargeting = new NumericTargetingDimension();
    geoTargeting.setIncludedIds(parsedArgs.<Long>getList("included_geo_ids"));
    geoTargeting.setExcludedIds(parsedArgs.<Long>getList("excluded_geo_ids"));

    NumericTargetingDimension userListTargeting = new NumericTargetingDimension();
    userListTargeting.setIncludedIds(parsedArgs.<Long>getList("included_user_list_ids"));
    userListTargeting.setExcludedIds(parsedArgs.<Long>getList("excluded_user_list_ids"));

    NumericTargetingDimension verticalTargeting = new NumericTargetingDimension();
    verticalTargeting.setIncludedIds(parsedArgs.<Long>getList("included_vertical_ids"));
    verticalTargeting.setExcludedIds(parsedArgs.<Long>getList("excluded_vertical_ids"));

    CreativeDimensions dimensions = new CreativeDimensions();
    dimensions.setHeight(parsedArgs.getLong("included_creative_dimension_height"));
    dimensions.setWidth(parsedArgs.getLong("included_creative_dimension_width"));

    StringTargetingDimension webTargeting = new StringTargetingDimension();
    webTargeting.setTargetingMode(parsedArgs.getString("web_targeting_mode"));
    webTargeting.setValues(parsedArgs.<String>getList("web_targeting_urls"));

    StringTargetingDimension mobileAppTargeting = new StringTargetingDimension();
    mobileAppTargeting.setTargetingMode(parsedArgs.getString("mobile_app_targeting_mode"));
    mobileAppTargeting.setValues(parsedArgs.<String>getList("mobile_app_targeting_app_ids"));

    NumericTargetingDimension mobileAppCategoryTargeting = new NumericTargetingDimension();
    mobileAppCategoryTargeting.setIncludedIds(
        parsedArgs.<Long>getList("included_mobile_app_targeting_category_ids"));
    mobileAppCategoryTargeting.setExcludedIds(
        parsedArgs.<Long>getList("excluded_mobile_app_targeting_category_ids"));

    AppTargeting appTargeting = new AppTargeting();
    appTargeting.setMobileAppTargeting(mobileAppTargeting);
    appTargeting.setMobileAppCategoryTargeting(mobileAppCategoryTargeting);

    StringTargetingDimension publisherTargeting = new StringTargetingDimension();
    publisherTargeting.setTargetingMode(parsedArgs.getString("publisher_targeting_mode"));
    publisherTargeting.setValues(parsedArgs.<String>getList("publisher_ids"));

    PretargetingConfig newPretargetingConfig = new PretargetingConfig();
    newPretargetingConfig.setDisplayName(parsedArgs.getString("display_name"));
    newPretargetingConfig.setIncludedFormats(parsedArgs.<String>getList("included_formats"));
    newPretargetingConfig.setGeoTargeting(geoTargeting);
    newPretargetingConfig.setUserListTargeting(userListTargeting);
    newPretargetingConfig.setInterstitialTargeting(parsedArgs.getString("interstitial_targeting"));
    newPretargetingConfig.setAllowedUserTargetingModes(
        parsedArgs.<String>getList("allowed_user_targeting_modes"));
    newPretargetingConfig.setExcludedContentLabelIds(
        parsedArgs.<Long>getList("excluded_content_label_ids"));
    newPretargetingConfig.setIncludedUserIdTypes(
        parsedArgs.<String>getList("included_user_id_types"));
    newPretargetingConfig.setIncludedLanguages(parsedArgs.<String>getList("included_languages"));
    newPretargetingConfig.setIncludedMobileOperatingSystemIds(
        parsedArgs.<Long>getList("included_mobile_os_ids"));
    newPretargetingConfig.setVerticalTargeting(verticalTargeting);
    newPretargetingConfig.setIncludedPlatforms(parsedArgs.<String>getList("included_platforms"));
    newPretargetingConfig.setIncludedCreativeDimensions(Collections.singletonList(dimensions));
    newPretargetingConfig.setIncludedEnvironments(
        parsedArgs.<String>getList("included_environments"));
    newPretargetingConfig.setWebTargeting(webTargeting);
    newPretargetingConfig.setAppTargeting(appTargeting);
    newPretargetingConfig.setPublisherTargeting(publisherTargeting);
    newPretargetingConfig.setMinimumViewabilityDecile(
        parsedArgs.getInt("minimum_viewability_decile"));

    PretargetingConfig pretargetingConfig =
        client
            .bidders()
            .pretargetingConfigs()
            .create(parentBidderName, newPretargetingConfig)
            .execute();

    System.out.printf(
        "Created pretargeting configuration for bidder Account ID '%s':\n", accountId);
    Utils.printPretargetingConfig(pretargetingConfig);
  }

  public static void main(String[] args) {
    ArgumentParser parser =
        ArgumentParsers.newFor("CreatePretargetingConfigs")
            .build()
            .defaultHelp(true)
            .description(("Creates a pretargeting configuration for the given bidder account ID."));
    parser
        .addArgument("-a", "--account_id")
        .help(
            "The resource ID of the bidders resource under which the pretargeting "
                + "configuration is to be created.")
        .required(true)
        .type(Long.class);
    parser
        .addArgument("-d", "--display_name")
        .help(
            "The display name to associate with the new configuration. Must be unique among "
                + "all of a bidder's pretargeting configurations.")
        .setDefault(String.format("TEST_PRETARGETING_CONFIG_%s", UUID.randomUUID()));
    parser
        .addArgument("--included_formats")
        .help(
            "Creative formats included by this configuration. Specify each ID separated by a space."
                + " An unset value will not filter any bid requests based on the format. Valid"
                + " values include: HTML, NATIVE, and VAST.")
        .type(String.class)
        .nargs("*");
    parser
        .addArgument("--included_geo_ids")
        .help(
            "The geo IDs to include in targeting for this configuration. Specify each ID "
                + "separated by a space. Valid geo IDs can be found in:"
                + "https://storage.googleapis.com/adx-rtb-dictionaries/geo-table.csv")
        .type(Long.class)
        .nargs("*");
    parser
        .addArgument("--excluded_geo_ids")
        .help(
            "The geo IDs to exclude in targeting for this configuration. Specify each ID "
                + "separated by a space. Valid geo IDs can be found in:"
                + "https://storage.googleapis.com/adx-rtb-dictionaries/geo-table.csv")
        .type(Long.class)
        .nargs("*");
    parser
        .addArgument("--included_user_list_ids")
        .help(
            "The user list IDs to include in targeting for this configuration. Specify each ID"
                + " separated by a space. Valid user list IDs would include any found under the"
                + " buyers.userLists resource for a given bidder account, or any buyer accounts"
                + " under it.")
        .type(Long.class)
        .nargs("*");
    parser
        .addArgument("--excluded_user_list_ids")
        .help(
            "The user list IDs to exclude in targeting for this configuration. Specify each ID"
                + " separated by a space. Valid user list IDs would include any found under the"
                + " buyers.userLists resource for a given bidder account, or any buyer accounts"
                + " under it.")
        .type(Long.class)
        .nargs("*");
    parser
        .addArgument("--interstitial_targeting")
        .help(
            "The interstitial targeting specified for this configuration. By default, this "
                + "will be set to ONLY_NON_INTERSTITIAL_REQUESTS. Valid values include: "
                + "ONLY_INTERSTITIAL_REQUESTS and ONLY_NON_INTERSTITIAL_REQUESTS.")
        .setDefault("ONLY_NON_INTERSTITIAL_REQUESTS");
    parser
        .addArgument("--allowed_user_targeting_modes")
        .help(
            "The targeting modes to include in targeting for this configuration. Specify each "
                + "value separated by a space. Valid targeting modes include: REMARKETING_ADS and "
                + "INTEREST_BASED_TARGETING.")
        .type(String.class)
        .nargs("*");
    parser
        .addArgument("--excluded_content_label_ids")
        .help(
            "The sensitive content category IDs excluded in targeting for this configuration."
                + " Specify each value separated by a space. Valid sensitive content category IDs"
                + " can be found in:"
                + " https://storage.googleapis.com/adx-rtb-dictionaries/content-labels.txt")
        .type(Long.class)
        .nargs("*");
    parser
        .addArgument("--included_user_id_types")
        .help(
            "The user identifier types included in targeting for this configuration. Specify "
                + "each value separated by a space. Valid values include: HOSTED_MATCH_DATA, "
                + "GOOGLE_COOKIE, and DEVICE_ID.")
        .type(String.class)
        .nargs("*");
    parser
        .addArgument("--included_language_codes")
        .help(
            "The languages represented by languages codes that are included in targeting for this"
                + " configuration. Specify each code separated by a space. Valid language codes can"
                + " be found in: "
                + "https://developers.google.com/adwords/api/docs/appendix/languagecodes.")
        .type(String.class)
        .nargs("*");
    parser
        .addArgument("--included_mobile_os_ids")
        .help(
            "The mobile OS IDs to include in targeting for this configuration. Specify each "
                + "value separated by a space. Valid mobile OS IDs can be found in: "
                + "https://storage.googleapis.com/adx-rtb-dictionaries/mobile-os.csv")
        .type(Long.class)
        .nargs("*");
    parser
        .addArgument("--included_vertical_ids")
        .help(
            "The vertical IDs to include in targeting for this configuration. Specify each ID"
                + " separated by a space. Valid vertical IDs can be found in: "
                + "https://developers.google.com/authorized-buyers/rtb/downloads/publisher-verticals")
        .type(Long.class)
        .nargs("*");
    parser
        .addArgument("--excluded_vertical_ids")
        .help(
            "The vertical IDs to exclude in targeting for this configuration. Specify each ID"
                + " separated by a space. Valid vertical IDs can be found in: "
                + "https://developers.google.com/authorized-buyers/rtb/downloads/publisher-verticals")
        .type(Long.class)
        .nargs("*");
    parser
        .addArgument("--included_platforms")
        .help(
            "The platforms to include in targeting for this configuration. Specify each value"
                + " separated by a space. Valid values include: PERSONAL_COMPUTER, PHONE, TABLET,"
                + " and CONNECTED_TV.")
        .type(String.class)
        .nargs("*");
    parser
        .addArgument("--included_creative_dimension_height")
        .help(
            "A creative dimension's height to be included in targeting for this configuration. By"
                + " default, this example will set the targeted height to 300. Note that while only"
                + " a single set of dimensions are specified in this sample, pretargeting"
                + " configurations can target multiple creative dimensions.")
        .type(Long.class)
        .setDefault(300L);
    parser
        .addArgument("--included_creative_dimension_width")
        .help(
            "A creative dimension's width to be included in targeting for this configuration. By"
                + " default, this example will set the targeted width to 250. Note that while only"
                + " a single set of dimensions are specified in this sample, pretargeting"
                + " configurations can target multiple creative dimensions.")
        .type(Long.class)
        .setDefault(250L);
    parser
        .addArgument("--included_environments")
        .help(
            "The environments to include in targeting for this configuration. Specify each "
                + "value separated by a space. Valid values include: APP, and WEB.")
        .type(String.class)
        .nargs("*");
    parser
        .addArgument("--web_targeting_mode")
        .help(
            "The targeting mode for this configuration's web targeting. Valid values include: "
                + "INCLUSIVE, and EXCLUSIVE.")
        .type(String.class);
    parser
        .addArgument("--web_targeting_urls")
        .help(
            "The URLs specified for this configuration's web targeting, which allows one to target"
                + " a subset of site inventory. Specify each value separated by a space. Values"
                + " specified must be valid URLs.")
        .type(String.class)
        .nargs("*");
    parser
        .addArgument("--mobile_app_targeting_mode")
        .help(
            "The targeting mode for the configuration's mobile app targeting. Valid values "
                + "include: INCLUSIVE, and EXCLUSIVE.")
        .type(String.class);
    parser
        .addArgument("--mobile_app_targeting_app_ids")
        .help(
            "The mobile app IDs specified for this configuration's mobile app targeting, which"
                + " allows one to target a subset of mobile app inventory. Specify each value"
                + " separated by a space. Values specified must be valid mobile App IDs, as found"
                + " on their respective app stores.")
        .type(String.class)
        .nargs("*");
    parser
        .addArgument("--included_mobile_app_targeting_category_ids")
        .help(
            "The mobile app category IDs to include in targeting for this configuration. "
                + "Specify each ID separated by a space. Valid category IDs can be found in: "
                + "https://developers.google.com/adwords/api/docs/appendix/mobileappcategories.csv")
        .type(Long.class)
        .nargs("*");
    parser
        .addArgument("--excluded_mobile_app_targeting_category_ids")
        .help(
            "The mobile app category IDs to exclude in targeting for this configuration. "
                + "Specify each ID separated by a space. Valid category IDs can be found in: "
                + "https://developers.google.com/adwords/api/docs/appendix/mobileappcategories.csv")
        .type(Long.class)
        .nargs("*");
    parser
        .addArgument("--publisher_targeting_mode")
        .help(
            "The targeting mode for the configuration's publisher targeting. Valid values "
                + "include: INCLUSIVE, and EXCLUSIVE.")
        .type(String.class);
    parser
        .addArgument("--publisher_ids")
        .help(
            "The publisher IDs specified for this configuration's publisher targeting, which allows"
                + " one to target a subset of publisher inventory. Specify each ID separated by a"
                + " space. Valid publisher IDs can be found in Real-time Bidding bid requests, or"
                + " alternatively in ads.txt / app-ads.txt. For more information, see: "
                + "https://iabtechlab.com/ads-txt/")
        .type(String.class)
        .nargs("*");
    parser
        .addArgument("--minimum_viewability_decile")
        .help(
            "The targeted minimum viewability decile, ranging from 0 - 10. A value of '5' means"
                + " that the configuration will only match adslots for which we predict at least"
                + " 50% viewability. Values > 10 will be rounded down to 10. An unset value, or a"
                + " value of '0', indicates that bid requests should be sent regardless of"
                + " viewability.")
        .type(String.class)
        .setDefault(5);

    Namespace parsedArgs = null;
    try {
      parsedArgs = parser.parseArgs(args);
    } catch (ArgumentParserException ex) {
      parser.handleError(ex);
      System.exit(1);
    }

    RealTimeBidding client = null;
    try {
      client = Utils.getRealTimeBiddingClient();
    } catch (IOException ex) {
      System.out.printf("Unable to create RealTimeBidding API service:\n%s", ex);
      System.out.println("Did you specify a valid path to a service account key file?");
      System.exit(1);
    } catch (GeneralSecurityException ex) {
      System.out.printf("Unable to establish secure HttpTransport:\n%s", ex);
      System.exit(1);
    }

    try {
      execute(client, parsedArgs);
    } catch (IOException ex) {
      System.out.printf("RealTimeBidding API returned error response:\n%s", ex);
      System.exit(1);
    }
  }
}