Title

within the ) this will get the actual link element + sourceElement = getSourceElement(sourceElement); + + if(isLinkToDifferentDomainButSamePiwikWebsite(sourceElement)) { + replaceHrefForCrossDomainLink(sourceElement); + } + + } + } + + function isIE8orOlder() + { + return documentAlias.all && !documentAlias.addEventListener; + } + + function getKeyCodeFromEvent(event) + { + // event.which is deprecated https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent/which + var which = event.which; + + /** + 1 : Left mouse button + 2 : Wheel button or middle button + 3 : Right mouse button + */ + + var typeOfEventButton = (typeof event.button); + + if (!which && typeOfEventButton !== 'undefined' ) { + /** + -1: No button pressed + 0 : Main button pressed, usually the left button + 1 : Auxiliary button pressed, usually the wheel button or themiddle button (if present) + 2 : Secondary button pressed, usually the right button + 3 : Fourth button, typically the Browser Back button + 4 : Fifth button, typically the Browser Forward button + + IE8 and earlier has different values: + 1 : Left mouse button + 2 : Right mouse button + 4 : Wheel button or middle button + + For a left-hand configured mouse, the return values are reversed. We do not take care of that. + */ + + if (isIE8orOlder()) { + if (event.button & 1) { + which = 1; + } else if (event.button & 2) { + which = 3; + } else if (event.button & 4) { + which = 2; + } + } else { + if (event.button === 0 || event.button === '0') { + which = 1; + } else if (event.button & 1) { + which = 2; + } else if (event.button & 2) { + which = 3; + } + } + } + + return which; + } + + function getNameOfClickedButton(event) + { + switch (getKeyCodeFromEvent(event)) { + case 1: + return 'left'; + case 2: + return 'middle'; + case 3: + return 'right'; + } + } + + function getTargetElementFromEvent(event) + { + return event.target || event.srcElement; + } + + /* + * Handle click event + */ + function clickHandler(enable) { + + return function (event) { + + event = event || windowAlias.event; + + var button = getNameOfClickedButton(event); + var target = getTargetElementFromEvent(event); + + if (event.type === 'click') { + + var ignoreClick = false; + if (enable && button === 'middle') { + // if enabled, we track middle clicks via mouseup + // some browsers (eg chrome) trigger click and mousedown/up events when middle is clicked, + // whereas some do not. This way we make "sure" to track them only once, either in click + // (default) or in mouseup (if enable == true) + ignoreClick = true; + } + + if (target && !ignoreClick) { + processClick(target); + } + } else if (event.type === 'mousedown') { + if (button === 'middle' && target) { + lastButton = button; + lastTarget = target; + } else { + lastButton = lastTarget = null; + } + } else if (event.type === 'mouseup') { + if (button === lastButton && target === lastTarget) { + processClick(target); + } + lastButton = lastTarget = null; + } else if (event.type === 'contextmenu') { + processClick(target); + } + }; + } + + /* + * Add click listener to a DOM element + */ + function addClickListener(element, enable) { + var enableType = typeof enable; + if (enableType === 'undefined') { + enable = true; + } + + addEventListener(element, 'click', clickHandler(enable), false); + + if (enable) { + addEventListener(element, 'mouseup', clickHandler(enable), false); + addEventListener(element, 'mousedown', clickHandler(enable), false); + addEventListener(element, 'contextmenu', clickHandler(enable), false); + } + } + + /* + * Add click handlers to anchor and AREA elements, except those to be ignored + */ + function addClickListeners(enable, trackerInstance) { + linkTrackingInstalled = true; + + // iterate through anchor elements with href and AREA elements + var i, + ignorePattern = getClassesRegExp(configIgnoreClasses, 'ignore'), + linkElements = documentAlias.links, + linkElement = null, trackerType = null; + + if (linkElements) { + for (i = 0; i < linkElements.length; i++) { + linkElement = linkElements[i]; + if (!ignorePattern.test(linkElement.className)) { + trackerType = typeof linkElement.piwikTrackers; + + if ('undefined' === trackerType) { + linkElement.piwikTrackers = []; + } + + if (-1 === indexOfArray(linkElement.piwikTrackers, trackerInstance)) { + // we make sure to setup link only once for each tracker + linkElement.piwikTrackers.push(trackerInstance); + addClickListener(linkElement, enable); + } + } + } + } + } + + + function enableTrackOnlyVisibleContent (checkOnSroll, timeIntervalInMs, tracker) { + + if (isTrackOnlyVisibleContentEnabled) { + // already enabled, do not register intervals again + return true; + } + + isTrackOnlyVisibleContentEnabled = true; + + var didScroll = false; + var events, index; + + function setDidScroll() { didScroll = true; } + + trackCallbackOnLoad(function () { + + function checkContent(intervalInMs) { + setTimeout(function () { + if (!isTrackOnlyVisibleContentEnabled) { + return; // the tests stopped tracking only visible content + } + didScroll = false; + tracker.trackVisibleContentImpressions(); + checkContent(intervalInMs); + }, intervalInMs); + } + + function checkContentIfDidScroll(intervalInMs) { + + setTimeout(function () { + if (!isTrackOnlyVisibleContentEnabled) { + return; // the tests stopped tracking only visible content + } + + if (didScroll) { + didScroll = false; + tracker.trackVisibleContentImpressions(); + } + + checkContentIfDidScroll(intervalInMs); + }, intervalInMs); + } + + if (checkOnSroll) { + + // scroll event is executed after each pixel, so we make sure not to + // execute event too often. otherwise FPS goes down a lot! + events = ['scroll', 'resize']; + for (index = 0; index < events.length; index++) { + if (documentAlias.addEventListener) { + documentAlias.addEventListener(events[index], setDidScroll); + } else { + windowAlias.attachEvent('on' + events[index], setDidScroll); + } + } + + checkContentIfDidScroll(100); + } + + if (timeIntervalInMs && timeIntervalInMs > 0) { + timeIntervalInMs = parseInt(timeIntervalInMs, 10); + checkContent(timeIntervalInMs); + } + + }); + } + + /* + * Browser features (plugins, resolution, cookies) + */ + function detectBrowserFeatures() { + var i, + mimeType, + pluginMap = { + // document types + pdf: 'application/pdf', + + // media players + qt: 'video/quicktime', + realp: 'audio/x-pn-realaudio-plugin', + wma: 'application/x-mplayer2', + + // interactive multimedia + dir: 'application/x-director', + fla: 'application/x-shockwave-flash', + + // RIA + java: 'application/x-java-vm', + gears: 'application/x-googlegears', + ag: 'application/x-silverlight' + }; + + // detect browser features except IE < 11 (IE 11 user agent is no longer MSIE) + if (!((new RegExp('MSIE')).test(navigatorAlias.userAgent))) { + // general plugin detection + if (navigatorAlias.mimeTypes && navigatorAlias.mimeTypes.length) { + for (i in pluginMap) { + if (Object.prototype.hasOwnProperty.call(pluginMap, i)) { + mimeType = navigatorAlias.mimeTypes[pluginMap[i]]; + browserFeatures[i] = (mimeType && mimeType.enabledPlugin) ? '1' : '0'; + } + } + } + + // Safari and Opera + // IE6/IE7 navigator.javaEnabled can't be aliased, so test directly + if (typeof navigator.javaEnabled !== 'unknown' && + isDefined(navigatorAlias.javaEnabled) && + navigatorAlias.javaEnabled()) { + browserFeatures.java = '1'; + } + + // Firefox + if (isFunction(windowAlias.GearsFactory)) { + browserFeatures.gears = '1'; + } + + // other browser features + browserFeatures.cookie = hasCookies(); + } + + var width = parseInt(screenAlias.width, 10); + var height = parseInt(screenAlias.height, 10); + browserFeatures.res = parseInt(width, 10) + 'x' + parseInt(height, 10); + } + + /**/ + /* + * Register a test hook. Using eval() permits access to otherwise + * privileged members. + */ + function registerHook(hookName, userHook) { + var hookObj = null; + + if (isString(hookName) && !isDefined(registeredHooks[hookName]) && userHook) { + if (isObject(userHook)) { + hookObj = userHook; + } else if (isString(userHook)) { + try { + eval('hookObj =' + userHook); + } catch (ignore) { } + } + + registeredHooks[hookName] = hookObj; + } + + return hookObj; + } + /**/ + + /************************************************************ + * Constructor + ************************************************************/ + + /* + * initialize tracker + */ + detectBrowserFeatures(); + updateDomainHash(); + setVisitorIdCookie(); + + /**/ + /* + * initialize test plugin + */ + executePluginMethod('run', null, registerHook); + /**/ + + /************************************************************ + * Public data and methods + ************************************************************/ + + + /**/ + /* + * Test hook accessors + */ + this.hook = registeredHooks; + this.getHook = function (hookName) { + return registeredHooks[hookName]; + }; + this.getQuery = function () { + return query; + }; + this.getContent = function () { + return content; + }; + + this.buildContentImpressionRequest = buildContentImpressionRequest; + this.buildContentInteractionRequest = buildContentInteractionRequest; + this.buildContentInteractionRequestNode = buildContentInteractionRequestNode; + this.buildContentInteractionTrackingRedirectUrl = buildContentInteractionTrackingRedirectUrl; + this.getContentImpressionsRequestsFromNodes = getContentImpressionsRequestsFromNodes; + this.getCurrentlyVisibleContentImpressionsRequestsIfNotTrackedYet = getCurrentlyVisibleContentImpressionsRequestsIfNotTrackedYet; + this.trackCallbackOnLoad = trackCallbackOnLoad; + this.trackCallbackOnReady = trackCallbackOnReady; + this.buildContentImpressionsRequests = buildContentImpressionsRequests; + this.wasContentImpressionAlreadyTracked = wasContentImpressionAlreadyTracked; + this.appendContentInteractionToRequestIfPossible = getContentInteractionToRequestIfPossible; + this.setupInteractionsTracking = setupInteractionsTracking; + this.trackContentImpressionClickInteraction = trackContentImpressionClickInteraction; + this.internalIsNodeVisible = isVisible; + this.isNodeAuthorizedToTriggerInteraction = isNodeAuthorizedToTriggerInteraction; + this.replaceHrefIfInternalLink = replaceHrefIfInternalLink; + this.getDomains = function () { + return configHostsAlias; + }; + this.getConfigCookiePath = function () { + return configCookiePath; + }; + this.getConfigIdPageView = function () { + return configIdPageView; + }; + this.getConfigDownloadExtensions = function () { + return configDownloadExtensions; + }; + this.enableTrackOnlyVisibleContent = function (checkOnScroll, timeIntervalInMs) { + return enableTrackOnlyVisibleContent(checkOnScroll, timeIntervalInMs, this); + }; + this.clearTrackedContentImpressions = function () { + trackedContentImpressions = []; + }; + this.getTrackedContentImpressions = function () { + return trackedContentImpressions; + }; + this.clearEnableTrackOnlyVisibleContent = function () { + isTrackOnlyVisibleContentEnabled = false; + }; + this.disableLinkTracking = function () { + linkTrackingInstalled = false; + linkTrackingEnabled = false; + }; + this.getConfigVisitorCookieTimeout = function () { + return configVisitorCookieTimeout; + }; + this.removeAllAsyncTrackersButFirst = function () { + var firstTracker = asyncTrackers[0]; + asyncTrackers = [firstTracker]; + }; + this.getRemainingVisitorCookieTimeout = getRemainingVisitorCookieTimeout; + /**/ + + /** + * Get visitor ID (from first party cookie) + * + * @return string Visitor ID in hexits (or empty string, if not yet known) + */ + this.getVisitorId = function () { + return getValuesFromVisitorIdCookie().uuid; + }; + + /** + * Get the visitor information (from first party cookie) + * + * @return array + */ + this.getVisitorInfo = function () { + // Note: in a new method, we could return also return getValuesFromVisitorIdCookie() + // which returns named parameters rather than returning integer indexed array + return loadVisitorIdCookie(); + }; + + /** + * Get the Attribution information, which is an array that contains + * the Referrer used to reach the site as well as the campaign name and keyword + * It is useful only when used in conjunction with Tracker API function setAttributionInfo() + * To access specific data point, you should use the other functions getAttributionReferrer* and getAttributionCampaign* + * + * @return array Attribution array, Example use: + * 1) Call JSON_PIWIK.stringify(piwikTracker.getAttributionInfo()) + * 2) Pass this json encoded string to the Tracking API (php or java client): setAttributionInfo() + */ + this.getAttributionInfo = function () { + return loadReferrerAttributionCookie(); + }; + + /** + * Get the Campaign name that was parsed from the landing page URL when the visitor + * landed on the site originally + * + * @return string + */ + this.getAttributionCampaignName = function () { + return loadReferrerAttributionCookie()[0]; + }; + + /** + * Get the Campaign keyword that was parsed from the landing page URL when the visitor + * landed on the site originally + * + * @return string + */ + this.getAttributionCampaignKeyword = function () { + return loadReferrerAttributionCookie()[1]; + }; + + /** + * Get the time at which the referrer (used for Goal Attribution) was detected + * + * @return int Timestamp or 0 if no referrer currently set + */ + this.getAttributionReferrerTimestamp = function () { + return loadReferrerAttributionCookie()[2]; + }; + + /** + * Get the full referrer URL that will be used for Goal Attribution + * + * @return string Raw URL, or empty string '' if no referrer currently set + */ + this.getAttributionReferrerUrl = function () { + return loadReferrerAttributionCookie()[3]; + }; + + /** + * Specify the Piwik server URL + * + * @param string trackerUrl + */ + this.setTrackerUrl = function (trackerUrl) { + configTrackerUrl = trackerUrl; + }; + + /** + * Returns the Piwik server URL + * @returns string + */ + this.getTrackerUrl = function () { + return configTrackerUrl; + }; + + /** + * Adds a new tracker. All sent requests will be also sent to the given siteId and piwikUrl. + * + * @param string piwikUrl The tracker URL of the current tracker instance + * @param int|string siteId + * @return Tracker + */ + this.addTracker = function (piwikUrl, siteId) { + if (!siteId) { + throw new Error('A siteId must be given to add a new tracker'); + } + + if (!isDefined(piwikUrl) || null === piwikUrl) { + piwikUrl = this.getTrackerUrl(); + } + + var tracker = new Tracker(piwikUrl, siteId); + + asyncTrackers.push(tracker); + + return tracker; + }; + + /** + * Returns the site ID + * + * @returns int + */ + this.getSiteId = function() { + return configTrackerSiteId; + }; + + /** + * Specify the site ID + * + * @param int|string siteId + */ + this.setSiteId = function (siteId) { + setSiteId(siteId); + }; + + /** + * Sets a User ID to this user (such as an email address or a username) + * + * @param string User ID + */ + this.setUserId = function (userId) { + if(!isDefined(userId) || !userId.length) { + return; + } + configUserId = userId; + visitorUUID = hash(configUserId).substr(0, 16); + }; + + /** + * Gets the User ID if set. + * + * @returns string User ID + */ + this.getUserId = function() { + return configUserId; + }; + + /** + * Pass custom data to the server + * + * Examples: + * tracker.setCustomData(object); + * tracker.setCustomData(key, value); + * + * @param mixed key_or_obj + * @param mixed opt_value + */ + this.setCustomData = function (key_or_obj, opt_value) { + if (isObject(key_or_obj)) { + configCustomData = key_or_obj; + } else { + if (!configCustomData) { + configCustomData = {}; + } + configCustomData[key_or_obj] = opt_value; + } + }; + + /** + * Get custom data + * + * @return mixed + */ + this.getCustomData = function () { + return configCustomData; + }; + + /** + * Configure function with custom request content processing logic. + * It gets called after request content in form of query parameters string has been prepared and before request content gets sent. + * + * Examples: + * tracker.setCustomRequestProcessing(function(request){ + * var pairs = request.split('&'); + * var result = {}; + * pairs.forEach(function(pair) { + * pair = pair.split('='); + * result[pair[0]] = decodeURIComponent(pair[1] || ''); + * }); + * return JSON.stringify(result); + * }); + * + * @param function customRequestContentProcessingLogic + */ + this.setCustomRequestProcessing = function (customRequestContentProcessingLogic) { + configCustomRequestContentProcessing = customRequestContentProcessingLogic; + }; + + /** + * Appends the specified query string to the piwik.php?... Tracking API URL + * + * @param string queryString eg. 'lat=140&long=100' + */ + this.appendToTrackingUrl = function (queryString) { + configAppendToTrackingUrl = queryString; + }; + + /** + * Returns the query string for the current HTTP Tracking API request. + * Piwik would prepend the hostname and path to Piwik: http://example.org/piwik/piwik.php? + * prior to sending the request. + * + * @param request eg. "param=value¶m2=value2" + */ + this.getRequest = function (request) { + return getRequest(request); + }; + + /** + * Add plugin defined by a name and a callback function. + * The callback function will be called whenever a tracking request is sent. + * This can be used to append data to the tracking request, or execute other custom logic. + * + * @param string pluginName + * @param Object pluginObj + */ + this.addPlugin = function (pluginName, pluginObj) { + plugins[pluginName] = pluginObj; + }; + + /** + * Set Custom Dimensions. Set Custom Dimensions will not be cleared after a tracked pageview and will + * be sent along all following tracking requests. It is possible to remove/clear a value via `deleteCustomDimension`. + * + * @param int index A Custom Dimension index + * @param string value + */ + this.setCustomDimension = function (customDimensionId, value) { + customDimensionId = parseInt(customDimensionId, 10); + if (customDimensionId > 0) { + if (!isDefined(value)) { + value = ''; + } + if (!isString(value)) { + value = String(value); + } + customDimensions[customDimensionId] = value; + } + }; + + /** + * Get a stored value for a specific Custom Dimension index. + * + * @param int index A Custom Dimension index + */ + this.getCustomDimension = function (customDimensionId) { + customDimensionId = parseInt(customDimensionId, 10); + if (customDimensionId > 0 && Object.prototype.hasOwnProperty.call(customDimensions, customDimensionId)) { + return customDimensions[customDimensionId]; + } + }; + + /** + * Delete a custom dimension. + * + * @param int index Custom dimension Id + */ + this.deleteCustomDimension = function (customDimensionId) { + customDimensionId = parseInt(customDimensionId, 10); + if (customDimensionId > 0) { + delete customDimensions[customDimensionId]; + } + }; + + /** + * Set custom variable within this visit + * + * @param int index Custom variable slot ID from 1-5 + * @param string name + * @param string value + * @param string scope Scope of Custom Variable: + * - "visit" will store the name/value in the visit and will persist it in the cookie for the duration of the visit, + * - "page" will store the name/value in the next page view tracked. + * - "event" will store the name/value in the next event tracked. + */ + this.setCustomVariable = function (index, name, value, scope) { + var toRecord; + + if (!isDefined(scope)) { + scope = 'visit'; + } + if (!isDefined(name)) { + return; + } + if (!isDefined(value)) { + value = ""; + } + if (index > 0) { + name = !isString(name) ? String(name) : name; + value = !isString(value) ? String(value) : value; + toRecord = [name.slice(0, customVariableMaximumLength), value.slice(0, customVariableMaximumLength)]; + // numeric scope is there for GA compatibility + if (scope === 'visit' || scope === 2) { + loadCustomVariables(); + customVariables[index] = toRecord; + } else if (scope === 'page' || scope === 3) { + customVariablesPage[index] = toRecord; + } else if (scope === 'event') { /* GA does not have 'event' scope but we do */ + customVariablesEvent[index] = toRecord; + } + } + }; + + /** + * Get custom variable + * + * @param int index Custom variable slot ID from 1-5 + * @param string scope Scope of Custom Variable: "visit" or "page" or "event" + */ + this.getCustomVariable = function (index, scope) { + var cvar; + + if (!isDefined(scope)) { + scope = "visit"; + } + + if (scope === "page" || scope === 3) { + cvar = customVariablesPage[index]; + } else if (scope === "event") { + cvar = customVariablesEvent[index]; + } else if (scope === "visit" || scope === 2) { + loadCustomVariables(); + cvar = customVariables[index]; + } + + if (!isDefined(cvar) + || (cvar && cvar[0] === '')) { + return false; + } + + return cvar; + }; + + /** + * Delete custom variable + * + * @param int index Custom variable slot ID from 1-5 + * @param string scope + */ + this.deleteCustomVariable = function (index, scope) { + // Only delete if it was there already + if (this.getCustomVariable(index, scope)) { + this.setCustomVariable(index, '', '', scope); + } + }; + + /** + * Deletes all custom variables for a certain scope. + * + * @param string scope + */ + this.deleteCustomVariables = function (scope) { + if (scope === "page" || scope === 3) { + customVariablesPage = {}; + } else if (scope === "event") { + customVariablesEvent = {}; + } else if (scope === "visit" || scope === 2) { + customVariables = {}; + } + }; + + /** + * When called then the Custom Variables of scope "visit" will be stored (persisted) in a first party cookie + * for the duration of the visit. This is useful if you want to call getCustomVariable later in the visit. + * + * By default, Custom Variables of scope "visit" are not stored on the visitor's computer. + */ + this.storeCustomVariablesInCookie = function () { + configStoreCustomVariablesInCookie = true; + }; + + /** + * Set delay for link tracking (in milliseconds) + * + * @param int delay + */ + this.setLinkTrackingTimer = function (delay) { + configTrackerPause = delay; + }; + + /** + * Get delay for link tracking (in milliseconds) + * + * @param int delay + */ + this.getLinkTrackingTimer = function () { + return configTrackerPause; + }; + + /** + * Set list of file extensions to be recognized as downloads + * + * @param string|array extensions + */ + this.setDownloadExtensions = function (extensions) { + if(isString(extensions)) { + extensions = extensions.split('|'); + } + configDownloadExtensions = extensions; + }; + + /** + * Specify additional file extensions to be recognized as downloads + * + * @param string|array extensions for example 'custom' or ['custom1','custom2','custom3'] + */ + this.addDownloadExtensions = function (extensions) { + var i; + if(isString(extensions)) { + extensions = extensions.split('|'); + } + for (i=0; i < extensions.length; i++) { + configDownloadExtensions.push(extensions[i]); + } + }; + + /** + * Removes specified file extensions from the list of recognized downloads + * + * @param string|array extensions for example 'custom' or ['custom1','custom2','custom3'] + */ + this.removeDownloadExtensions = function (extensions) { + var i, newExtensions = []; + if(isString(extensions)) { + extensions = extensions.split('|'); + } + for (i=0; i < configDownloadExtensions.length; i++) { + if (indexOfArray(extensions, configDownloadExtensions[i]) === -1) { + newExtensions.push(configDownloadExtensions[i]); + } + } + configDownloadExtensions = newExtensions; + }; + + /** + * Set array of domains to be treated as local. Also supports path, eg '.piwik.org/subsite1'. In this + * case all links that don't go to '*.piwik.org/subsite1/ *' would be treated as outlinks. + * For example a link to 'piwik.org/' or 'piwik.org/subsite2' both would be treated as outlinks. + * + * Also supports page wildcard, eg 'piwik.org/index*'. In this case all links + * that don't go to piwik.org/index* would be treated as outlinks. + * + * The current domain will be added automatically if no given host alias contains a path and if no host + * alias is already given for the current host alias. Say you are on "example.org" and set + * "hostAlias = ['example.com', 'example.org/test']" then the current "example.org" domain will not be + * added as there is already a more restrictive hostAlias 'example.org/test' given. We also do not add + * it automatically if there was any other host specifying any path like + * "['example.com', 'example2.com/test']". In this case we would also not add the current + * domain "example.org" automatically as the "path" feature is used. As soon as someone uses the path + * feature, for Piwik JS Tracker to work correctly in all cases, one needs to specify all hosts + * manually. + * + * @param string|array hostsAlias + */ + this.setDomains = function (hostsAlias) { + configHostsAlias = isString(hostsAlias) ? [hostsAlias] : hostsAlias; + + var hasDomainAliasAlready = false, i = 0, alias; + for (i; i < configHostsAlias.length; i++) { + alias = String(configHostsAlias[i]); + + if (isSameHost(domainAlias, domainFixup(alias))) { + hasDomainAliasAlready = true; + break; + } + + var pathName = getPathName(alias); + if (pathName && pathName !== '/' && pathName !== '/*') { + hasDomainAliasAlready = true; + break; + } + } + + // The current domain will be added automatically if no given host alias contains a path + // and if no host alias is already given for the current host alias. + if (!hasDomainAliasAlready) { + /** + * eg if domainAlias = 'piwik.org' and someone set hostsAlias = ['piwik.org/foo'] then we should + * not add piwik.org as it would increase the allowed scope. + */ + configHostsAlias.push(domainAlias); + } + }; + + /** + * Enables cross domain linking. By default, the visitor ID that identifies a unique visitor is stored in + * the browser's first party cookies. This means the cookie can only be accessed by pages on the same domain. + * If you own multiple domains and would like to track all the actions and pageviews of a specific visitor + * into the same visit, you may enable cross domain linking. Whenever a user clicks on a link it will append + * a URL parameter pk_vid to the clicked URL which consists of these parts: 16 char visitorId, a 10 character + * current timestamp and the last 6 characters are an id based on the userAgent to identify the users device). + * This way the current visitorId is forwarded to the page of the different domain. + * + * On the different domain, the Piwik tracker will recognize the set visitorId from the URL parameter and + * reuse this parameter if the page was loaded within 45 seconds. If cross domain linking was not enabled, + * it would create a new visit on that page because we wouldn't be able to access the previously created + * cookie. By enabling cross domain linking you can track several different domains into one website and + * won't lose for example the original referrer. + * + * To make cross domain linking work you need to set which domains should be considered as your domains by + * calling the method "setDomains()" first. We will add the URL parameter to links that go to a + * different domain but only if the domain was previously set with "setDomains()" to make sure not to append + * the URL parameters when a link actually goes to a third-party URL. + */ + this.enableCrossDomainLinking = function () { + crossDomainTrackingEnabled = true; + }; + + /** + * Disable cross domain linking if it was previously enabled. See enableCrossDomainLinking(); + */ + this.disableCrossDomainLinking = function () { + crossDomainTrackingEnabled = false; + }; + + /** + * Detect whether cross domain linking is enabled or not. See enableCrossDomainLinking(); + * @returns bool + */ + this.isCrossDomainLinkingEnabled = function () { + return crossDomainTrackingEnabled; + }; + + /** + * Set array of classes to be ignored if present in link + * + * @param string|array ignoreClasses + */ + this.setIgnoreClasses = function (ignoreClasses) { + configIgnoreClasses = isString(ignoreClasses) ? [ignoreClasses] : ignoreClasses; + }; + + /** + * Set request method + * + * @param string method GET or POST; default is GET + */ + this.setRequestMethod = function (method) { + configRequestMethod = method || defaultRequestMethod; + }; + + /** + * Set request Content-Type header value, applicable when POST request method is used for submitting tracking events. + * See XMLHttpRequest Level 2 spec, section 4.7.2 for invalid headers + * @link http://dvcs.w3.org/hg/xhr/raw-file/tip/Overview.html + * + * @param string requestContentType; default is 'application/x-www-form-urlencoded; charset=UTF-8' + */ + this.setRequestContentType = function (requestContentType) { + configRequestContentType = requestContentType || defaultRequestContentType; + }; + + /** + * Override referrer + * + * @param string url + */ + this.setReferrerUrl = function (url) { + configReferrerUrl = url; + }; + + /** + * Override url + * + * @param string url + */ + this.setCustomUrl = function (url) { + configCustomUrl = resolveRelativeReference(locationHrefAlias, url); + }; + + /** + * Override document.title + * + * @param string title + */ + this.setDocumentTitle = function (title) { + configTitle = title; + }; + + /** + * Set the URL of the Piwik API. It is used for Page Overlay. + * This method should only be called when the API URL differs from the tracker URL. + * + * @param string apiUrl + */ + this.setAPIUrl = function (apiUrl) { + configApiUrl = apiUrl; + }; + + /** + * Set array of classes to be treated as downloads + * + * @param string|array downloadClasses + */ + this.setDownloadClasses = function (downloadClasses) { + configDownloadClasses = isString(downloadClasses) ? [downloadClasses] : downloadClasses; + }; + + /** + * Set array of classes to be treated as outlinks + * + * @param string|array linkClasses + */ + this.setLinkClasses = function (linkClasses) { + configLinkClasses = isString(linkClasses) ? [linkClasses] : linkClasses; + }; + + /** + * Set array of campaign name parameters + * + * @see http://piwik.org/faq/how-to/#faq_120 + * @param string|array campaignNames + */ + this.setCampaignNameKey = function (campaignNames) { + configCampaignNameParameters = isString(campaignNames) ? [campaignNames] : campaignNames; + }; + + /** + * Set array of campaign keyword parameters + * + * @see http://piwik.org/faq/how-to/#faq_120 + * @param string|array campaignKeywords + */ + this.setCampaignKeywordKey = function (campaignKeywords) { + configCampaignKeywordParameters = isString(campaignKeywords) ? [campaignKeywords] : campaignKeywords; + }; + + /** + * Strip hash tag (or anchor) from URL + * Note: this can be done in the Piwik>Settings>Websites on a per-website basis + * + * @deprecated + * @param bool enableFilter + */ + this.discardHashTag = function (enableFilter) { + configDiscardHashTag = enableFilter; + }; + + /** + * Set first-party cookie name prefix + * + * @param string cookieNamePrefix + */ + this.setCookieNamePrefix = function (cookieNamePrefix) { + configCookieNamePrefix = cookieNamePrefix; + // Re-init the Custom Variables cookie + customVariables = getCustomVariablesFromCookie(); + }; + + /** + * Set first-party cookie domain + * + * @param string domain + */ + this.setCookieDomain = function (domain) { + var domainFixed = domainFixup(domain); + + if (isPossibleToSetCookieOnDomain(domainFixed)) { + configCookieDomain = domainFixed; + updateDomainHash(); + } + }; + + /** + * Set first-party cookie path + * + * @param string domain + */ + this.setCookiePath = function (path) { + configCookiePath = path; + updateDomainHash(); + }; + + /** + * Set visitor cookie timeout (in seconds) + * Defaults to 13 months (timeout=33955200) + * + * @param int timeout + */ + this.setVisitorCookieTimeout = function (timeout) { + configVisitorCookieTimeout = timeout * 1000; + }; + + /** + * Set session cookie timeout (in seconds). + * Defaults to 30 minutes (timeout=1800) + * + * @param int timeout + */ + this.setSessionCookieTimeout = function (timeout) { + configSessionCookieTimeout = timeout * 1000; + }; + + /** + * Set referral cookie timeout (in seconds). + * Defaults to 6 months (15768000000) + * + * @param int timeout + */ + this.setReferralCookieTimeout = function (timeout) { + configReferralCookieTimeout = timeout * 1000; + }; + + /** + * Set conversion attribution to first referrer and campaign + * + * @param bool if true, use first referrer (and first campaign) + * if false, use the last referrer (or campaign) + */ + this.setConversionAttributionFirstReferrer = function (enable) { + configConversionAttributionFirstReferrer = enable; + }; + + /** + * Disables all cookies from being set + * + * Existing cookies will be deleted on the next call to track + */ + this.disableCookies = function () { + configCookiesDisabled = true; + browserFeatures.cookie = '0'; + + if (configTrackerSiteId) { + deleteCookies(); + } + }; + + /** + * One off cookies clearing. Useful to call this when you know for sure a new visitor is using the same browser, + * it maybe helps to "reset" tracking cookies to prevent data reuse for different users. + */ + this.deleteCookies = function () { + deleteCookies(); + }; + + /** + * Handle do-not-track requests + * + * @param bool enable If true, don't track if user agent sends 'do-not-track' header + */ + this.setDoNotTrack = function (enable) { + var dnt = navigatorAlias.doNotTrack || navigatorAlias.msDoNotTrack; + configDoNotTrack = enable && (dnt === 'yes' || dnt === '1'); + + // do not track also disables cookies and deletes existing cookies + if (configDoNotTrack) { + this.disableCookies(); + } + }; + + /** + * Add click listener to a specific link element. + * When clicked, Piwik will log the click automatically. + * + * @param DOMElement element + * @param bool enable If false, do not use pseudo click-handler (middle click + context menu) + */ + this.addListener = function (element, enable) { + addClickListener(element, enable); + }; + + /** + * Install link tracker. + * + * If you change the DOM of your website or web application you need to make sure to call this method + * again so Piwik can detect links that were added newly. + * + * The default behaviour is to use actual click events. However, some browsers + * (e.g., Firefox, Opera, and Konqueror) don't generate click events for the middle mouse button. + * + * To capture more "clicks", the pseudo click-handler uses mousedown + mouseup events. + * This is not industry standard and is vulnerable to false positives (e.g., drag events). + * + * There is a Safari/Chrome/Webkit bug that prevents tracking requests from being sent + * by either click handler. The workaround is to set a target attribute (which can't + * be "_self", "_top", or "_parent"). + * + * @see https://bugs.webkit.org/show_bug.cgi?id=54783 + * + * @param bool enable Defaults to true. + * * If "true", use pseudo click-handler (treat middle click and open contextmenu as + * left click). A right click (or any click that opens the context menu) on a link + * will be tracked as clicked even if "Open in new tab" is not selected. + * * If "false" (default), nothing will be tracked on open context menu or middle click. + * The context menu is usually opened to open a link / download in a new tab + * therefore you can get more accurate results by treat it as a click but it can lead + * to wrong click numbers. + */ + this.enableLinkTracking = function (enable) { + linkTrackingEnabled = true; + + var self = this; + trackCallback(function () { + trackCallbackOnReady(function () { + addClickListeners(enable, self); + }); + }); + }; + + /** + * Enable tracking of uncatched JavaScript errors + * + * If enabled, uncaught JavaScript Errors will be tracked as an event by defining a + * window.onerror handler. If a window.onerror handler is already defined we will make + * sure to call this previously registered error handler after tracking the error. + * + * By default we return false in the window.onerror handler to make sure the error still + * appears in the browser's console etc. Note: Some older browsers might behave differently + * so it could happen that an actual JavaScript error will be suppressed. + * If a window.onerror handler was registered we will return the result of this handler. + * + * Make sure not to overwrite the window.onerror handler after enabling the JS error + * tracking as the error tracking won't work otherwise. To capture all JS errors we + * recommend to include the Piwik JavaScript tracker in the HTML as early as possible. + * If possible directly in before loading any other JavaScript. + */ + this.enableJSErrorTracking = function () { + if (enableJSErrorTracking) { + return; + } + + enableJSErrorTracking = true; + var onError = windowAlias.onerror; + + windowAlias.onerror = function (message, url, linenumber, column, error) { + trackCallback(function () { + var category = 'JavaScript Errors'; + + var action = url + ':' + linenumber; + if (column) { + action += ':' + column; + } + + logEvent(category, action, message); + }); + + if (onError) { + return onError(message, url, linenumber, column, error); + } + + return false; + }; + }; + + /** + * Disable automatic performance tracking + */ + this.disablePerformanceTracking = function () { + configPerformanceTrackingEnabled = false; + }; + + /** + * Set the server generation time. + * If set, the browser's performance.timing API in not used anymore to determine the time. + * + * @param int generationTime + */ + this.setGenerationTimeMs = function (generationTime) { + configPerformanceGenerationTime = parseInt(generationTime, 10); + }; + + /** + * Set heartbeat (in seconds) + * + * @param int heartBeatDelayInSeconds Defaults to 15. Cannot be lower than 1. + */ + this.enableHeartBeatTimer = function (heartBeatDelayInSeconds) { + heartBeatDelayInSeconds = Math.max(heartBeatDelayInSeconds, 1); + configHeartBeatDelay = (heartBeatDelayInSeconds || 15) * 1000; + + // if a tracking request has already been sent, start the heart beat timeout + if (lastTrackerRequestTime !== null) { + setUpHeartBeat(); + } + }; + + /** + * Disable heartbeat if it was previously activated. + */ + this.disableHeartBeatTimer = function () { + heartBeatDown(); + + if (configHeartBeatDelay || heartBeatSetUp) { + if (windowAlias.removeEventListener) { + windowAlias.removeEventListener('focus', heartBeatOnFocus, true); + windowAlias.removeEventListener('blur', heartBeatOnBlur, true); + } else if (windowAlias.detachEvent) { + windowAlias.detachEvent('onfocus', heartBeatOnFocus); + windowAlias.detachEvent('onblur', heartBeatOnBlur); + } + } + + configHeartBeatDelay = null; + heartBeatSetUp = false; + }; + + /** + * Frame buster + */ + this.killFrame = function () { + if (windowAlias.location !== windowAlias.top.location) { + windowAlias.top.location = windowAlias.location; + } + }; + + /** + * Redirect if browsing offline (aka file: buster) + * + * @param string url Redirect to this URL + */ + this.redirectFile = function (url) { + if (windowAlias.location.protocol === 'file:') { + windowAlias.location = url; + } + }; + + /** + * Count sites in pre-rendered state + * + * @param bool enable If true, track when in pre-rendered state + */ + this.setCountPreRendered = function (enable) { + configCountPreRendered = enable; + }; + + /** + * Trigger a goal + * + * @param int|string idGoal + * @param int|float customRevenue + * @param mixed customData + */ + this.trackGoal = function (idGoal, customRevenue, customData) { + trackCallback(function () { + logGoal(idGoal, customRevenue, customData); + }); + }; + + /** + * Manually log a click from your own code + * + * @param string sourceUrl + * @param string linkType + * @param mixed customData + * @param function callback + */ + this.trackLink = function (sourceUrl, linkType, customData, callback) { + trackCallback(function () { + logLink(sourceUrl, linkType, customData, callback); + }); + }; + + /** + * Log visit to this page + * + * @param string customTitle + * @param mixed customData + * @param function callback + */ + this.trackPageView = function (customTitle, customData, callback) { + trackedContentImpressions = []; + + if (isOverlaySession(configTrackerSiteId)) { + trackCallback(function () { + injectOverlayScripts(configTrackerUrl, configApiUrl, configTrackerSiteId); + }); + } else { + trackCallback(function () { + logPageView(customTitle, customData, callback); + }); + } + }; + + /** + * Scans the entire DOM for all content blocks and tracks all impressions once the DOM ready event has + * been triggered. + * + * If you only want to track visible content impressions have a look at `trackVisibleContentImpressions()`. + * We do not track an impression of the same content block twice if you call this method multiple times + * unless `trackPageView()` is called meanwhile. This is useful for single page applications. + */ + this.trackAllContentImpressions = function () { + if (isOverlaySession(configTrackerSiteId)) { + return; + } + + trackCallback(function () { + trackCallbackOnReady(function () { + // we have to wait till DOM ready + var contentNodes = content.findContentNodes(); + var requests = getContentImpressionsRequestsFromNodes(contentNodes); + + sendBulkRequest(requests, configTrackerPause); + }); + }); + }; + + /** + * Scans the entire DOM for all content blocks as soon as the page is loaded. It tracks an impression + * only if a content block is actually visible. Meaning it is not hidden and the content is or was at + * some point in the viewport. + * + * If you want to track all content blocks have a look at `trackAllContentImpressions()`. + * We do not track an impression of the same content block twice if you call this method multiple times + * unless `trackPageView()` is called meanwhile. This is useful for single page applications. + * + * Once you have called this method you can no longer change `checkOnScroll` or `timeIntervalInMs`. + * + * If you do want to only track visible content blocks but not want us to perform any automatic checks + * as they can slow down your frames per second you can call `trackVisibleContentImpressions()` or + * `trackContentImpressionsWithinNode()` manually at any time to rescan the entire DOM for newly + * visible content blocks. + * o Call `trackVisibleContentImpressions(false, 0)` to initially track only visible content impressions + * o Call `trackVisibleContentImpressions()` at any time again to rescan the entire DOM for newly visible content blocks or + * o Call `trackContentImpressionsWithinNode(node)` at any time to rescan only a part of the DOM for newly visible content blocks + * + * @param boolean [checkOnScroll=true] Optional, you can disable rescanning the entire DOM automatically + * after each scroll event by passing the value `false`. If enabled, + * we check whether a previously hidden content blocks became visible + * after a scroll and if so track the impression. + * Note: If a content block is placed within a scrollable element + * (`overflow: scroll`), we can currently not detect when this block + * becomes visible. + * @param integer [timeIntervalInMs=750] Optional, you can define an interval to rescan the entire DOM + * for new impressions every X milliseconds by passing + * for instance `timeIntervalInMs=500` (rescan DOM every 500ms). + * Rescanning the entire DOM and detecting the visible state of content + * blocks can take a while depending on the browser and amount of content. + * In case your frames per second goes down you might want to increase + * this value or disable it by passing the value `0`. + */ + this.trackVisibleContentImpressions = function (checkOnSroll, timeIntervalInMs) { + if (isOverlaySession(configTrackerSiteId)) { + return; + } + + if (!isDefined(checkOnSroll)) { + checkOnSroll = true; + } + + if (!isDefined(timeIntervalInMs)) { + timeIntervalInMs = 750; + } + + enableTrackOnlyVisibleContent(checkOnSroll, timeIntervalInMs, this); + + trackCallback(function () { + trackCallbackOnLoad(function () { + // we have to wait till CSS parsed and applied + var contentNodes = content.findContentNodes(); + var requests = getCurrentlyVisibleContentImpressionsRequestsIfNotTrackedYet(contentNodes); + + sendBulkRequest(requests, configTrackerPause); + }); + }); + }; + + /** + * Tracks a content impression using the specified values. You should not call this method too often + * as each call causes an XHR tracking request and can slow down your site or your server. + * + * @param string contentName For instance "Ad Sale". + * @param string [contentPiece='Unknown'] For instance a path to an image or the text of a text ad. + * @param string [contentTarget] For instance the URL of a landing page. + */ + this.trackContentImpression = function (contentName, contentPiece, contentTarget) { + if (isOverlaySession(configTrackerSiteId)) { + return; + } + + if (!contentName) { + return; + } + + contentPiece = contentPiece || 'Unknown'; + + trackCallback(function () { + var request = buildContentImpressionRequest(contentName, contentPiece, contentTarget); + sendRequest(request, configTrackerPause); + }); + }; + + /** + * Scans the given DOM node and its children for content blocks and tracks an impression for them if + * no impression was already tracked for it. If you have called `trackVisibleContentImpressions()` + * upfront only visible content blocks will be tracked. You can use this method if you, for instance, + * dynamically add an element using JavaScript to your DOM after we have tracked the initial impressions. + * + * @param Element domNode + */ + this.trackContentImpressionsWithinNode = function (domNode) { + if (isOverlaySession(configTrackerSiteId) || !domNode) { + return; + } + + trackCallback(function () { + if (isTrackOnlyVisibleContentEnabled) { + trackCallbackOnLoad(function () { + // we have to wait till CSS parsed and applied + var contentNodes = content.findContentNodesWithinNode(domNode); + + var requests = getCurrentlyVisibleContentImpressionsRequestsIfNotTrackedYet(contentNodes); + sendBulkRequest(requests, configTrackerPause); + }); + } else { + trackCallbackOnReady(function () { + // we have to wait till DOM ready + var contentNodes = content.findContentNodesWithinNode(domNode); + + var requests = getContentImpressionsRequestsFromNodes(contentNodes); + sendBulkRequest(requests, configTrackerPause); + }); + } + }); + }; + + /** + * Tracks a content interaction using the specified values. You should use this method only in conjunction + * with `trackContentImpression()`. The specified `contentName` and `contentPiece` has to be exactly the + * same as the ones that were used in `trackContentImpression()`. Otherwise the interaction will not count. + * + * @param string contentInteraction The type of interaction that happened. For instance 'click' or 'submit'. + * @param string contentName The name of the content. For instance "Ad Sale". + * @param string [contentPiece='Unknown'] The actual content. For instance a path to an image or the text of a text ad. + * @param string [contentTarget] For instance the URL of a landing page. + */ + this.trackContentInteraction = function (contentInteraction, contentName, contentPiece, contentTarget) { + if (isOverlaySession(configTrackerSiteId)) { + return; + } + + if (!contentInteraction || !contentName) { + return; + } + + contentPiece = contentPiece || 'Unknown'; + + trackCallback(function () { + var request = buildContentInteractionRequest(contentInteraction, contentName, contentPiece, contentTarget); + sendRequest(request, configTrackerPause); + }); + }; + + /** + * Tracks an interaction with the given DOM node / content block. + * + * By default we track interactions on click but sometimes you might want to track interactions yourself. + * For instance you might want to track an interaction manually on a double click or a form submit. + * Make sure to disable the automatic interaction tracking in this case by specifying either the CSS + * class `piwikContentIgnoreInteraction` or the attribute `data-content-ignoreinteraction`. + * + * @param Element domNode This element itself or any of its parent elements has to be a content block + * element. Meaning one of those has to have a `piwikTrackContent` CSS class or + * a `data-track-content` attribute. + * @param string [contentInteraction='Unknown] The name of the interaction that happened. For instance + * 'click', 'formSubmit', 'DblClick', ... + */ + this.trackContentInteractionNode = function (domNode, contentInteraction) { + if (isOverlaySession(configTrackerSiteId) || !domNode) { + return; + } + + trackCallback(function () { + var request = buildContentInteractionRequestNode(domNode, contentInteraction); + sendRequest(request, configTrackerPause); + }); + }; + + /** + * Useful to debug content tracking. This method will log all detected content blocks to console + * (if the browser supports the console). It will list the detected name, piece, and target of each + * content block. + */ + this.logAllContentBlocksOnPage = function () { + var contentNodes = content.findContentNodes(); + var contents = content.collectContent(contentNodes); + + if (console !== undefined && console && console.log) { + console.log(contents); + } + }; + + /** + * Records an event + * + * @param string category The Event Category (Videos, Music, Games...) + * @param string action The Event's Action (Play, Pause, Duration, Add Playlist, Downloaded, Clicked...) + * @param string name (optional) The Event's object Name (a particular Movie name, or Song name, or File name...) + * @param float value (optional) The Event's value + * @param function callback + * @param mixed customData + */ + this.trackEvent = function (category, action, name, value, customData, callback) { + trackCallback(function () { + logEvent(category, action, name, value, customData, callback); + }); + }; + + /** + * Log special pageview: Internal search + * + * @param string keyword + * @param string category + * @param int resultsCount + * @param mixed customData + */ + this.trackSiteSearch = function (keyword, category, resultsCount, customData) { + trackCallback(function () { + logSiteSearch(keyword, category, resultsCount, customData); + }); + }; + + /** + * Used to record that the current page view is an item (product) page view, or a Ecommerce Category page view. + * This must be called before trackPageView() on the product/category page. + * It will set 3 custom variables of scope "page" with the SKU, Name and Category for this page view. + * Note: Custom Variables of scope "page" slots 3, 4 and 5 will be used. + * + * On a category page, you can set the parameter category, and set the other parameters to empty string or false + * + * Tracking Product/Category page views will allow Piwik to report on Product & Categories + * conversion rates (Conversion rate = Ecommerce orders containing this product or category / Visits to the product or category) + * + * @param string sku Item's SKU code being viewed + * @param string name Item's Name being viewed + * @param string category Category page being viewed. On an Item's page, this is the item's category + * @param float price Item's display price, not use in standard Piwik reports, but output in API product reports. + */ + this.setEcommerceView = function (sku, name, category, price) { + if (!isDefined(category) || !category.length) { + category = ""; + } else if (category instanceof Array) { + category = JSON_PIWIK.stringify(category); + } + + customVariablesPage[5] = ['_pkc', category]; + + if (isDefined(price) && String(price).length) { + customVariablesPage[2] = ['_pkp', price]; + } + + // On a category page, do not track Product name not defined + if ((!isDefined(sku) || !sku.length) + && (!isDefined(name) || !name.length)) { + return; + } + + if (isDefined(sku) && sku.length) { + customVariablesPage[3] = ['_pks', sku]; + } + + if (!isDefined(name) || !name.length) { + name = ""; + } + + customVariablesPage[4] = ['_pkn', name]; + }; + + /** + * Adds an item (product) that is in the current Cart or in the Ecommerce order. + * This function is called for every item (product) in the Cart or the Order. + * The only required parameter is sku. + * The items are deleted from this JavaScript object when the Ecommerce order is tracked via the method trackEcommerceOrder. + * + * @param string sku (required) Item's SKU Code. This is the unique identifier for the product. + * @param string name (optional) Item's name + * @param string name (optional) Item's category, or array of up to 5 categories + * @param float price (optional) Item's price. If not specified, will default to 0 + * @param float quantity (optional) Item's quantity. If not specified, will default to 1 + */ + this.addEcommerceItem = function (sku, name, category, price, quantity) { + if (sku.length) { + ecommerceItems[sku] = [ sku, name, category, price, quantity ]; + } + }; + + /** + * Tracks an Ecommerce order. + * If the Ecommerce order contains items (products), you must call first the addEcommerceItem() for each item in the order. + * All revenues (grandTotal, subTotal, tax, shipping, discount) will be individually summed and reported in Piwik reports. + * Parameters orderId and grandTotal are required. For others, you can set to false if you don't need to specify them. + * After calling this method, items added to the cart will be removed from this JavaScript object. + * + * @param string|int orderId (required) Unique Order ID. + * This will be used to count this order only once in the event the order page is reloaded several times. + * orderId must be unique for each transaction, even on different days, or the transaction will not be recorded by Piwik. + * @param float grandTotal (required) Grand Total revenue of the transaction (including tax, shipping, etc.) + * @param float subTotal (optional) Sub total amount, typically the sum of items prices for all items in this order (before Tax and Shipping costs are applied) + * @param float tax (optional) Tax amount for this order + * @param float shipping (optional) Shipping amount for this order + * @param float discount (optional) Discounted amount in this order + */ + this.trackEcommerceOrder = function (orderId, grandTotal, subTotal, tax, shipping, discount) { + logEcommerceOrder(orderId, grandTotal, subTotal, tax, shipping, discount); + }; + + /** + * Tracks a Cart Update (add item, remove item, update item). + * On every Cart update, you must call addEcommerceItem() for each item (product) in the cart, including the items that haven't been updated since the last cart update. + * Then you can call this function with the Cart grandTotal (typically the sum of all items' prices) + * Calling this method does not remove from this JavaScript object the items that were added to the cart via addEcommerceItem + * + * @param float grandTotal (required) Items (products) amount in the Cart + */ + this.trackEcommerceCartUpdate = function (grandTotal) { + logEcommerceCartUpdate(grandTotal); + }; + + /** + * Sends a tracking request with custom request parameters. + * Piwik will prepend the hostname and path to Piwik, as well as all other needed tracking request + * parameters prior to sending the request. Useful eg if you track custom dimensions via a plugin. + * + * @param request eg. "param=value¶m2=value2" + * @param customData + * @param callback + * @param pluginMethod + */ + this.trackRequest = function (request, customData, callback, pluginMethod) { + trackCallback(function () { + var fullRequest = getRequest(request, customData, pluginMethod); + sendRequest(fullRequest, configTrackerPause, callback); + }); + }; + + Piwik.trigger('TrackerSetup', [this]); + } + + function TrackerProxy() { + return { + push: apply + }; + } + + /** + * Applies the given methods in the given order if they are present in paq. + * + * @param {Array} paq + * @param {Array} methodsToApply an array containing method names in the order that they should be applied + * eg ['setSiteId', 'setTrackerUrl'] + * @returns {Array} the modified paq array with the methods that were already applied set to undefined + */ + function applyMethodsInOrder(paq, methodsToApply) + { + var appliedMethods = {}; + var index, iterator; + + for (index = 0; index < methodsToApply.length; index++) { + var methodNameToApply = methodsToApply[index]; + appliedMethods[methodNameToApply] = 1; + + for (iterator = 0; iterator < paq.length; iterator++) { + if (paq[iterator] && paq[iterator][0]) { + var methodName = paq[iterator][0]; + + if (methodNameToApply === methodName) { + apply(paq[iterator]); + delete paq[iterator]; + + if (appliedMethods[methodName] > 1) { + logConsoleError('The method ' + methodName + ' is registered more than once in "_paq" variable. Only the last call has an effect. Please have a look at the multiple Piwik trackers documentation: http://developer.piwik.org/guides/tracking-javascript-guide#multiple-piwik-trackers'); + } + + appliedMethods[methodName]++; + } + } + } + } + + return paq; + } + + /************************************************************ + * Constructor + ************************************************************/ + + var applyFirst = ['addTracker', 'disableCookies', 'setTrackerUrl', 'setAPIUrl', 'enableCrossDomainLinking', 'setCookiePath', 'setCookieDomain', 'setDomains', 'setUserId', 'setSiteId', 'enableLinkTracking']; + + function createFirstTracker(piwikUrl, siteId) + { + var tracker = new Tracker(piwikUrl, siteId); + asyncTrackers.push(tracker); + + _paq = applyMethodsInOrder(_paq, applyFirst); + + // apply the queue of actions + for (iterator = 0; iterator < _paq.length; iterator++) { + if (_paq[iterator]) { + apply(_paq[iterator]); + } + } + + // replace initialization array with proxy object + _paq = new TrackerProxy(); + + return tracker; + } + + /************************************************************ + * Proxy object + * - this allows the caller to continue push()'ing to _paq + * after the Tracker has been initialized and loaded + ************************************************************/ + + // initialize the Piwik singleton + addEventListener(windowAlias, 'beforeunload', beforeUnloadHandler, false); + + Date.prototype.getTimeAlias = Date.prototype.getTime; + + /************************************************************ + * Public data and methods + ************************************************************/ + + Piwik = { + initialized: false, + + JSON: JSON_PIWIK, + + /** + * DOM Document related methods + */ + DOM: { + /** + * Adds an event listener to the given element. + * @param element + * @param eventType + * @param eventHandler + * @param useCapture Optional + */ + addEventListener: function (element, eventType, eventHandler, useCapture) { + var captureType = typeof useCapture; + if (captureType === 'undefined') { + useCapture = false; + } + + addEventListener(element, eventType, eventHandler, useCapture); + }, + /** + * Specify a function to execute when the DOM is fully loaded. + * + * If the DOM is already loaded, the function will be executed immediately. + * + * @param function callback + */ + onLoad: trackCallbackOnLoad, + + /** + * Specify a function to execute when the DOM is ready. + * + * If the DOM is already ready, the function will be executed immediately. + * + * @param function callback + */ + onReady: trackCallbackOnReady, + + /** + * Detect whether a node is visible right now. + */ + isNodeVisible: isVisible, + + /** + * Detect whether a node has been visible at some point + */ + isOrWasNodeVisible: content.isNodeVisible + }, + + /** + * Listen to an event and invoke the handler when a the event is triggered. + * + * @param string event + * @param function handler + */ + on: function (event, handler) { + if (!eventHandlers[event]) { + eventHandlers[event] = []; + } + + eventHandlers[event].push(handler); + }, + + /** + * Remove a handler to no longer listen to the event. Must pass the same handler that was used when + * attaching the event via ".on". + * @param string event + * @param function handler + */ + off: function (event, handler) { + if (!eventHandlers[event]) { + return; + } + + var i = 0; + for (i; i < eventHandlers[event].length; i++) { + if (eventHandlers[event][i] === handler) { + eventHandlers[event].splice(i, 1); + } + } + }, + + /** + * Triggers the given event and passes the parameters to all handlers. + * + * @param string event + * @param Array extraParameters + * @param Object context If given the handler will be executed in this context + */ + trigger: function (event, extraParameters, context) { + if (!eventHandlers[event]) { + return; + } + + var i = 0; + for (i; i < eventHandlers[event].length; i++) { + eventHandlers[event][i].apply(context || windowAlias, extraParameters); + } + }, + + /** + * Add plugin + * + * @param string pluginName + * @param Object pluginObj + */ + addPlugin: function (pluginName, pluginObj) { + plugins[pluginName] = pluginObj; + }, + + /** + * Get Tracker (factory method) + * + * @param string piwikUrl + * @param int|string siteId + * @return Tracker + */ + getTracker: function (piwikUrl, siteId) { + if (!isDefined(siteId)) { + siteId = this.getAsyncTracker().getSiteId(); + } + if (!isDefined(piwikUrl)) { + piwikUrl = this.getAsyncTracker().getTrackerUrl(); + } + + return new Tracker(piwikUrl, siteId); + }, + + /** + * Get all created async trackers + * + * @return Tracker[] + */ + getAsyncTrackers: function () { + return asyncTrackers; + }, + + /** + * Adds a new tracker. All sent requests will be also sent to the given siteId and piwikUrl. + * If piwikUrl is not set, current url will be used. + * + * @param null|string piwikUrl If null, will reuse the same tracker URL of the current tracker instance + * @param int|string siteId + * @return Tracker + */ + addTracker: function (piwikUrl, siteId) { + if (!asyncTrackers.length) { + createFirstTracker(piwikUrl, siteId); + } else { + asyncTrackers[0].addTracker(piwikUrl, siteId); + } + }, + + /** + * Get internal asynchronous tracker object. + * + * If no parameters are given, it returns the internal asynchronous tracker object. If a piwikUrl and idSite + * is given, it will try to find an optional + * + * @param string piwikUrl + * @param int|string siteId + * @return Tracker + */ + getAsyncTracker: function (piwikUrl, siteId) { + + var firstTracker; + if (asyncTrackers && asyncTrackers.length && asyncTrackers[0]) { + firstTracker = asyncTrackers[0]; + } else { + return createFirstTracker(piwikUrl, siteId); + } + + if (!siteId && !piwikUrl) { + // for BC and by default we just return the initally created tracker + return firstTracker; + } + + // we look for another tracker created via `addTracker` method + if ((!isDefined(siteId) || null === siteId) && firstTracker) { + siteId = firstTracker.getSiteId(); + } + + if ((!isDefined(piwikUrl) || null === piwikUrl) && firstTracker) { + piwikUrl = firstTracker.getTrackerUrl(); + } + + var tracker, i = 0; + for (i; i < asyncTrackers.length; i++) { + tracker = asyncTrackers[i]; + if (tracker + && String(tracker.getSiteId()) === String(siteId) + && tracker.getTrackerUrl() === piwikUrl) { + + return tracker; + } + } + }, + + /** + * When calling plugin methods via "_paq.push(['...'])" and the plugin is loaded separately because + * piwik.js is not writable then there is a chance that first piwik.js is loaded and later the plugin. + * In this case we would have already executed all "_paq.push" methods and they would not have succeeded + * because the plugin will be loaded only later. In this case, once a plugin is loaded, it should call + * "Piwik.retryMissedPluginCalls()" so they will be executed after all. + * + * @param string piwikUrl + * @param int|string siteId + * @return Tracker + */ + retryMissedPluginCalls: function () { + var missedCalls = missedPluginTrackerCalls; + missedPluginTrackerCalls = []; + var i = 0; + for (i; i < missedCalls.length; i++) { + apply(missedCalls[i]); + } + } + }; + + // Expose Piwik as an AMD module + if (typeof define === 'function' && define.amd) { + define('piwik', [], function () { return Piwik; }); + } + + return Piwik; + }()); +} + +/*!! pluginTrackerHook */ + +(function () { + 'use strict'; + + function hasPaqConfiguration() + { + if ('object' !== typeof _paq) { + return false; + } + // needed to write it this way for jslint + var lengthType = typeof _paq.length; + if ('undefined' === lengthType) { + return false; + } + + return !!_paq.length; + } + + if (window + && 'object' === typeof window.piwikPluginAsyncInit + && window.piwikPluginAsyncInit.length) { + var i = 0; + for (i; i < window.piwikPluginAsyncInit.length; i++) { + if (typeof window.piwikPluginAsyncInit[i] === 'function') { + window.piwikPluginAsyncInit[i](); + } + } + } + + if (window && window.piwikAsyncInit) { + window.piwikAsyncInit(); + } + + if (!window.Piwik.getAsyncTrackers().length) { + // we only create an initial tracker when no other async tracker has been created yet in piwikAsyncInit() + if (hasPaqConfiguration()) { + // we only create an initial tracker if there is a configuration for it via _paq. Otherwise + // Piwik.getAsyncTrackers() would return unconfigured trackers + window.Piwik.addTracker(); + } else { + _paq = {push: function (args) { + if (console !== undefined && console && console.error) { + console.error('_paq.push() was used but Piwik tracker was not initialized before the piwik.js file was loaded. Make sure to configure the tracker via _paq.push before loading piwik.js. Alternatively, you can create a tracker via Piwik.addTracker() manually and then use _paq.push but it may not fully work as tracker methods may not be executed in the correct order.', args); + } + }}; + } + } + + window.Piwik.trigger('PiwikInitialized', []); + window.Piwik.initialized = true; +}()); + + +/*jslint sloppy: true */ +(function () { + var jsTrackerType = (typeof AnalyticsTracker); + if (jsTrackerType === 'undefined') { + AnalyticsTracker = window.Piwik; + } +}()); +/*jslint sloppy: false */ + +/************************************************************ + * Deprecated functionality below + * Legacy piwik.js compatibility ftw + ************************************************************/ + +/* + * Piwik globals + * + * var piwik_install_tracker, piwik_tracker_pause, piwik_download_extensions, piwik_hosts_alias, piwik_ignore_classes; + */ +/*global piwik_log:true */ +/*global piwik_track:true */ + +/** + * Track page visit + * + * @param string documentTitle + * @param int|string siteId + * @param string piwikUrl + * @param mixed customData + */ +if (typeof piwik_log !== 'function') { + piwik_log = function (documentTitle, siteId, piwikUrl, customData) { + 'use strict'; + + function getOption(optionName) { + try { + if (window['piwik_' + optionName]) { + return window['piwik_' + optionName]; + } + } catch (ignore) { } + + return; // undefined + } + + // instantiate the tracker + var option, + piwikTracker = window.Piwik.getTracker(piwikUrl, siteId); + + // initialize tracker + piwikTracker.setDocumentTitle(documentTitle); + piwikTracker.setCustomData(customData); + + // handle Piwik globals + option = getOption('tracker_pause'); + + if (option) { + piwikTracker.setLinkTrackingTimer(option); + } + + option = getOption('download_extensions'); + + if (option) { + piwikTracker.setDownloadExtensions(option); + } + + option = getOption('hosts_alias'); + + if (option) { + piwikTracker.setDomains(option); + } + + option = getOption('ignore_classes'); + + if (option) { + piwikTracker.setIgnoreClasses(option); + } + + // track this page view + piwikTracker.trackPageView(); + + // default is to install the link tracker + if (getOption('install_tracker')) { + + /** + * Track click manually (function is defined below) + * + * @param string sourceUrl + * @param int|string siteId + * @param string piwikUrl + * @param string linkType + */ + piwik_track = function (sourceUrl, siteId, piwikUrl, linkType) { + piwikTracker.setSiteId(siteId); + piwikTracker.setTrackerUrl(piwikUrl); + piwikTracker.trackLink(sourceUrl, linkType); + }; + + // set-up link tracking + piwikTracker.enableLinkTracking(); + } + }; +} + +/*! @license-end */ diff --git a/main.go b/main.go new file mode 100644 index 0000000..c03bf2b --- /dev/null +++ b/main.go @@ -0,0 +1,512 @@ +package main + +import ( + "encoding/json" + "github.com/davecgh/go-spew/spew" + "net/http" + "strconv" + "time" + "log" +) + +func main() { + + http.HandleFunc("/piwik.php", func(w http.ResponseWriter, r *http.Request) { + pr := ParseV3(r) + spew.Dump(pr) + }) + http.Handle("/", http.FileServer(http.Dir("assets"))) + http.ListenAndServe(":8080", nil) +} + +type V3Visit struct { + SiteID string //idsite + Record bool //rec + URL string //url + ActionName string //action_anem + VisitorID string //_id + Referrer string //urlref + CustomVars map[string]interface{} //_cvar + VisitsCount string //_idvc + ViewTime time.Time //_viewts + VisitorFirstVisitTime time.Time //_idts + CampaignName string //_rcn + CampaignKeyword string //_rck + Resolution string //res + LocalHour string //h + LocalMinute string //m + LocalSeconds string //s + LocalTimeUTC time.Time + Plugins struct { + Flash bool //fla + Java bool //java + Director bool //dir + Quicktime bool //qt + RealPlayer bool //realp + PDF bool //pdf + WindowsMedia bool //wma + Gears bool //gears + Silverlight bool //ag + } + SupportsCookies bool //cookie + UserAgent string //ua + Language string //lang + UserID string //uid + CustomUserID string //cid + NewVisit bool //new_visit + + PageCustomVars map[string]interface{} //cvar + Link string //link + Download string //download + Search string //search + SearchCategory string //search_cat + SearchCount string //search_count + PageViewID string //pv_id + GoalID string //idgoal + Revenue string //revenue + GenerationTime string //gt_ms + Characterset string //cs + + EventCategory string //e_c + EventAction string //e_a + EventName string //e_n + EventValue string //e_v + + ContentName string //c_n + ContentPiece string //c_p + ContentTarget string //c_t + ContentInteraction string //c_i + + ECommerceID string // ec_id + ECommerceItems [][]string // ec_items + ECommerceSubTotal string // ec_st + ECommerceTax string // ec_tx + ECommerceShipping string // ec_sh + ECommerceDiscount string // ec_dt + ECommerceTime time.Time // ec_ts + + TokenAuth string //token_auth + CustomIP string //cip + CustomDateTime string //cdt + CustomCountry string //country + CustomRegion string //region + CustomCity string //city + CustomLatitude string //lat + CustomLongitude string //long + + MediaID string // ma_id + MediaTitle string // ma_ti + MediaResource string // ma_re + MediaType string // ma_mt + MediaPlayerName string // ma_pn + MediaSecondsPlayingTime string // ma_st + MediaLength string // ma_le + MediaProgress string // ma_ps + MediaTimeUntilPlay string // ma_ttp + MediaWidth string // ma_w + MediaHeight string // ma_h + MediaFullscreen bool // ma_fs + + SendImage string //send_image +} + +func ParseV3(r *http.Request) *V3Visit { + /* + https://developer.piwik.org/api-reference/tracking-api + */ + + v3 := new(V3Visit) + // (required) — The ID of the website we're tracking a visit/action for. + v3.SiteID = r.URL.Query().Get("idsite") + + // (required) — Required for tracking, must be set to one, eg, &rec=1. + if r.URL.Query().Get("rec") == "1" { + v3.Record = true + } else { + v3.Record = false + } + + // (required) — The full URL for the current action. + v3.URL = r.URL.Query().Get("url") + + // (recommended) — The title of the action being tracked. + // It is possible to use slashes / to set one or several categories for this action. + // For example, Help / Feedback will create the Action Feedback in the category Help. + v3.ActionName = r.URL.Query().Get("action_name") + + // (recommended) — The unique visitor ID, must be a 16 characters hexadecimal string. + // Every unique visitor must be assigned a different ID and this ID must not change after it is assigned. + // If this value is not set Piwik will still track visits, but the unique visitors metric might be less accurate. + v3.VisitorID = r.URL.Query().Get("_id") + + /* + r.URL.Query().Get("rand") // (recommended) — Meant to hold a random value that is generated before each request. Using it helps avoid the tracking request being cached by the browser or a proxy. + r.URL.Query().Get("apiv") // (recommended) — The parameter &apiv=1 defines the api version to use (currently always set to 1) + */ + + // The full HTTP Referrer URL. + // This value is used to determine how someone got to your website (ie, through a website, search engine or campaign). + v3.Referrer = r.URL.Query().Get("urlref") + + // Visit scope custom variables. + // This is a JSON encoded string of the custom variable array (see below for an example value). + if e := json.Unmarshal([]byte(r.URL.Query().Get("_cvar")), v3.CustomVars);e != nil { + log.Println(e) + } + + // The current count of visits for this visitor. + // To set this value correctly, it would be required to store the value for each visitor in your application (using sessions or persisting in a database). + // Then you would manually increment the counts by one on each new visit or "session", depending on how you choose to define a visit. + // This value is used to populate the report Visitors > Engagement > Visits by visit number. + v3.VisitsCount = r.URL.Query().Get("_idvc") + + // The UNIX timestamp of this visitor's previous visit. This parameter is used to populate the report Visitors > Engagement > Visits by days since last visit. + v3.ViewTime = stringToTime(r.URL.Query().Get("_viewts")) + + // The UNIX timestamp of this visitor's first visit. This could be set to the date where the user first started using your software/app, or when he/she created an account. + // This parameter is used to populate the Goals > Days to Conversion report. + v3.VisitorFirstVisitTime = stringToTime(r.URL.Query().Get("_idts")) + + // The Campaign name (see Tracking Campaigns). + // Used to populate the Referrers > Campaigns report. + // Note: this parameter will only be used for the first pageview of a visit. + v3.CampaignName = r.URL.Query().Get("_rcn") + + // The Campaign Keyword (see Tracking Campaigns). + // Used to populate the Referrers > Campaigns report (clicking on a campaign loads all keywords for this campaign). + // Note: this parameter will only be used for the first pageview of a visit. + v3.CampaignKeyword = r.URL.Query().Get("_rck") + + // The resolution of the device the visitor is using, eg 1280x1024. + v3.Resolution = r.URL.Query().Get("res") + + // The current hour (local time). + v3.LocalHour = r.URL.Query().Get("h") + + // The current minute (local time). + v3.LocalMinute = r.URL.Query().Get("m") + + // The current second (local time). + v3.LocalSeconds = r.URL.Query().Get("s") + + v3.LocalTimeUTC = time.Date(time.Now().Year(), time.Now().Month(), time.Now().Day(), atoi(r.URL.Query().Get("h")), atoi(r.URL.Query().Get("m")), atoi(r.URL.Query().Get("s")), 0, time.UTC) + + // plugins used by the visitor can be specified by setting the following parameters to 1 + + // Flash + if r.URL.Query().Get("fla") == "1" { + v3.Plugins.Flash = true + } + + // Java + if r.URL.Query().Get("java") == "1" { + v3.Plugins.Java = true + } + + // Director + if r.URL.Query().Get("dir") == "1" { + v3.Plugins.Director = true + } + + // Quicktime + if r.URL.Query().Get("qt") == "1" { + v3.Plugins.Quicktime = true + } + + // Real Player + if r.URL.Query().Get("realp") == "1" { + v3.Plugins.RealPlayer = true + } + + // PDF + if r.URL.Query().Get("pdf") == "1" { + v3.Plugins.PDF = true + } + + // Windows Media + if r.URL.Query().Get("wma") == "1" { + v3.Plugins.WindowsMedia = true + } + + // Gears + if r.URL.Query().Get("gears") == "1" { + v3.Plugins.Gears = true + } + + // Silverlight + if r.URL.Query().Get("ag") == "1" { + v3.Plugins.Silverlight = true + } + + // when set to 1, the visitor's client is known to support cookies. + if r.URL.Query().Get("cookie") == "1" { + v3.SupportsCookies = true + } + + // An override value for the User-Agent HTTP header field. The user agent is used to detect the operating system and browser used. + if r.URL.Query().Get("ua") != "" { + v3.UserAgent = r.URL.Query().Get("ua") + } else { + v3.UserAgent = r.UserAgent() + } + + // An override value for the Accept-Language HTTP header field. This value is used to detect the visitor's country if GeoIP is not enabled. + if r.URL.Query().Get("lang") != "" { + v3.Language = r.URL.Query().Get("lang") + } else { + v3.Language = r.Header.Get("Accept-Language") + } + + // defines the User ID for this request. + // User ID is any non empty unique string identifying the user (such as an email address or a username). + // To access this value, users must be logged-in in your system so you can fetch this user ID from your system, and pass it to Piwik. + // The User ID appears in the visitor log, the Visitor profile, and you can Segment reports for one or several User ID (userId segment). + // When specified, the User ID will be "enforced". + // This means that if there is no recent visit with this User ID, a new one will be created. + // If a visit is found in the last 30 minutes with your specified User ID, then the new action will be recorded to this existing visit. + v3.UserID = r.URL.Query().Get("uid") + + // defines the visitor ID for this request. + // You must set this value to exactly a 16 character hexadecimal string (containing only characters 01234567890abcdefABCDEF). + // We recommended to set the User ID via uid rather than use this cid + v3.CustomUserID = r.URL.Query().Get("cid") + + // If set to 1, will force a new visit to be created for this action. This feature is also available in JavaScript. + if r.URL.Query().Get("new_visit") == "1" { + v3.NewVisit = true + } + + /* + // ? scopes? + dimension := make(map[string]string) + for k, v := range r.URL.Query() { + if strings.HasPrefix(k, "dimension") { + dimension[strings.TrimPrefix(k, "dimension")] = v + } + } + */ + + /* + Optional Action info (measure Page view, Outlink, Download, Site search) + */ + + // Page scope custom variables. This is a JSON encoded string of the custom variable array (see below for an example value). + json.Unmarshal([]byte(r.URL.Query().Get("cvar")), v3.PageCustomVars) + + // An external URL the user has opened. + // Used for tracking outlink clicks. + // We recommend to also set the url parameter to this same value. + v3.Link = r.URL.Query().Get("link") + + // URL of a file the user has downloaded. + // Used for tracking downloads. + // We recommend to also set the url parameter to this same value. + v3.Download = r.URL.Query().Get("download") + + // The Site Search keyword. + // When specified, the request will not be tracked as a normal pageview but will instead be tracked as a Site Search request. + v3.Search = r.URL.Query().Get("search") + + // when search is specified, you can optionally specify a search category with this parameter. + v3.SearchCategory = r.URL.Query().Get("search_cat") + + // when search is specified, we also recommend to set the search_count to the number of search results displayed on the results page. + // When keywords are tracked with &search_count=0 they will appear in the "No Result Search Keyword" report. + v3.SearchCount = r.URL.Query().Get("search_count") + + // Accepts a six character unique ID that identifies which actions were performed on a specific page view. + // When a page was viewed, all following tracking requests (such as events) during that page view should use the same pageview ID. + // Once another page was viewed a new unique ID should be generated. + // Use [0-9a-Z] as possible characters for the unique ID. + v3.PageViewID = r.URL.Query().Get("pv_id") + + // If specified, the tracking request will trigger a conversion for the goal of the website being tracked with this ID. + v3.GoalID = r.URL.Query().Get("idgoal") + + // A monetary value that was generated as revenue by this goal conversion. + // Only used if idgoal is specified in the request. + v3.Revenue = r.URL.Query().Get("revenue") + + // The amount of time it took the server to generate this action, in milliseconds. + // This value is used to process the Page speed report Avg. generation time column in the Page URL and Page Title reports, + // as well as a site wide running average of the speed of your server. + // Note: when using the JavaScript tracker this value is set to the time for server to generate response + the time for client to download response. + v3.GenerationTime = r.URL.Query().Get("gt_ms") + + // The charset of the page being tracked. + // Specify the charset if the data you send to Piwik is encoded in a different character set than the default utf-8. + v3.Characterset = r.URL.Query().Get("cs") + + /* + Optional Event Tracking info + */ + + // The event category. Must not be empty. (eg. Videos, Music, Games...) + v3.EventCategory = r.URL.Query().Get("e_c") + + // The event action. Must not be empty. (eg. Play, Pause, Duration, Add Playlist, Downloaded, Clicked...) + v3.EventAction = r.URL.Query().Get("e_a") + + // The event name. (eg. a Movie name, or Song name, or File name...) + v3.EventName = r.URL.Query().Get("e_n") + + // The event value. Must be a float or integer value (numeric), not a string. + v3.EventValue = r.URL.Query().Get("e_v") + + /* + Optional Content Tracking info + */ + + // The name of the content. For instance 'Ad Foo Bar' + v3.ContentName = r.URL.Query().Get("c_n") + // The actual content piece. For instance the path to an image, video, audio, any text + v3.ContentPiece = r.URL.Query().Get("c_p") + // The target of the content. For instance the URL of a landing page + v3.ContentTarget = r.URL.Query().Get("c_t") + // The name of the interaction with the content. For instance a 'click' + v3.ContentInteraction = r.URL.Query().Get("c_i") + + // Optional Ecommerce info + // you must set &idgoal=0 in the request to track an ecommerce interaction: cart update or an ecommerce order. + if r.URL.Query().Get("idgoal") == "0" { + // The unique string identifier for the ecommerce order (required when tracking an ecommerce order) + v3.ECommerceID = r.URL.Query().Get("ec_id") + + // Items in the Ecommerce order. + // This is a JSON encoded array of items. Each item is an array with the following info in this order: item sku, item name, item category, item price, item quantity. + json.Unmarshal([]byte(r.URL.Query().Get("ec_items")), v3.ECommerceItems) + + // The grand total for the ecommerce order (required when tracking an ecommerce order) + v3.Revenue = r.URL.Query().Get("revenue") + + // The sub total of the order; excludes shipping. + v3.ECommerceSubTotal = r.URL.Query().Get("ec_st") + + // Tax Amount of the order + v3.ECommerceTax = r.URL.Query().Get("ec_tx") + + // Shipping cost of the Order + v3.ECommerceShipping = r.URL.Query().Get("ec_sh") + + // Discount offered + v3.ECommerceDiscount = r.URL.Query().Get("ec_dt") + + // The UNIX timestamp of this customer's last ecommerce order. + // This value is used to process the "Days since last order" report. + v3.ECommerceTime = stringToTime(r.URL.Query().Get("_ects")) + } + + /* + Other parameters (require authentication via token_auth) + */ + + // 32 character authorization key used to authenticate the API request. + v3.TokenAuth = r.URL.Query().Get("token_auth") + + // Override value for the visitor IP (both IPv4 and IPv6 notations supported). + v3.CustomIP = r.URL.Query().Get("cip") + + // Override for the datetime of the request (normally the current time is used). + // This can be used to record visits and page views in the past. + // The expected format is either a datetime such as: 2011-04-05 00:11:42 (remember to URL encode the value!), or a valid UNIX timestamp such as 1301919102. + // The datetime must be sent in UTC timezone. + // Note: if you record data in the past, you will need to force Piwik to re-process reports for the past dates. + // If you set cdt to a datetime older than 24 hours then token_auth must be set. + // If you set cdt with a datetime in the last 24 hours then you don't need to pass token_auth. + v3.CustomDateTime = r.URL.Query().Get("cdt") + + // An override value for the country. Should be set to the two letter country code of the visitor (lowercase), eg fr, de, us. + v3.CustomCountry = r.URL.Query().Get("country") + + // An override value for the region. Should be set to the two letter region code as defined by MaxMind's GeoIP databases. See here for a list of them for every country (the region codes are located in the second column, to the left of the region name and to the right of the country code). + v3.CustomRegion = r.URL.Query().Get("region") + + // An override value for the city. The name of the city the visitor is located in, eg, Tokyo. + v3.CustomCity = r.URL.Query().Get("city") + + // An override value for the visitor's latitude, eg 22.456. + v3.CustomLatitude = r.URL.Query().Get("lat") + + // An override value for the visitor's longitude, eg 22.456. + v3.CustomLongitude = r.URL.Query().Get("long") + + /* + Media Analytics parameters + https://developer.piwik.org/guides/media-analytics/custom-player#media-analytics-http-tracking-api-reference + */ + + // A unique id that is always the same while playing a media. As soon as the played media changes (new video or audio started), this ID has to change. + v3.MediaID = r.URL.Query().Get("ma_id") + + // The name / title of the media. + v3.MediaTitle = r.URL.Query().Get("ma_ti") + + // The URL of the media resource. + v3.MediaResource = r.URL.Query().Get("ma_re") + + // video or audio depending on the type of the media. + v3.MediaType = r.URL.Query().Get("ma_mt") + + // The name of the media player, for example html5. + v3.MediaPlayerName = r.URL.Query().Get("ma_pn") + + // The time in seconds for how long a user has been playing this media. + // This number should typically increase when you send a media tracking request. + // It should be 0 if the media was only visible/impressed but not played. + // Do not increase this number when a media is paused. + v3.MediaSecondsPlayingTime = r.URL.Query().Get("ma_st") + + // The duration (the length) of the media in seconds. For example if a video is 90 seconds long, the value should be 90. + v3.MediaLength = r.URL.Query().Get("ma_le") + + // The progress / current position within the media. Defines basically at which position within the total length the user is currently playing. + v3.MediaProgress = r.URL.Query().Get("ma_ps") + + // Defines after how many seconds the user has started playing this media. + // For example a user might have seen the poster of the video for 30 seconds before a user actually pressed the play button. + v3.MediaTimeUntilPlay = r.URL.Query().Get("ma_ttp") + + // The resolution width of the media in pixels. Only recommended to be set for videos. + v3.MediaWidth = r.URL.Query().Get("ma_w") + + // The resolution height of the media in pixels. Only recommended to be set for videos. + v3.MediaHeight = r.URL.Query().Get("ma_h") + + // Should be 0 or 1 and defines whether the media is currently viewed in full screen. Only recommended to be set for videos. + switch r.URL.Query().Get("ma_fs") { + case "0": + v3.MediaFullscreen = false + case "1": + v3.MediaFullscreen = true + default: + v3.MediaFullscreen = false + } + + // If set to 0 (send_image=0) Piwik will respond with a HTTP 204 response code instead of a GIF image. + // This improves performance and can fix errors if images are not allowed to be obtained directly (eg Chrome Apps). + // Available since Piwik 2.10.0 + v3.SendImage = r.URL.Query().Get("send_image") + + return v3 + + /* + r.URL.Query().Get("") // + */ + +} + +func stringToTime(s string) time.Time { + i, err := strconv.ParseInt(s, 10, 64) + if err != nil { + return time.Time{} + } + return time.Unix(i, 0) +} + +func atoi(a string) int { + i, err := strconv.Atoi(a) + if err != nil { + panic(err) + } + return i +}