/**
* @class
* @classdesc Hits builder.
* @name BuildManager
* @param parent {object} Instance of the Tag used
* @public
*/
var BuildManager = function (parent) {
'use strict';
var self = this;
var MAXSIZE = 1500;
var _secureProtocol = 'https:';
/**
* List of querystring parameters which can be truncated
* For others parameters (ati, atc, pdtl, etc.), see truncate option
* @type {String[]}
* @private
*/
var _multiHitable = ['stc', 'dz'];
/**
* Create an element of the "preQuery" object.
* @memberof BuildManager#
* @function
* @param param {string} name of a querystring parameter
* @param value {string} value of a querystring parameter
* @param truncate {boolean} true if the parameter can truncate
* @param multihit {boolean} true if the parameter must be added in all multi-hits
* @param separator {string} separator to consider for multi-hits
* @param encode {boolean} true if if the parameter value is encoded
* @returns {object}
* @private
*/
var _makeSubQuery = function (param, value, truncate, multihit, separator, encode) {
var p = '&' + param + '=';
return {
param: p,
paramSize: p.length,
str: value,
strSize: value.length,
truncate: !!truncate,
multihit: !!multihit,
separator: separator || '',
encode: !!encode
};
};
/**
* Create one hit with the first elements of the given dictionary and deletes them from it.
* @memberof BuildManager#
* @function
* @param subQueries {object} dictionary generated with the _preQuery method
* @param hitMaxSize {number}
* @returns {Array} :
* - index 0 : query string to put on a hit
* <br />- index 1 : dictionary remains unused, null if empty
* @private
*/
var _makeOneHit = function (subQueries, hitMaxSize) {
var hit = '';
var usedSpace = 0;
var hitDone = true;
for (var key in subQueries) {
if (subQueries.hasOwnProperty(key)) {
var subQuery = subQueries[key];
if (subQuery) {
hitDone = false;
var freeSpace = hitMaxSize - usedSpace;
if (subQuery.strSize + subQuery.paramSize < freeSpace) {
// le nouveau paramètre rentre dans le hit
hit += subQuery.param + subQuery.str;
usedSpace += subQuery.strSize + subQuery.paramSize;
if (!subQuery.multihit) {
subQueries[key] = undefined;
}
hitDone = true;
} else if (subQuery.truncate) {
// le nouveau paramètre ne rentre pas dans le hit mais il est tronquable
var index = freeSpace;
if (subQuery.separator) {
var query = subQuery.str.substr(0, freeSpace);
if (subQuery.encode) {
index = query.lastIndexOf(encodeURIComponent(subQuery.separator)) || index;
}
else {
index = query.lastIndexOf(subQuery.separator) || index;
}
}
hit += subQuery.param + subQuery.str.substr(0, index);
subQueries[key].str = subQuery.str.substr(index, subQuery.strSize - 1);
subQueries[key].strSize = subQueries[key].str.length;
break;
} else {
// le nouveau paramètre ne rentre pas dans le hit ET il n'est pas tronquable, on force son découpage et on log une erreur en debug mode
if (subQuery.strSize + subQuery.paramSize > hitMaxSize) {
parent.emit('Tracker:Hit:Build:Error', {
lvl: 'ERROR',
msg: 'Too long parameter "' + subQuery.param + '"',
details: {value: subQuery.str}
});
// make the key + value under the max length allowed
subQueries[key].str = subQueries[key].str.substr(0, hitMaxSize - subQuery.paramSize - 1);
subQueries[key].strSize = subQueries[key].str.length;
}
break;
}
}
else {
hitDone = true;
}
}
}
return [hit, hitDone ? null : subQueries];
};
/**
* First step in the formating of the querystring parameters: make a dictionary paramName => object (see _makeSubQuery).
* <br />The resulting dictionary contains all parameters in string format, in the right order, ready to be truncate if they can, etc.
* @memberof BuildManager#
* @function
* @param buffer {object} Buffer part to process
* @param maxsize {number} Hit max size
* @returns {Array} :
* - index 0 : preProcessed parameters
* <br />- index 1 : sum of the parameter size
* <br />- index 2 : true if a parameter was too long and can't be truncated
* <br />- index 3 : if sizeError name of the offending parameter
* @private
*/
var _preQuery = function (buffer, maxsize) {
var subQueries = {};
var totalSize = 0;
var sizeError = false;
var keySizeError = undefined;
var lastKey, lastSubQuery;
for (var key in buffer) {
if (buffer.hasOwnProperty(key)) {
var subQueryValue = buffer[key]['value'];
//si le paramètre est une fonction on l'exécute pour obtenir une valeur
// qui passera pas les traitements suivants (transformation en string, encodage, etc.)
if (typeof subQueryValue === 'function') {
subQueryValue = subQueryValue();
}
if (subQueryValue instanceof Array) {
//si la valeur est un tableau on le transforme en chaînes séparés par un séparateur donné ou par ','
subQueryValue = subQueryValue.join(buffer[key]['options']['separator'] || ',');
} else if (typeof subQueryValue === 'object') {
//si c'est un object on le sérialise
subQueryValue = window['ATInternet']['Utils']['jsonSerialize'](subQueryValue);
} else if (typeof subQueryValue === 'undefined') {
subQueryValue = 'undefined';
} else {
subQueryValue = subQueryValue.toString();
}
if (buffer[key]['options']['encode']) {
subQueryValue = encodeURIComponent(subQueryValue);
}
var subQuery = _makeSubQuery(key, subQueryValue, ATInternet.Utils.arrayIndexOf(_multiHitable, key) > -1 || buffer[key]['options']['truncate'], buffer[key]['options']['multihit'], buffer[key]['options']['separator'], buffer[key]['options']['encode']);
totalSize += subQuery.paramSize + subQuery.strSize;
if (!buffer[key]['options']['last']) {
subQueries[key] = subQuery;
if (subQueries[key].paramSize + subQueries[key].strSize > maxsize && !subQueries[key].truncate) {
//le paramètre est trop long et non troncable
sizeError = true;
keySizeError = key;
break;
}
} else {
//la paramètre avait l'option 'last', on le garde pour le placer à la fin du dictionnaire
if (subQueryValue.length > maxsize - 10) {
subQueryValue = subQueryValue.substr(0, maxsize - 10);
}
lastKey = key;
lastSubQuery = subQuery;
}
}
}
if (lastKey) {
subQueries[lastKey] = lastSubQuery;
}
return [subQueries, totalSize, sizeError, keySizeError];
};
/**
* Build at least one queryString (except for "?s=xxxx" parameter) using {@link ATInternet.Tracker.BufferManager parameters in the BufferManager}.
* <br />Indeed if the total size of the params involves a too long hit it's truncated in several hits (multihits).
* @memberof BuildManager#
* @function
* @param customParams {object} Custom parameters forced for queryString
* @param withOptions {boolean} true if custom params contain options
* @param filters {Array} List of buffer filters
* @param callback {function} Callback which will use the queryString
* @returns {string|Array} String if the total size was short enough, other wise it will be an array.
* <br />Warning: it will be an array with one element if one of the parameter was too long and couldn't be truncated.
* @private
*/
var _buildParams = function (customParams, withOptions, filters, callback) {
var createQueriesString = function (buffer) {
if (buffer === {}) {
return "";
}
var queries = [];
var resPreQuery = _preQuery(buffer, MAXSIZE);
var queryStrParams = resPreQuery[0];
var errorSize = resPreQuery[2];
if (errorSize) {
//Il y a une erreur sur le param resPreQuery[3]
//on génère donc un tableau à un seul élément pour signifier une erreur
//ce tableau contiendra un hit contenant le paramètre qui a causé l'erreur tronqué et
//le parametre 'mherr'
var paramError = resPreQuery[3];
var queryError = queryStrParams[paramError];
queryError['str'] = queryError['str'].substr(0, MAXSIZE - 50);
queryError['strSize'] = MAXSIZE - 50;
var newPreQueries = {};
newPreQueries['mherr'] = _makeSubQuery('mherr', '1', false);
newPreQueries[paramError] = queryError;
queries.push(_makeOneHit(newPreQueries, MAXSIZE)[0]);
}
else {
var resHit = _makeOneHit(queryStrParams, MAXSIZE);
if (resHit[1] === null) {
//on n'est pas dans le cas d'un multihit donc on retourne une chaîne
queries = resHit[0];
} else {
//On est dans le cas d'un multihit
queries.push(resHit[0]);
while (resHit[1] !== null) {
resHit = _makeOneHit(queryStrParams, MAXSIZE);
queries.push(resHit[0]);
}
}
}
return queries;
};
var QueriesString = '';
if (!parent['buffer']['presentInFilters'](filters, 'hitType')) {
filters = parent['buffer']['addInFilters'](filters, 'hitType', ['page']);
}
filters = parent['buffer']['addInFilters'](filters, 'hitType', ['all']);
var params, key;
if (typeof customParams === 'object' && customParams !== null) {
// Récupérer les filtres et y ajouter celui des permanents
filters = parent['buffer']['addInFilters'](filters, 'permanent', true);
params = parent['buffer']['get'](filters, true);
var paramValue, paramOptions, isValue, isOptions, subKey;
for (key in customParams) {
if (customParams.hasOwnProperty(key)) {
paramValue = customParams[key];
paramOptions = {};
if (withOptions) {
if (typeof customParams[key] === 'object') {
isValue = false;
isOptions = false;
for (subKey in customParams[key]) {
if (customParams[key].hasOwnProperty(subKey)) {
if (subKey === 'value') {
isValue = true;
}
else if (subKey === 'options' && typeof customParams[key].options === 'object' && customParams[key].options !== null) {
isOptions = true;
}
}
}
if (isValue && isOptions) {
paramValue = customParams[key].value;
paramOptions = customParams[key].options;
}
}
}
params[key] = {
'value': paramValue,
'options': paramOptions
};
}
}
QueriesString = createQueriesString(params);
}
else {
params = parent['buffer']['get'](filters, true);
QueriesString = createQueriesString(params);
//on sort du buffer tous les paramètres qui ne sont pas permanents
for (key in params) {
if (params.hasOwnProperty(key)) {
if (!params[key]['options']['permanent']) {
parent['buffer']['del'](key);
}
}
}
}
callback && callback(QueriesString);
};
/**
* Build the base URL with level 1 and call the callback given with it
* @memberof BuildManager#
* @function
* @param forcedDomain {String} Force the domain of the base URL
* @param callback {function} Callback which will use the base URL
* @private
*/
var _buildConfig = function (forcedDomain, callback) {
var configSecure = parent.getConfig('secure');
var collectDomain = '';
if (forcedDomain) {
collectDomain = forcedDomain;
}
else {
var protocolSecure = (document.location.protocol === _secureProtocol);
var isSecure = configSecure || protocolSecure;
var log = isSecure ? parent.getConfig('logSSL') : parent.getConfig('log');
var domain = parent.getConfig('domain');
if (log && domain) {
collectDomain = log + '.' + domain;
}
else {
collectDomain = isSecure ? parent.getConfig('collectDomainSSL') : parent.getConfig('collectDomain');
}
}
var baseURL = parent.getConfig('baseURL');
var pixelPath = parent.getConfig('pixelPath');
pixelPath = pixelPath || '/';
if (pixelPath && pixelPath.charAt(0) !== '/') {
pixelPath = '/' + pixelPath;
}
var site = parent.getConfig('site');
if ((baseURL || (collectDomain && pixelPath)) && site) {
site = '?s=' + site;
var protocol = configSecure ? 'https://' : '//';
callback && callback(null, (baseURL ? baseURL : protocol + collectDomain + pixelPath) + site);
}
else {
callback && callback({message: 'Config error'});
}
};
/**
* Build a list of hits (base URL + queryString)
* @memberof BuildManager#
* @function
* @param customParams {object} Custom parameters forced
* @param withOptions {boolean} true if custom params contain options
* @param filters {Array} List of buffer filters
* @param forcedDomain {String} Force the domain of the base URL
* @param callback {function} callback which will use the hit list
* @private
*/
var _build = function (customParams, withOptions, filters, forcedDomain, callback) {
_buildConfig(forcedDomain, function (err, baseHit) {
if (!err) {
_buildParams(customParams, withOptions, filters, function (queriesString) {
var hits = [];
var uuid = ATInternet.Utils.uuid();
var guid = uuid.num(13);
if (!(queriesString instanceof Array)) {
hits.push(baseHit + queriesString);
} else if (queriesString.length === 1) {
hits.push(baseHit + '&mh=1-2-' + guid + queriesString[0]);
} else {
for (var i = 1; i <= queriesString.length; i++) {
hits.push(baseHit + '&mh=' + i + '-' + queriesString.length + '-' + guid + queriesString[i - 1]);
}
}
callback && callback(null, hits);
});
}
else {
callback && callback(err);
}
});
};
/**
* Send at least one hit, more if it's too long (multihits).
* @name send
* @memberof BuildManager#
* @function
* @param customParams {object} Object which contains some hit parameters that you would like to send specifically (they are given priority over the current buffer)
* @param filters {Array} List of buffer filters
* @param callback {function} Callback to execute
* @param forcedDomain {String} Force the domain of the base URL
* @param withOptions {boolean} true if custom params contain options
* @public
*/
self['send'] = function (customParams, filters, callback, forcedDomain, withOptions) {
_build(customParams, withOptions, filters, forcedDomain, function (err, hits) {
if (!err) {
for (var i = 0; i < hits.length; i++) {
self.sendUrl(hits[i], callback);
}
}
else {
parent.emit('Tracker:Hit:Build:Error', {
lvl: 'ERROR',
msg: err.message,
details: {hits: hits}
});
callback && callback();
}
});
};
/**
* Send single hit from complete url.
* <br />An event will be sent {@link ATInternet.Tracker.TriggersManager} :
* <br />- "Tracker:Hit:Sent:Ok" with hit data if succeed
* <br />- "Tracker:Hit:Sent:Error" with error data otherwise
* @name sendUrl
* @memberof BuildManager#
* @function
* @param hit {string} Url to send
* @param callback {function} Callback to execute
* @public
*/
self['sendUrl'] = function (hit, callback) {
var makeTriggerCallback = function (trackerTrigger, hit, level) {
return (function () {
return function (evt) {
parent.emit(trackerTrigger, {
lvl: level,
details: {
hit: hit,
event: evt
}
});
callback && callback();
};
})();
};
if (ATInternet.Utils.isOptedOut() && !parent.getConfig('sendHitWhenOptOut')) {
makeTriggerCallback('Tracker:Hit:Sent:NoTrack', hit, 'INFO')();
}
else {
var img = new Image();
img.onload = makeTriggerCallback('Tracker:Hit:Sent:Ok', hit, 'INFO');
img.onerror = makeTriggerCallback('Tracker:Hit:Sent:Error', hit, 'ERROR');
img.src = hit;
}
};
// For unit tests on private elements !!!
/* @if test */
self['buildParams'] = _buildParams;
self['buildConfig'] = _buildConfig;
self['build'] = _build;
self['makeSubQuery'] = _makeSubQuery;
self['preQuery'] = _preQuery;
self['multiHitable'] = _multiHitable;
self['makeOneHit'] = _makeOneHit;
self['secureProtocol'] = _secureProtocol;
/* @endif */
};
