@highfivve/ad-tag 5.5.4

package/lib/ads/modules/yield-optimization/yieldOptimizationService.js

@@ -0,0 +1,169 @@
+import { resolveAdUnitPath } from 'ad-tag/ads/adUnitPath';
+import { isYieldConfigDynamic } from 'ad-tag/ads/modules/yield-optimization/isYieldOptimizationConfigDynamic';
+import { calculateDynamicPriceRule } from 'ad-tag/ads/modules/yield-optimization/dynamicFloorPrice';
+export const createYieldOptimizationService = (yieldConfig) => {
+    const emptyAdUnitPriceRulesResponse = {
+        rules: {},
+        browser: 'None'
+    };
+    let adUnitPricingRuleResponse = Promise.resolve(emptyAdUnitPriceRulesResponse);
+    let isEnabled = false;
+    let device = 'mobile';
+    let adUnitPathVariables = {};
+    const init = (deviceLabel, adUnitPathVars, adUnitPaths, fetch, logger) => {
+        device = deviceLabel;
+        adUnitPathVariables = adUnitPathVars;
+        switch (yieldConfig.provider) {
+            case 'none':
+                logger.warn('YieldOptimizationService', 'Yield optimization is disabled!');
+                isEnabled = false;
+                adUnitPricingRuleResponse = Promise.resolve(emptyAdUnitPriceRulesResponse);
+                break;
+            case 'static':
+                logger.warn('YieldOptimizationService', 'Yield optimization is static!');
+                isEnabled = true;
+                adUnitPricingRuleResponse = Promise.resolve({
+                    rules: yieldConfig.config
+                        .rules,
+                    browser: 'None'
+                });
+                break;
+            case 'dynamic':
+                isEnabled = true;
+                const excludedAdUnitPaths = yieldConfig.excludedAdUnitPaths;
+                const filteredAdUnitPaths = adUnitPaths.filter(adUnitPath => excludedAdUnitPaths.indexOf(adUnitPath) < 0);
+                const resolvedAdUnits = filteredAdUnitPaths.map(adUnitPath => resolveAdUnitPath(adUnitPath, adUnitPathVariables));
+                adUnitPricingRuleResponse = loadConfigWithRetry(yieldConfig.configEndpoint, 3, resolvedAdUnits, fetch)
+                    .then(config => {
+                    logger.info('YieldOptimizationService', `loaded pricing rules for device ${device}`, config);
+                    return config;
+                })
+                    .catch(error => {
+                    logger.error('YieldOptimizationService', 'failed to initialize service', error);
+                    return emptyAdUnitPriceRulesResponse;
+                });
+                break;
+            default:
+                isEnabled = false;
+                adUnitPricingRuleResponse = Promise.reject('Unknown config provider');
+        }
+        return Promise.resolve();
+    };
+    const getPriceRule = (adUnitPath) => {
+        return adUnitPricingRuleResponse.then(response => response.rules[resolveAdUnitPath(adUnitPath, adUnitPathVariables)]);
+    };
+    const getBrowser = () => {
+        return adUnitPricingRuleResponse.then(response => response.browser || 'None');
+    };
+    const setTargeting = (adSlot, adServer, logger, yieldOptimizationConfig, auctionContext) => {
+        const adUnitPath = resolveAdUnitPath(adSlot.getAdUnitPath(), adUnitPathVariables);
+        return adUnitPricingRuleResponse.then(config => {
+            const rule = config.rules[adUnitPath];
+            if (adServer === 'gam') {
+                if (rule) {
+                    adSlot.setTargeting('upr_model', rule.model || 'static');
+                    if (rule.main) {
+                        adSlot.setTargeting('upr_main', 'true');
+                        const lastBidCpmsOnPosition = auctionContext?.getLastBidCpmsOfAdUnit(adSlot.getSlotElementId());
+                        if (lastBidCpmsOnPosition &&
+                            lastBidCpmsOnPosition?.length > 0 &&
+                            isYieldConfigDynamic(yieldOptimizationConfig) &&
+                            yieldOptimizationConfig.dynamicFloorPrices) {
+                            const { strategy, roundingStepsInCents, maxPriceRuleInCents, minPriceRuleInCents } = yieldOptimizationConfig.dynamicFloorPrices;
+                            const newRule = calculateDynamicPriceRule({
+                                strategy,
+                                previousCpms: lastBidCpmsOnPosition,
+                                standardRule: rule,
+                                roundingStepsInCents,
+                                maxPriceRuleInCents,
+                                minPriceRuleInCents
+                            });
+                            logger.debug('YieldOptimizationService', `set dynamic price rule id ${newRule.priceRuleId} for ${adUnitPath} based on previous bid cpms on same position. Stategy is '${strategy}'. Main traffic share ${rule.main}. Cpm is ${newRule.floorprice}.`);
+                            adSlot.setTargeting('upr_id', newRule.priceRuleId.toFixed(0));
+                            return newRule;
+                        }
+                        else {
+                            adSlot.setTargeting('upr_id', rule.priceRuleId.toFixed(0));
+                        }
+                    }
+                    else {
+                        logger.debug('YieldOptimizationService', `set price rule id ${rule.priceRuleId} for ${adUnitPath}. Main traffic share ${rule.main}. cpm is ${rule.floorprice}`);
+                        adSlot.setTargeting('upr_id', rule.priceRuleId.toFixed(0));
+                    }
+                }
+                else if (isEnabled) {
+                    logger.warn('YieldOptimizationService', `No price rule found for ${adUnitPath}`);
+                }
+            }
+            return rule;
+        });
+    };
+    const loadConfigWithRetry = (configEndpoint, retriesLeft, adUnitPaths, fetch, lastError = null) => {
+        if (retriesLeft <= 0) {
+            return Promise.reject(lastError);
+        }
+        return fetch(configEndpoint, {
+            method: 'POST',
+            mode: 'cors',
+            headers: {
+                'Content-Type': 'application/json',
+                Accept: 'application/json'
+            },
+            body: JSON.stringify({
+                device: device,
+                key: 'adUnitPath',
+                adUnitPaths: adUnitPaths
+            })
+        })
+            .then(response => {
+            return response.ok
+                ? response.json()
+                : response
+                    .text()
+                    .then(errorMessage => Promise.reject(`${response.statusText}: ${errorMessage}`));
+        })
+            .then((response) => {
+            if (typeof response !== 'object' || response === null) {
+                return Promise.reject('Invalid response');
+            }
+            if (!isAdunitPricesRulesResponse(response)) {
+                return Promise.reject('response is missing rules property');
+            }
+            if (validateRules(response.rules)) {
+                return response;
+            }
+            else {
+                return Promise.reject('At least one rule object was not valid');
+            }
+        })
+            .catch(error => {
+            const exponentialBackoff = new Promise(resolve => setTimeout(resolve, 100 / retriesLeft));
+            return exponentialBackoff.then(() => loadConfigWithRetry(configEndpoint, retriesLeft - 1, adUnitPaths, fetch, error));
+        });
+    };
+    const isAdunitPricesRulesResponse = (obj) => {
+        return obj.hasOwnProperty('rules');
+    };
+    const isPriceRules = (obj) => {
+        return typeof obj === 'object' && obj !== null;
+    };
+    const validateRules = (rules) => {
+        if (!isPriceRules(rules)) {
+            return false;
+        }
+        return Object.keys(rules).every(adUnit => {
+            const rule = rules[adUnit];
+            return (typeof rule === 'object' &&
+                rule !== null &&
+                typeof rule.main === 'boolean' &&
+                typeof rule.floorprice === 'number' &&
+                typeof rule.priceRuleId === 'number');
+        });
+    };
+    return {
+        init,
+        getPriceRule,
+        getBrowser,
+        setTargeting
+    };
+};

