| /******************************************************************************* |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| *******************************************************************************/ |
| package org.apache.ofbiz.marketing.tracking; |
| |
| import java.sql.Timestamp; |
| import java.util.LinkedList; |
| import java.util.List; |
| |
| import javax.servlet.http.Cookie; |
| import javax.servlet.http.HttpServletRequest; |
| import javax.servlet.http.HttpServletResponse; |
| import javax.servlet.http.HttpSession; |
| |
| import org.apache.ofbiz.base.util.Debug; |
| import org.apache.ofbiz.base.util.UtilDateTime; |
| import org.apache.ofbiz.base.util.UtilMisc; |
| import org.apache.ofbiz.base.util.UtilValidate; |
| import org.apache.ofbiz.webapp.stats.VisitHandler; |
| import org.apache.ofbiz.webapp.website.WebSiteWorker; |
| import org.apache.ofbiz.entity.Delegator; |
| import org.apache.ofbiz.entity.GenericEntityException; |
| import org.apache.ofbiz.entity.GenericValue; |
| import org.apache.ofbiz.entity.util.EntityQuery; |
| import org.apache.ofbiz.entity.util.EntityUtilProperties; |
| import org.apache.ofbiz.product.category.CategoryWorker; |
| |
| /** |
| * Events used for maintaining TrackingCode related information |
| */ |
| public class TrackingCodeEvents { |
| |
| public static final String module = TrackingCodeEvents.class.getName(); |
| |
| /** If TrackingCode monitoring is desired this event should be added to the list |
| * of events that run on every request. This event looks for the parameter |
| * <code>autoTrackingCode</code> or a shortened version: <code>atc</code>. |
| */ |
| public static String checkTrackingCodeUrlParam(HttpServletRequest request, HttpServletResponse response) { |
| String trackingCodeId = request.getParameter("autoTrackingCode"); |
| if (UtilValidate.isEmpty(trackingCodeId)) trackingCodeId = request.getParameter("atc"); |
| |
| if (UtilValidate.isNotEmpty(trackingCodeId)) { |
| //tracking code is specified on the request, get the TrackingCode value and handle accordingly |
| Delegator delegator = (Delegator) request.getAttribute("delegator"); |
| GenericValue trackingCode; |
| try { |
| trackingCode = EntityQuery.use(delegator).from("TrackingCode").where("trackingCodeId", trackingCodeId).cache().queryOne(); |
| } catch (GenericEntityException e) { |
| Debug.logError(e, "Error looking up TrackingCode with trackingCodeId [" + trackingCodeId + "], ignoring this trackingCodeId", module); |
| return "error"; |
| } |
| |
| if (trackingCode == null) { |
| Debug.logError("TrackingCode not found for trackingCodeId [" + trackingCodeId + "], ignoring this trackingCodeId.", module); |
| //this return value will be ignored, but we'll designate this as an error anyway |
| return "error"; |
| } |
| |
| return processTrackingCode(trackingCode, request, response, "TKCDSRC_URL_PARAM"); |
| } else { |
| return "success"; |
| } |
| } |
| |
| /** If TrackingCode monitoring is desired this event should be added to the list |
| * of events that run on every request. This event looks for the parameter |
| * <code>ptc</code> and handles the value as a Partner Managed Tracking Code. |
| * |
| * If the specified trackingCodeId exists then it is used as is, otherwise a new one |
| * is created with the ptc value as the trackingCodeId. The values for the fields of |
| * the new TrackingCode can come from one of two places: if a <code>dtc</code> parameter |
| * is included the value will be used to lookup a TrackingCode with default values, |
| * otherwise the default trackingCodeId will be looked up in the <code>partner.trackingCodeId.default</code> |
| * in the <code>general.properties</code> file. If that is still not found just use an empty TrackingCode. |
| */ |
| public static String checkPartnerTrackingCodeUrlParam(HttpServletRequest request, HttpServletResponse response) { |
| String trackingCodeId = request.getParameter("ptc"); |
| |
| if (UtilValidate.isNotEmpty(trackingCodeId)) { |
| //partner managed tracking code is specified on the request |
| Delegator delegator = (Delegator) request.getAttribute("delegator"); |
| GenericValue trackingCode; |
| try { |
| trackingCode = EntityQuery.use(delegator).from("TrackingCode").where("trackingCodeId", trackingCodeId).cache().queryOne(); |
| } catch (GenericEntityException e) { |
| Debug.logError(e, "Error looking up TrackingCode with trackingCodeId [" + trackingCodeId + "], ignoring this trackingCodeId", module); |
| return "error"; |
| } |
| |
| if (trackingCode == null) { |
| //create new TrackingCode with default values from a "dtc" parameter or from a properties file |
| |
| String dtc = request.getParameter("dtc"); |
| if (UtilValidate.isEmpty(dtc)) { |
| dtc = EntityUtilProperties.getPropertyValue("general", "partner.trackingCodeId.default", delegator); |
| } |
| if (UtilValidate.isNotEmpty(dtc)) { |
| GenericValue defaultTrackingCode = null; |
| try { |
| defaultTrackingCode = EntityQuery.use(delegator).from("TrackingCode").where("trackingCodeId", dtc).cache().queryOne(); |
| } catch (GenericEntityException e) { |
| Debug.logError(e, "Error looking up Default values TrackingCode with trackingCodeId [" + dtc + "], not using the dtc value for new TrackingCode defaults", module); |
| } |
| |
| if (defaultTrackingCode != null) { |
| defaultTrackingCode.set("trackingCodeId", trackingCodeId); |
| defaultTrackingCode.set("trackingCodeTypeId", "PARTNER_MGD"); |
| //null out userLogin fields, no use tracking to customer, or is there?; set dates to current |
| defaultTrackingCode.set("createdDate", UtilDateTime.nowTimestamp()); |
| defaultTrackingCode.set("createdByUserLogin", null); |
| defaultTrackingCode.set("lastModifiedDate", UtilDateTime.nowTimestamp()); |
| defaultTrackingCode.set("lastModifiedByUserLogin", null); |
| |
| trackingCode = defaultTrackingCode; |
| try { |
| trackingCode.create(); |
| } catch (GenericEntityException e) { |
| Debug.logError(e, "Error creating new Partner TrackingCode with trackingCodeId [" + trackingCodeId + "], ignoring this trackingCodeId", module); |
| return "error"; |
| } |
| } |
| } |
| |
| //if trackingCode is still null then the defaultTrackingCode thing didn't work out, use empty TrackingCode |
| if (trackingCode == null) { |
| trackingCode = delegator.makeValue("TrackingCode"); |
| trackingCode.set("trackingCodeId", trackingCodeId); |
| trackingCode.set("trackingCodeTypeId", "PARTNER_MGD"); |
| //leave userLogin fields empty, no use tracking to customer, or is there?; set dates to current |
| trackingCode.set("createdDate", UtilDateTime.nowTimestamp()); |
| trackingCode.set("lastModifiedDate", UtilDateTime.nowTimestamp()); |
| |
| //use nearly unlimited trackable lifetime: 10 billion seconds, 310 years |
| trackingCode.set("trackableLifetime", Long.valueOf(10000000000L)); |
| //use 2592000 seconds as billable lifetime: equals 1 month |
| trackingCode.set("billableLifetime", Long.valueOf(2592000)); |
| |
| trackingCode.set("comments", "This TrackingCode has default values because no default TrackingCode could be found."); |
| |
| Debug.logWarning("No default TrackingCode record was found, using a TrackingCode with hard coded default values: " + trackingCode, module); |
| |
| try { |
| trackingCode.create(); |
| } catch (GenericEntityException e) { |
| Debug.logError(e, "Error creating new Partner TrackingCode with trackingCodeId [" + trackingCodeId + "], ignoring this trackingCodeId", module); |
| return "error"; |
| } |
| } |
| } |
| |
| return processTrackingCode(trackingCode, request, response, "TKCDSRC_URL_PARAM"); |
| } else { |
| return "success"; |
| } |
| } |
| |
| public static String processTrackingCode(GenericValue trackingCode, HttpServletRequest request, HttpServletResponse response, String sourceEnumId) { |
| Delegator delegator = (Delegator) request.getAttribute("delegator"); |
| String trackingCodeId = trackingCode.getString("trackingCodeId"); |
| |
| //check effective dates |
| java.sql.Timestamp nowStamp = UtilDateTime.nowTimestamp(); |
| if (trackingCode.get("fromDate") != null && nowStamp.before(trackingCode.getTimestamp("fromDate"))) { |
| if (Debug.infoOn()) Debug.logInfo("The TrackingCode with ID [" + trackingCodeId + "] has not yet gone into effect, ignoring this trackingCodeId", module); |
| return "success"; |
| } |
| if (trackingCode.get("thruDate") != null && nowStamp.after(trackingCode.getTimestamp("thruDate"))) { |
| if (Debug.infoOn()) Debug.logInfo("The TrackingCode with ID [" + trackingCodeId + "] has expired, ignoring this trackingCodeId", module); |
| return "success"; |
| } |
| |
| //persist that info by associating with the current visit |
| GenericValue visit = VisitHandler.getVisit(request.getSession()); |
| if (visit != null) { |
| GenericValue trackingCodeVisit = delegator.makeValue("TrackingCodeVisit", |
| UtilMisc.toMap("trackingCodeId", trackingCodeId, "visitId", visit.get("visitId"), |
| "fromDate", UtilDateTime.nowTimestamp(), "sourceEnumId", sourceEnumId)); |
| try { |
| trackingCodeVisit.create(); |
| } catch (GenericEntityException e) { |
| Debug.logError(e, "Error while saving TrackingCodeVisit", module); |
| } |
| } |
| |
| |
| // write trackingCode cookies with the value set to the trackingCodeId |
| // NOTE: just write these cookies and if others exist from other tracking codes they will be overwritten, ie only keep the newest |
| |
| // load the properties from the website entity |
| String cookieDomain = null; |
| |
| String webSiteId = WebSiteWorker.getWebSiteId(request); |
| if (webSiteId != null) { |
| try { |
| GenericValue webSite = EntityQuery.use(delegator).from("WebSite").where("webSiteId", webSiteId).cache().queryOne(); |
| if (webSite != null) { |
| cookieDomain = webSite.getString("cookieDomain"); |
| } |
| } catch (GenericEntityException e) { |
| Debug.logWarning(e, "Problems with WebSite entity; using global default cookie domain", module); |
| } |
| } |
| |
| if (cookieDomain == null) { |
| cookieDomain = EntityUtilProperties.getPropertyValue("url", "cookie.domain", "", delegator); |
| } |
| |
| // if trackingCode.trackableLifetime not null and is > 0 write a trackable cookie with name in the form: TKCDT_{trackingCode.trackingCodeTypeId} and timeout will be trackingCode.trackableLifetime |
| Long trackableLifetime = trackingCode.getLong("trackableLifetime"); |
| if (trackableLifetime != null && (trackableLifetime.longValue() > 0 || trackableLifetime.longValue() == -1)) { |
| Cookie trackableCookie = new Cookie("TKCDT_" + trackingCode.getString("trackingCodeTypeId"), trackingCode.getString("trackingCodeId")); |
| if (trackableLifetime.longValue() > 0) trackableCookie.setMaxAge(trackableLifetime.intValue()); |
| trackableCookie.setPath("/"); |
| if (cookieDomain.length() > 0) trackableCookie.setDomain(cookieDomain); |
| response.addCookie(trackableCookie); |
| } |
| |
| // if trackingCode.billableLifetime not null and is > 0 write a billable cookie with name in the form: TKCDB_{trackingCode.trackingCodeTypeId} and timeout will be trackingCode.billableLifetime |
| Long billableLifetime = trackingCode.getLong("billableLifetime"); |
| if (billableLifetime != null && (billableLifetime.longValue() > 0 || billableLifetime.longValue() == -1)) { |
| Cookie billableCookie = new Cookie("TKCDB_" + trackingCode.getString("trackingCodeTypeId"), trackingCode.getString("trackingCodeId")); |
| if (billableLifetime.longValue() > 0) billableCookie.setMaxAge(billableLifetime.intValue()); |
| billableCookie.setPath("/"); |
| if (cookieDomain.length() > 0) billableCookie.setDomain(cookieDomain); |
| response.addCookie(billableCookie); |
| } |
| |
| // if site id exist in cookies then it is not required to create it, if exist with different site then create it |
| int siteIdCookieAge = (60 * 60 * 24 * 365); // should this be configurable? |
| String siteId = request.getParameter("siteId"); |
| if (UtilValidate.isNotEmpty(siteId)) { |
| String visitorSiteIdCookieName = "Ofbiz.TKCD.SiteId"; |
| String visitorSiteId = null; |
| // first try to get the current ID from the visitor cookie |
| javax.servlet.http.Cookie[] cookies = request.getCookies(); |
| if (cookies != null) { |
| for (int i = 0; i < cookies.length; i++) { |
| if (cookies[i].getName().equals(visitorSiteIdCookieName)) { |
| visitorSiteId = cookies[i].getValue(); |
| break; |
| } |
| } |
| } |
| |
| if (visitorSiteId == null || (visitorSiteId != null && !visitorSiteId.equals(siteId))) { |
| // if trackingCode.siteId is not null write a trackable cookie with name in the form: Ofbiz.TKCSiteId and timeout will be 60 * 60 * 24 * 365 |
| Cookie siteIdCookie = new Cookie("Ofbiz.TKCD.SiteId" ,siteId); |
| siteIdCookie.setMaxAge(siteIdCookieAge); |
| siteIdCookie.setPath("/"); |
| if (cookieDomain.length() > 0) siteIdCookie.setDomain(cookieDomain); |
| response.addCookie(siteIdCookie); |
| // if trackingCode.siteId is not null write a trackable cookie with name in the form: Ofbiz.TKCSiteId and timeout will be 60 * 60 * 24 * 365 |
| Cookie updatedTimeStampCookie = new Cookie("Ofbiz.TKCD.UpdatedTimeStamp" ,UtilDateTime.nowTimestamp().toString()); |
| updatedTimeStampCookie.setMaxAge(siteIdCookieAge); |
| updatedTimeStampCookie.setPath("/"); |
| if (cookieDomain.length() > 0) updatedTimeStampCookie.setDomain(cookieDomain); |
| response.addCookie(updatedTimeStampCookie); |
| } |
| } |
| |
| // if we have overridden logo, css and/or catalogId set some session attributes |
| HttpSession session = request.getSession(); |
| String overrideLogo = trackingCode.getString("overrideLogo"); |
| if (overrideLogo != null) |
| session.setAttribute("overrideLogo", overrideLogo); |
| String overrideCss = trackingCode.getString("overrideCss"); |
| if (overrideCss != null) |
| session.setAttribute("overrideCss", overrideCss); |
| String prodCatalogId = trackingCode.getString("prodCatalogId"); |
| if (UtilValidate.isNotEmpty(prodCatalogId)) { |
| session.setAttribute("CURRENT_CATALOG_ID", prodCatalogId); |
| CategoryWorker.setTrail(request, new LinkedList()); |
| } |
| |
| // if forward/redirect is needed, do a response.sendRedirect and return null to tell the control servlet to not do any other requests/views |
| String redirectUrl = trackingCode.getString("redirectUrl"); |
| if (UtilValidate.isNotEmpty(redirectUrl)) { |
| try { |
| response.sendRedirect(redirectUrl); |
| } catch (java.io.IOException e) { |
| Debug.logError(e, "Could not redirect as requested in the trackingCode to: " + redirectUrl, module); |
| } |
| return null; |
| } |
| |
| return "success"; |
| } |
| |
| /** If attaching TrackingCode Cookies to the visit is desired this event should be added to the list |
| * of events that run on the first hit in a visit. |
| */ |
| public static String checkTrackingCodeCookies(HttpServletRequest request, HttpServletResponse response) { |
| Delegator delegator = (Delegator) request.getAttribute("delegator"); |
| java.sql.Timestamp nowStamp = UtilDateTime.nowTimestamp(); |
| GenericValue visit = VisitHandler.getVisit(request.getSession()); |
| if (visit != null) { |
| // loop through cookies and look for ones with a name that starts with TKCDT_ for trackable cookies |
| Cookie[] cookies = request.getCookies(); |
| |
| if (cookies != null && cookies.length > 0) { |
| for (int i = 0; i < cookies.length; i++) { |
| if (cookies[i].getName().startsWith("TKCDT_")) { |
| String trackingCodeId = cookies[i].getValue(); |
| GenericValue trackingCode; |
| try { |
| trackingCode = EntityQuery.use(delegator).from("TrackingCode").where("trackingCodeId", trackingCodeId).cache().queryOne(); |
| } catch (GenericEntityException e) { |
| Debug.logError(e, "Error looking up TrackingCode with trackingCodeId [" + trackingCodeId + "], ignoring this trackingCodeId", module); |
| continue; |
| } |
| |
| if (trackingCode == null) { |
| Debug.logError("TrackingCode not found for trackingCodeId [" + trackingCodeId + "], ignoring this trackingCodeId.", module); |
| //this return value will be ignored, but we'll designate this as an error anyway |
| continue; |
| } |
| |
| //check effective dates |
| if (trackingCode.get("fromDate") != null && nowStamp.before(trackingCode.getTimestamp("fromDate"))) { |
| if (Debug.infoOn()) Debug.logInfo("The TrackingCode with ID [" + trackingCodeId + "] has not yet gone into effect, ignoring this trackingCodeId", module); |
| continue; |
| } |
| if (trackingCode.get("thruDate") != null && nowStamp.after(trackingCode.getTimestamp("thruDate"))) { |
| if (Debug.infoOn()) Debug.logInfo("The TrackingCode with ID [" + trackingCodeId + "] has expired, ignoring this trackingCodeId", module); |
| continue; |
| } |
| |
| // for each trackingCodeId found in this way attach to the visit with the TKCDSRC_COOKIE sourceEnumId |
| GenericValue trackingCodeVisit = delegator.makeValue("TrackingCodeVisit", |
| UtilMisc.toMap("trackingCodeId", trackingCodeId, "visitId", visit.get("visitId"), |
| "fromDate", nowStamp, "sourceEnumId", "TKCDSRC_COOKIE")); |
| try { |
| //not doing this inside a transaction, want each one possible to go in |
| trackingCodeVisit.create(); |
| } catch (GenericEntityException e) { |
| Debug.logError(e, "Error while saving TrackingCodeVisit", module); |
| //don't return error, want to get as many as possible: return "error"; |
| } |
| } |
| } |
| } |
| } |
| |
| return "success"; |
| } |
| |
| public static String checkAccessTrackingCode(HttpServletRequest request, HttpServletResponse response) { |
| Delegator delegator = (Delegator) request.getAttribute("delegator"); |
| java.sql.Timestamp nowStamp = UtilDateTime.nowTimestamp(); |
| |
| String trackingCodeId = request.getParameter("autoTrackingCode"); |
| if (UtilValidate.isEmpty(trackingCodeId)) trackingCodeId = request.getParameter("atc"); |
| if (UtilValidate.isEmpty(trackingCodeId)) { |
| Cookie[] cookies = request.getCookies(); |
| if (cookies != null) { |
| for (Cookie cookie : cookies) { |
| if ("TKCDT_ACCESS".equals(cookie.getName())) { |
| trackingCodeId = cookie.getValue(); |
| } |
| } |
| } |
| } |
| |
| if (UtilValidate.isNotEmpty(trackingCodeId)) { |
| // find the tracking code object |
| GenericValue trackingCode = null; |
| try { |
| trackingCode = EntityQuery.use(delegator).from("TrackingCode").where("trackingCodeId", trackingCodeId).cache().queryOne(); |
| } catch (GenericEntityException e) { |
| Debug.logError(e, "Error looking up TrackingCode with trackingCodeId [" + trackingCodeId + "], ignoring this trackingCodeId", module); |
| } |
| if (trackingCode != null) { |
| // verify the tracking code type |
| if ("ACCESS".equals(trackingCode.getString("trackingCodeTypeId"))) { |
| // verify the effective date |
| if (trackingCode.get("fromDate") != null && nowStamp.after(trackingCode.getTimestamp("fromDate"))) { |
| if (trackingCode.get("thruDate") != null && nowStamp.before(trackingCode.getTimestamp("thruDate"))) { |
| // tracking code is valid |
| return "success"; |
| } else { |
| if (Debug.infoOn()) |
| Debug.logInfo("The TrackingCode with ID [" + trackingCodeId + "] has expired, ignoring this trackingCodeId", module); |
| request.setAttribute("_ERROR_MESSAGE_", "Access code [" + trackingCodeId + "], is not valid."); |
| } |
| } else { |
| if (Debug.infoOn()) |
| Debug.logInfo("The TrackingCode with ID [" + trackingCodeId + "] has not yet gone into effect, ignoring this trackingCodeId", module); |
| request.setAttribute("_ERROR_MESSAGE_", "Access code [" + trackingCodeId + "], is not valid."); |
| } |
| } else { |
| Debug.logWarning("Tracking code found [" + trackingCodeId + "] but was not of the type ACCESS; access denied", module); |
| request.setAttribute("_ERROR_MESSAGE_", "Access code [" + trackingCodeId + "] not found."); |
| } |
| } else { |
| request.setAttribute("_ERROR_MESSAGE_", "Access code [" + trackingCodeId + "] not found."); |
| } |
| } |
| |
| // no tracking code or tracking code invalid; redirect to the access page (i.e. request named 'protect') |
| return ":_protect_:"; |
| } |
| |
| /** Removes the ACCESS tracking code cookie */ |
| public static String removeAccesTrackingCodeCookie(HttpServletRequest request, HttpServletResponse response) { |
| Cookie[] cookies = request.getCookies(); |
| if (cookies != null) { |
| for (Cookie cookie : cookies) { |
| if (cookie.getName().endsWith("_ACCESS")) { |
| cookie.setMaxAge(0); |
| response.addCookie(cookie); |
| } |
| } |
| } |
| return "success"; |
| } |
| |
| /** Makes a list of TrackingCodeOrder entities to be attached to the current order; called by the createOrder event; the values in the returned List will not have the orderId set */ |
| public static List<GenericValue> makeTrackingCodeOrders(HttpServletRequest request) { |
| Delegator delegator = (Delegator) request.getAttribute("delegator"); |
| java.sql.Timestamp nowStamp = UtilDateTime.nowTimestamp(); |
| List<GenericValue> trackingCodeOrders = new LinkedList<GenericValue>(); |
| |
| Cookie[] cookies = request.getCookies(); |
| Timestamp affiliateReferredTimeStamp = null; |
| String siteId = null; |
| String isBillable = null; |
| String trackingCodeId = null; |
| if (cookies != null && cookies.length > 0) { |
| for (int i = 0; i < cookies.length; i++) { |
| String cookieName = cookies[i].getName(); |
| // find the siteId cookie if it exists |
| if ("Ofbiz.TKCD.SiteId".equals(cookieName)) { |
| siteId = cookies[i].getValue(); |
| } |
| |
| // find the referred timestamp cookie if it exists |
| if ("Ofbiz.TKCD.UpdatedTimeStamp".equals(cookieName)) { |
| String affiliateReferredTime = cookies[i].getValue(); |
| if (affiliateReferredTime !=null && !affiliateReferredTime.equals("")) { |
| try { |
| affiliateReferredTimeStamp = Timestamp.valueOf(affiliateReferredTime); |
| } catch (IllegalArgumentException e) { |
| Debug.logError(e, "Error parsing affiliateReferredTimeStamp value from cookie", module); |
| } |
| } |
| } |
| |
| // find any that start with TKCDB_ for billable tracking code cookies with isBillable=Y |
| // also and for each TKCDT_ cookie that doesn't have a corresponding billable code add it to the list with isBillable=N |
| // This cookie value keeps trackingCodeId |
| if (cookieName.startsWith("TKCDB_")) { |
| isBillable = "Y"; |
| trackingCodeId = cookies[i].getValue(); |
| } else if (cookieName.startsWith("TKCDT_")) { |
| isBillable = "N"; |
| trackingCodeId = cookies[i].getValue(); |
| } |
| |
| } |
| } |
| GenericValue trackingCode = null; |
| try { |
| trackingCode = EntityQuery.use(delegator).from("TrackingCode").where("trackingCodeId", trackingCodeId).cache().queryOne(); |
| } catch (GenericEntityException e) { |
| Debug.logError(e, "Error looking up TrackingCode with trackingCodeId [" + trackingCodeId + "], ignoring this trackingCodeId", module); |
| } |
| |
| if (trackingCode != null) { |
| //check effective dates |
| if (trackingCode.get("fromDate") != null && nowStamp.before(trackingCode.getTimestamp("fromDate"))) { |
| if (Debug.infoOn()) Debug.logInfo("The TrackingCode with ID [" + trackingCodeId + "] has not yet gone into effect, ignoring this trackingCodeId", module); |
| } |
| if (trackingCode.get("thruDate") != null && nowStamp.after(trackingCode.getTimestamp("thruDate"))) { |
| if (Debug.infoOn()) Debug.logInfo("The TrackingCode with ID [" + trackingCodeId + "] has expired, ignoring this trackingCodeId", module); |
| } |
| GenericValue trackingCodeOrder = delegator.makeValue("TrackingCodeOrder", |
| UtilMisc.toMap("trackingCodeTypeId", trackingCode.get("trackingCodeTypeId"), |
| "trackingCodeId", trackingCodeId, "isBillable", isBillable, "siteId", siteId, |
| "hasExported", "N", "affiliateReferredTimeStamp",affiliateReferredTimeStamp)); |
| |
| Debug.logInfo(" trackingCodeOrder is " + trackingCodeOrder, module); |
| trackingCodeOrders.add(trackingCodeOrder); |
| } else { |
| // Only log an error if there was a trackingCodeId to begin with |
| if (trackingCodeId != null) { |
| Debug.logError("TrackingCode not found for trackingCodeId [" + trackingCodeId + "], ignoring this trackingCodeId.", module); |
| } |
| } |
| |
| return trackingCodeOrders; |
| } |
| } |