package/lib/ads/modules/zeotap/index.js

@@ -0,0 +1,111 @@
+import { mkConfigureStepOncePerRequestAdsCycle, mkInitStep } from 'ad-tag/ads/adPipeline';
+import { AssetLoadMethod } from 'ad-tag/util/assetLoaderService';
+import { tcfapi } from 'ad-tag/types/tcfapi';
+export class Zeotap {
+    constructor() {
+        this.name = 'zeotap';
+        this.description = 'Provides Zeotap functionality (data collection and identity plus) to Moli.';
+        this.moduleType = 'identity';
+        this.gvlid = 301;
+        this.loadScriptCount = 0;
+        this.zeotapConfig = null;
+        this.hasConsent = (tcData) => {
+            if (tcData.gdprApplies) {
+                return (tcData.vendor.consents[this.gvlid] &&
+                    tcData.purpose.consents[tcfapi.responses.TCPurpose.STORE_INFORMATION_ON_DEVICE] &&
+                    tcData.purpose.consents[tcfapi.responses.TCPurpose.CREATE_PERSONALISED_ADS_PROFILE] &&
+                    tcData.purpose.consents[tcfapi.responses.TCPurpose.SELECT_PERSONALISED_ADS] &&
+                    tcData.purpose.consents[tcfapi.responses.TCPurpose.CREATE_PERSONALISED_CONTENT_PROFILE] &&
+                    tcData.purpose.consents[tcfapi.responses.TCPurpose.SELECT_PERSONALISED_CONTENT] &&
+                    tcData.purpose.consents[tcfapi.responses.TCPurpose.MEASURE_AD_PERFORMANCE] &&
+                    tcData.purpose.consents[tcfapi.responses.TCPurpose.APPLY_MARKET_RESEARCH] &&
+                    tcData.purpose.consents[tcfapi.responses.TCPurpose.DEVELOP_IMPROVE_PRODUCTS]);
+            }
+            return true;
+        };
+        this.loadScript = (config, assetLoaderService, moduleConfig) => {
+            const { mode, dataKeyValues, exclusionKeyValues, assetUrl, hashedEmailAddress, countryCode } = moduleConfig;
+            if (!assetLoaderService) {
+                return Promise.reject('Zeotap module :: no asset loader found, module not initialized yet?');
+            }
+            if (mode === 'default' && this.loadScriptCount > 0) {
+                return Promise.reject("Zeotap module :: can't reload script in default mode.");
+            }
+            const keyValuesMap = this.makeKeyValuesMap(config.targeting?.keyValues);
+            if (exclusionKeyValues.some(kv => this.isExclusionKeyValueSet(kv, keyValuesMap))) {
+                return Promise.reject('Zeotap module :: targeting exclusions prevented loading the script.');
+            }
+            const customData = dataKeyValues
+                .map(kv => this.parameterFromKeyValue(kv, keyValuesMap))
+                .join('&');
+            const loadIdPlus = !!moduleConfig.hashedEmailAddress && this.loadScriptCount === 0;
+            const url = assetUrl +
+                `&idp=${loadIdPlus ? 1 : 0}` +
+                (customData.length > 0 ? `&${customData}` : '') +
+                (countryCode ? `&ctry=${countryCode}` : '') +
+                (hashedEmailAddress ? `&z_e_sha2_l=${hashedEmailAddress}` : '');
+            this.loadScriptCount++;
+            return assetLoaderService.loadScript({
+                name: this.name,
+                loadMethod: AssetLoadMethod.TAG,
+                assetUrl: url
+            });
+        };
+        this.parameterFromKeyValue = (kv, keyValuesMap) => {
+            const value = keyValuesMap.get(kv.keyValueKey);
+            if (Array.isArray(value)) {
+                return `${kv.parameterKey}=${encodeURIComponent(value.join(','))}`;
+            }
+            return `${kv.parameterKey}=${encodeURIComponent(value || '')}`;
+        };
+        this.isExclusionKeyValueSet = (kv, keyValuesMap) => {
+            const value = keyValuesMap.get(kv.keyValueKey);
+            if (Array.isArray(value)) {
+                return value.indexOf(kv.disableOnValue) > -1;
+            }
+            return value === kv.disableOnValue;
+        };
+        this.makeKeyValuesMap = (keyValues) => {
+            return keyValues
+                ? new Map(Object.keys(keyValues)
+                    .map(key => [key, keyValues[key]])
+                    .filter(([, value]) => !!value))
+                : new Map();
+        };
+    }
+    config__() {
+        return this.zeotapConfig;
+    }
+    configure__(moduleConfig) {
+        if (moduleConfig?.zeotap && moduleConfig.zeotap.enabled) {
+            this.zeotapConfig = moduleConfig.zeotap;
+        }
+    }
+    initSteps__() {
+        const config = this.zeotapConfig;
+        return config && config.mode === 'default'
+            ? [
+                mkInitStep(this.name, context => {
+                    if (this.hasConsent(context.tcData__)) {
+                        this.loadScript(context.config__, context.assetLoaderService__, config).catch(error => context.logger__.error(this.name, error));
+                    }
+                    return Promise.resolve();
+                })
+            ]
+            : [];
+    }
+    configureSteps__() {
+        const config = this.zeotapConfig;
+        return config && config.mode === 'spa'
+            ? [
+                mkConfigureStepOncePerRequestAdsCycle(this.name, context => {
+                    this.loadScript(context.config__, context.assetLoaderService__, config).catch(error => context.logger__.error(this.name, error));
+                    return Promise.resolve();
+                })
+            ]
+            : [];
+    }
+    prepareRequestAdsSteps__() {
+        return [];
+    }
+}