Subversion Repositories SmartDukaan

Rev

Rev 3141 | Go to most recent revision | Show entire file | Ignore whitespace | Details | Blame | Last modification | View Log | RSS feed

Rev 3141 Rev 3238
Line 28... Line 28...
28 
import com.google.appengine.api.datastore.PreparedQuery;
 28 
import com.google.appengine.api.datastore.PreparedQuery;
29 
import com.google.appengine.api.datastore.Query;
 29 
import com.google.appengine.api.datastore.Query;
30 
 
 30 
 
31 
public class DailyAggregatorServlet extends HttpServlet {
 31 
public class DailyAggregatorServlet extends HttpServlet {
32 
    private static final long serialVersionUID = -8236918415987438049L;
 32 
    private static final long serialVersionUID = -8236918415987438049L;
- 
 
 33 
    private static final String KIND = "DataLog";
- 
 
 34 
    private static final String SESSION_ID_FILED = "sessionId";
- 
 
 35 
    private static final String ITEMID_FILED = "itemId";
- 
 
 36 
    private static final String ITEMIDS_FILED = "itemIds";
- 
 
 37 
    private static final String PRODUCTNAME_FILED = "productName";
- 
 
 38 
    private static final String EVENTTYPE_FILED = "eventType";
- 
 
 39 
    private static final String DATE_FILED = "date";
- 
 
 40
- 
 
 41 
    private static final String PRODUCT_VIEW_EVENT = "PRODUCT_VIEW";
- 
 
 42 
    private static final String ADD_TO_CART_EVENT = "ADD_TO_CART";
- 
 
 43 
    private static final String DELETE_FROM_CART_EVENT = "DELETE_FROM_CART";
- 
 
 44 
    private static final String RESEARCH_ADD_EVENT = "RESEARCH_ADD";
- 
 
 45 
    private static final String RESEARCH_DELETE_EVENT = "RESEARCH_DELETE";
- 
 
 46 
    private static final String SHIPPING_ACCESS_EVENT = "SHIPPINIG_ACCESS";
- 
 
 47 
    private static final String PAYMENT_SUCCESS_EVENT = "PAYMENT_SUCCESS";
- 
 
 48 
    private static final String ORDER_CREATION_EVENT = "ORDER_CREATION";
- 
 
 49 
    private static final String PAYMENT_FAILURE_EVENT = "PAYMENT_FAILURE";
- 
 
 50 
    private static final String PROCEED_TO_PAY_EVENT = "PROCEED_TO_PAY";
- 
 
 51
- 
 
 52 
    private static final String VIEW_COUNT_KEY = "ViewCount";
- 
 
 53 
    private static final String UNIQUE_VIEW_COUNT_KEY = "UniqueViewCount";
- 
 
 54 
    private static final String ADD_TO_CART_COUNT_KEY = "AddToCartCount";
- 
 
 55 
    private static final String UNIQUE_ADD_TO_CART_COUNT_KEY = "UniqueAddToCartCount";
- 
 
 56 
    private static final String DELETE_FROM_CART_COUNT_KEY = "DeleteFromCartCount";
- 
 
 57 
    private static final String UNIQUE_DELETE_FROM_CART_COUNT_KEY = "UniqueDeleteFromCartCount";
- 
 
 58 
    private static final String ADD_TO_RESEARCH_COUNT_KEY = "AddToResearchCount";
- 
 
 59 
    private static final String UNIQUE_ADD_TO_RESEARCH_COUNT_KEY = "UniqueAddToResearchCount";
- 
 
 60 
    private static final String DELETE_FROM_RESEARCH_COUNT_KEY = "DeleteFromResearchCount";
- 
 
 61 
    private static final String UNIQUE_DELETE_FROM_RESEARCH_COUNT_KEY = "UniqueDeleteFromResearchCount";
- 
 
 62 
    private static final String SHIPPING_ACCESS_COUNT_KEY = "ShippingAccessCount";
- 
 
 63 
    private static final String UNIQUE_SHIPPING_ACCESS_COUNT_KEY = "UniqueShippingAccessCount";
- 
 
 64 
    private static final String PAYMENT_SUCCESS_COUNT_KEY = "PaymentSuccessCount";
- 
 
 65 
    private static final String UNIQUE_PAYMENT_SUCCESS_COUNT_KEY = "UniquePaymentSuccessCount";
- 
 
 66 
    private static final String ORDER_CREATION_COUNT_KEY = "OrderCreationCount";
- 
 
 67 
    private static final String UNIQUE_ORDER_CREATION_COUNT_KEY = "UniqueOrderCreationCount";
- 
 
 68 
    private static final String PAYMENT_FAILURE_COUNT_KEY = "PaymentFailureCount";
- 
 
 69 
    private static final String UNIQUE_PAYMENT_FAILURE_COUNT_KEY = "UniquePaymentFailureCount";
- 
 
 70 
    private static final String PROCEED_TO_PAY_COUNT_KEY = "ProceedToPayCount";
- 
 
 71 
    private static final String UNIQUE_PROCEED_TO_PAY_COUNT_KEY = "UniqueProceedToPayCount";
- 
 
 72
- 
 
 73 
    private Map<Long, Item> itemsMap = new HashMap<Long, Item>();
- 
 
 74 
    private Map<Long, Item> itemsCatalogIdMap = new HashMap<Long, Item>();
- 
 
 75 
    private Map<String, Item> itemsNameMap = new HashMap<String, Item>();
- 
 
 76 
    private Map<Long, Map<String, Long>> itemsResultMap = new HashMap<Long, Map<String, Long>>();
- 
 
 77
- 
 
 78 
    private Date fromDate;
- 
 
 79 
    private Date toDate;
- 
 
 80 
    private DatastoreService datastore;
33 
 
 81
34 
    public void doPost(HttpServletRequest req, HttpServletResponse resp) {
 82 
    public void doPost(HttpServletRequest req, HttpServletResponse resp) {
- 
 
 83 
        datastore = DatastoreServiceFactory.getDatastoreService();
35 
        SimpleDateFormat sdf = new SimpleDateFormat("yyyyMMdd");
 84 
        SimpleDateFormat sdf = new SimpleDateFormat("yyyyMMdd");
36 
        Calendar cal = Calendar.getInstance(TimeZone.getTimeZone("IST"));
 85 
        Calendar cal = Calendar.getInstance(TimeZone.getTimeZone("IST"));
37 
        String dateStr = req.getParameter("date");
86 
        String dateStr = req.getParameter("date");
38 
        if (dateStr != null && !dateStr.isEmpty()) {
 87 
        if (dateStr != null && !dateStr.isEmpty()) {
39 
            try {
 88 
            try {
Line 45... Line 94...
45 
        }
 94 
        }
46 
        cal.set(Calendar.HOUR_OF_DAY, 0);
95 
        cal.set(Calendar.HOUR_OF_DAY, 0);
47 
        cal.set(Calendar.MINUTE, 0);
96 
        cal.set(Calendar.MINUTE, 0);
48 
        cal.set(Calendar.SECOND, 0);
97 
        cal.set(Calendar.SECOND, 0);
49 
        cal.set(Calendar.MILLISECOND, 0);
 98 
        cal.set(Calendar.MILLISECOND, 0);
50 
        Date toDate = cal.getTime();
 99 
        fromDate = cal.getTime();
51 
        cal.add(Calendar.DAY_OF_MONTH, -1);
 100 
        cal.add(Calendar.DAY_OF_MONTH, 1);
52 
        Date fromDate = cal.getTime();
 101 
        toDate = cal.getTime();
53
102
54 
        ItemRepository itemRepository = new ItemRepository();
 103 
        ItemRepository itemRepository = new ItemRepository();
55 
        List<Item> items = itemRepository.getAll();
 104 
        List<Item> items = itemRepository.getAll();
56 
        Map<Long, Item> itemsMap = new HashMap<Long, Item>();
 - 
 
57 
        Map<Long, Item> itemsCatalogIdMap = new HashMap<Long, Item>();
 - 
 
58 
        Map<String, Item> itemsNameMap = new HashMap<String, Item>();
 - 
 
59 
        Map<Long, Map<String, Long>> itemsResultMap = new HashMap<Long, Map<String, Long>>();
 - 
 
60 
        for (Item item : items) {
 105 
        for (Item item : items) {
61 
            itemsMap.put(item.getId(), item);
 106 
            itemsMap.put(item.getId(), item);
62 
            itemsCatalogIdMap.put(item.getCatalogId(), item);
 107 
            itemsCatalogIdMap.put(item.getCatalogId(), item);
63 
            itemsNameMap.put(item.getName().trim(), item);
 108 
            itemsNameMap.put(item.getName().trim(), item);
64 
        }
 109 
        }
65
110
- 
 
 111 
        UpdateViewCount(PRODUCT_VIEW_EVENT, VIEW_COUNT_KEY, UNIQUE_VIEW_COUNT_KEY);
- 
 
 112
- 
 
 113 
        UpdateItemIdEventCount(ADD_TO_CART_EVENT, ADD_TO_CART_COUNT_KEY, UNIQUE_ADD_TO_CART_COUNT_KEY, false);
- 
 
 114 
        UpdateItemIdEventCount(DELETE_FROM_CART_EVENT, DELETE_FROM_CART_COUNT_KEY, UNIQUE_DELETE_FROM_CART_COUNT_KEY, false);
- 
 
 115 
        UpdateItemIdEventCount(RESEARCH_ADD_EVENT, ADD_TO_RESEARCH_COUNT_KEY, UNIQUE_ADD_TO_RESEARCH_COUNT_KEY, true);
- 
 
 116 
        UpdateItemIdEventCount(RESEARCH_DELETE_EVENT, DELETE_FROM_RESEARCH_COUNT_KEY, UNIQUE_DELETE_FROM_RESEARCH_COUNT_KEY, true);
- 
 
 117
- 
 
 118 
        UpdateItemIdEventCount(SHIPPING_ACCESS_EVENT, SHIPPING_ACCESS_COUNT_KEY, UNIQUE_SHIPPING_ACCESS_COUNT_KEY, false);
- 
 
 119 
        UpdateItemIdEventCount(PAYMENT_SUCCESS_EVENT, PAYMENT_SUCCESS_COUNT_KEY, UNIQUE_PAYMENT_SUCCESS_COUNT_KEY, false);
- 
 
 120 
        UpdateItemIdEventCount(ORDER_CREATION_EVENT, ORDER_CREATION_COUNT_KEY, UNIQUE_ORDER_CREATION_COUNT_KEY, false);
- 
 
 121 
        UpdateItemIdEventCount(PAYMENT_FAILURE_EVENT, PAYMENT_FAILURE_COUNT_KEY, UNIQUE_PAYMENT_FAILURE_COUNT_KEY, false);
- 
 
 122 
        UpdateItemIdEventCount(PROCEED_TO_PAY_EVENT, PROCEED_TO_PAY_COUNT_KEY, UNIQUE_PROCEED_TO_PAY_COUNT_KEY, false);
- 
 
 123
66 
        DatastoreService datastore = DatastoreServiceFactory.getDatastoreService();
 124 
        List<ItemActivity> itemActivities = new ArrayList<ItemActivity>();
- 
 
 125 
        ItemActivityRepository itemActivityRepository = new ItemActivityRepository();
- 
 
 126 
        for (Entry<Long, Map<String, Long>> entry : itemsResultMap.entrySet()) {
- 
 
 127 
            Long catalogItemId = (Long)entry.getKey();
- 
 
 128 
            Map<String, Long> itemMap = (Map<String, Long>)entry.getValue();
- 
 
 129
- 
 
 130 
            ItemActivity itemActivity = new ItemActivity();
- 
 
 131 
            itemActivity.setCatalogId(catalogItemId);
- 
 
 132 
            itemActivity.setDate(fromDate);
- 
 
 133
- 
 
 134 
            itemActivity.setView(itemMap.get(VIEW_COUNT_KEY));
- 
 
 135 
            itemActivity.setAddToCart(itemMap.get(ADD_TO_CART_COUNT_KEY));
- 
 
 136 
            itemActivity.setAddToResearch(itemMap.get(ADD_TO_RESEARCH_COUNT_KEY));
- 
 
 137 
            itemActivity.setDeleteFromCart(itemMap.get(DELETE_FROM_CART_COUNT_KEY));
- 
 
 138 
            itemActivity.setDeleteFromResearch(itemMap.get(DELETE_FROM_RESEARCH_COUNT_KEY));
- 
 
 139 
            itemActivity.setShippingAccess(itemMap.get(SHIPPING_ACCESS_COUNT_KEY));
- 
 
 140 
            itemActivity.setPaymentSuccess(itemMap.get(PAYMENT_SUCCESS_COUNT_KEY));
- 
 
 141 
            itemActivity.setOrderCreation(itemMap.get(ORDER_CREATION_COUNT_KEY));
- 
 
 142 
            itemActivity.setPaymentFailure(itemMap.get(PAYMENT_FAILURE_COUNT_KEY));
- 
 
 143 
            itemActivity.setProceedToPay(itemMap.get(PROCEED_TO_PAY_COUNT_KEY));
- 
 
 144
- 
 
 145 
            itemActivity.setUniqueView(itemMap.get(UNIQUE_VIEW_COUNT_KEY));
- 
 
 146 
            itemActivity.setUniqueAddToCart(itemMap.get(UNIQUE_ADD_TO_CART_COUNT_KEY));
- 
 
 147 
            itemActivity.setUniqueAddToResearch(itemMap.get(UNIQUE_ADD_TO_RESEARCH_COUNT_KEY));
- 
 
 148 
            itemActivity.setUniqueDeleteFromCart(itemMap.get(UNIQUE_DELETE_FROM_CART_COUNT_KEY));
- 
 
 149 
            itemActivity.setUniqueDeleteFromResearch(itemMap.get(UNIQUE_ADD_TO_RESEARCH_COUNT_KEY));
- 
 
 150 
            itemActivity.setUniqueShippingAccess(itemMap.get(UNIQUE_SHIPPING_ACCESS_COUNT_KEY));
- 
 
 151 
            itemActivity.setUniquePaymentSuccess(itemMap.get(UNIQUE_PAYMENT_SUCCESS_COUNT_KEY));
- 
 
 152 
            itemActivity.setUniqueOrderCreation(itemMap.get(UNIQUE_ORDER_CREATION_COUNT_KEY));
- 
 
 153 
            itemActivity.setUniquePaymentFailure(itemMap.get(UNIQUE_PAYMENT_FAILURE_COUNT_KEY));
- 
 
 154 
            itemActivity.setUniqueProceedToPay(itemMap.get(UNIQUE_PROCEED_TO_PAY_COUNT_KEY));
- 
 
 155
- 
 
 156 
            itemActivities.add(itemActivity);
- 
 
 157 
        }
- 
 
 158 
        itemActivityRepository.createAll(itemActivities);
- 
 
 159 
    }
- 
 
 160 
 
- 
 
 161 
    public void doGet(HttpServletRequest req, HttpServletResponse resp) {
- 
 
 162 
        doPost(req, resp);
- 
 
 163 
    }
- 
 
 164 
 
- 
 
 165 
    private void UpdateViewCount(String event, String viewCountKey, String uniqueViewCountKey) {
67 
        Query query = new Query("DataLog");
 166 
        Query query = new Query(KIND);
68 
        query.addFilter("eventType", Query.FilterOperator.EQUAL, "PRODUCT_VIEW");
 167 
        query.addFilter(EVENTTYPE_FILED, Query.FilterOperator.EQUAL, event);
69 
        query.addFilter("date", Query.FilterOperator.GREATER_THAN_OR_EQUAL, fromDate);
 168 
        query.addFilter(DATE_FILED, Query.FilterOperator.GREATER_THAN_OR_EQUAL, fromDate);
70 
        query.addFilter("date", Query.FilterOperator.LESS_THAN, toDate);
 169 
        query.addFilter(DATE_FILED, Query.FilterOperator.LESS_THAN, toDate);
71 
        PreparedQuery pq = datastore.prepare(query);
 170 
        PreparedQuery pq = datastore.prepare(query);
72 
        Set<String> uniqueSet = new HashSet<String>();
 171 
        Set<String> uniqueSet = new HashSet<String>();
73 
        for (Entity result : pq.asIterable()) {
 172 
        for (Entity result : pq.asIterable()) {
74 
            String sessionId = (String)result.getProperty("sessionId");
 173 
            String sessionId = (String)result.getProperty(SESSION_ID_FILED);
75 
            Long catalogItemId = (Long)result.getProperty("itemId");
 174 
            Long catalogItemId = (Long)result.getProperty(ITEMID_FILED);
76 
            if(catalogItemId == null) {
 175 
            if(catalogItemId == null) {
77 
                String name = (String)result.getProperty("productName");
 176 
                String name = (String)result.getProperty(PRODUCTNAME_FILED);
78 
                if (itemsNameMap.containsKey(name.trim())) {
 177 
                if (itemsNameMap.containsKey(name.trim())) {
79 
                    catalogItemId = itemsNameMap.get(name.trim()).getCatalogId();
 178 
                    catalogItemId = itemsNameMap.get(name.trim()).getCatalogId();
80 
                }
 179 
                }
81 
            }
 180 
            }
82 
            if (itemsResultMap.containsKey(catalogItemId)) {
 181 
            if (itemsResultMap.containsKey(catalogItemId)) {
83 
                Map<String, Long> itemMap = itemsResultMap.get(catalogItemId);
 182 
                Map<String, Long> itemMap = itemsResultMap.get(catalogItemId);
84 
                if (itemMap.containsKey("ViewCount")) {
 183 
                if (itemMap.containsKey(VIEW_COUNT_KEY)) {
85 
                    Long count = itemMap.get("ViewCount");
 184 
                    Long count = itemMap.get(VIEW_COUNT_KEY);
86 
                    itemMap.put("ViewCount", ++count);
 185 
                    itemMap.put(VIEW_COUNT_KEY, ++count);
87 
                }
 186 
                }
88 
                else {
 187 
                else {
89 
                    itemMap.put("ViewCount", 1l);
 188 
                    itemMap.put(VIEW_COUNT_KEY, 1l);
90 
                }
 189 
                }
91 
            }
 190 
            }
92 
            else {
 191 
            else {
93 
                Map<String, Long> itemMap = new HashMap<String, Long>();
 192 
                Map<String, Long> itemMap = new HashMap<String, Long>();
94 
                itemMap.put("ViewCount", 1l);
 193 
                itemMap.put(VIEW_COUNT_KEY, 1l);
95 
                itemsResultMap.put(catalogItemId, itemMap);
 194 
                itemsResultMap.put(catalogItemId, itemMap);
96 
            }
 195 
            }
97 
            String uniqueKey = sessionId + catalogItemId;
 196 
            String uniqueKey = sessionId + catalogItemId;
98 
            if (!uniqueSet.contains(uniqueKey)) {
 197 
            if (!uniqueSet.contains(uniqueKey)) {
99 
                Map<String, Long> itemMap = itemsResultMap.get(catalogItemId);
 198 
                Map<String, Long> itemMap = itemsResultMap.get(catalogItemId);
100 
                if (itemMap.containsKey("uniqueViewCount")) {
 199 
                if (itemMap.containsKey(UNIQUE_VIEW_COUNT_KEY)) {
101 
                    Long count = itemMap.get("uniqueViewCount");
 200 
                    Long count = itemMap.get(UNIQUE_VIEW_COUNT_KEY);
102 
                    itemMap.put("uniqueViewCount", ++count);
 201 
                    itemMap.put(UNIQUE_VIEW_COUNT_KEY, ++count);
103 
                }
 202 
                }
104 
                else {
 203 
                else {
105 
                    itemMap.put("uniqueViewCount", 1l);
 204 
                    itemMap.put(UNIQUE_VIEW_COUNT_KEY, 1l);
106 
                }
 205 
                }
107 
                uniqueSet.add(uniqueKey);
 206 
                uniqueSet.add(uniqueKey);
108 
            }
 207 
            }
109 
        }
 208 
        }
110
209 
    }
- 
 
 210
- 
 
 211 
    private void UpdateItemIdEventCount(String event, String countKey, String uniqueCountKey, boolean isCatalogIdEvent) {
111 
        query = new Query("DataLog");
 212 
        Query query = new Query(KIND);
112 
        query.addFilter("eventType", Query.FilterOperator.EQUAL, "ADD_TO_CART");
 213 
        query.addFilter(EVENTTYPE_FILED, Query.FilterOperator.EQUAL, event);
113 
        query.addFilter("date", Query.FilterOperator.GREATER_THAN_OR_EQUAL, fromDate);
 214 
        query.addFilter(DATE_FILED, Query.FilterOperator.GREATER_THAN_OR_EQUAL, fromDate);
114 
        query.addFilter("date", Query.FilterOperator.LESS_THAN, toDate);
 215 
        query.addFilter(DATE_FILED, Query.FilterOperator.LESS_THAN, toDate);
115 
        pq = datastore.prepare(query);
 216 
        PreparedQuery pq = datastore.prepare(query);
116 
        uniqueSet = new HashSet<String>();
 217 
        Set<String> uniqueSet = new HashSet<String>();
117 
        for (Entity result : pq.asIterable()) {
 218 
        for (Entity result : pq.asIterable()) {
118 
            String sessionId = (String)result.getProperty("sessionId");
 219 
            String sessionId = (String)result.getProperty(SESSION_ID_FILED);
119 
            for (Long itemId : (List<Long>)result.getProperty("itemIds")) {
 - 
 
120 
                Long catalogItemId = itemsMap.get(itemId).getCatalogId();
 - 
 
121 
                if (itemsResultMap.containsKey(catalogItemId)) {
 - 
 
122 
                    Map<String, Long> itemMap = itemsResultMap.get(catalogItemId);
 - 
 
123 
                    if (itemMap.containsKey("AddToCartCount")) {
 - 
 
124 
                        Long count = itemMap.get("AddToCartCount");
 - 
 
125 
                        itemMap.put("AddToCartCount", ++count);
 - 
 
126 
                    }
 - 
 
127 
                    else {
 220 
            List<Long> itemIds = null;
128 
                        itemMap.put("AddToCartCount", 1l);
 - 
 
129 
                    }
 - 
 
130 
                }
 - 
 
131 
                else {
 - 
 
132 
                    Map<String, Long> itemMap = new HashMap<String, Long>();
 - 
 
133 
                    itemMap.put("AddToCartCount", 1l);
 - 
 
134 
                    itemsResultMap.put(catalogItemId, itemMap);
 - 
 
135 
                }
 - 
 
136 
                String uniqueKey = sessionId + catalogItemId;
 - 
 
137 
                if (!uniqueSet.contains(uniqueKey)) {
 221 
            if (!result.hasProperty(ITEMIDS_FILED)) {
138 
                    Map<String, Long> itemMap = itemsResultMap.get(catalogItemId);
 - 
 
139 
                    if (itemMap.containsKey("uniqueAddToCartCount")) {
 - 
 
140 
                        Long count = itemMap.get("uniqueAddToCartCount");
 - 
 
141 
                        itemMap.put("uniqueAddToCartCount", ++count);
 - 
 
142 
                    }
 - 
 
143 
                    else {
 222 
                continue;
144 
                        itemMap.put("uniqueAddToCartCount", 1l);
 - 
 
145 
                    }
 - 
 
146 
                    uniqueSet.add(uniqueKey);
 - 
 
147 
                }
 - 
 
148 
            }
 223 
            }
149 
        }
 224 
            try {
150
- 
 
151 
        query = new Query("DataLog");
 - 
 
152 
        query.addFilter("eventType", Query.FilterOperator.EQUAL, "DELETE_FROM_CART");
 - 
 
153 
        query.addFilter("date", Query.FilterOperator.GREATER_THAN_OR_EQUAL, fromDate);
 - 
 
154 
        query.addFilter("date", Query.FilterOperator.LESS_THAN, toDate);
 - 
 
155 
        pq = datastore.prepare(query);
 - 
 
156 
        uniqueSet = new HashSet<String>();
 - 
 
157 
        for (Entity result : pq.asIterable()) {
 - 
 
158 
            String sessionId = (String)result.getProperty("sessionId");
 - 
 
159 
            for (Long itemId : (List<Long>)result.getProperty("itemIds")) {
 225 
                itemIds = (List<Long>)result.getProperty(ITEMIDS_FILED);
160 
                Long catalogItemId = itemsMap.get(itemId).getCatalogId();
 - 
 
161 
                if (itemsResultMap.containsKey(catalogItemId)) {
 226 
            } catch (ClassCastException e) {
162 
                    Map<String, Long> itemMap = itemsResultMap.get(catalogItemId);
 - 
 
163 
                    if (itemMap.containsKey("DeleteFromCartCount")) {
 - 
 
164 
                        Long count = itemMap.get("DeleteFromCartCount");
 - 
 
165 
                        itemMap.put("DeleteFromCartCount", ++count);
 - 
 
166 
                    }
 227 
                try {
167 
                    else {
 228 
                    itemIds = new ArrayList<Long>();
168 
                        itemMap.put("DeleteFromCartCount", 1l);
 229 
                    itemIds.add((Long)result.getProperty(ITEMIDS_FILED));
169 
                    }
 - 
 
170 
                }
 230 
                }
171 
                else {
 - 
 
172 
                    Map<String, Long> itemMap = new HashMap<String, Long>();
 - 
 
173 
                    itemMap.put("DeleteFromCartCount", 1l);
 - 
 
174 
                    itemsResultMap.put(catalogItemId, itemMap);
 - 
 
175 
                }
 - 
 
176 
                String uniqueKey = sessionId + catalogItemId;
 - 
 
177 
                if (!uniqueSet.contains(uniqueKey)) {
 - 
 
178 
                    Map<String, Long> itemMap = itemsResultMap.get(catalogItemId);
 - 
 
179 
                    if (itemMap.containsKey("uniqueDeleteFromCartCount")) {
 - 
 
180 
                        Long count = itemMap.get("uniqueDeleteFromCartCount");
 - 
 
181 
                        itemMap.put("uniqueDeleteFromCartCount", ++count);
 - 
 
182 
                    }
 - 
 
183 
                    else {
 231 
                catch(Exception ex) {
184 
                        itemMap.put("uniqueDeleteFromCartCount", 1l);
 - 
 
185 
                    }
 - 
 
186 
                    uniqueSet.add(uniqueKey);
 232 
                    log(e.getMessage());
187 
                }
 233 
                }
188 
            }
 234 
            }
189 
        }
 235
190
- 
 
191 
        query = new Query("DataLog");
 - 
 
192 
        query.addFilter("eventType", Query.FilterOperator.EQUAL, "RESEARCH_ADD");
 - 
 
193 
        query.addFilter("date", Query.FilterOperator.GREATER_THAN_OR_EQUAL, fromDate);
 - 
 
194 
        query.addFilter("date", Query.FilterOperator.LESS_THAN, toDate);
 - 
 
195 
        pq = datastore.prepare(query);
 - 
 
196 
        uniqueSet = new HashSet<String>();
 - 
 
197 
        for (Entity result : pq.asIterable()) {
 - 
 
198 
            String sessionId = (String)result.getProperty("sessionId");
 - 
 
199 
            for (Long catalogItemId : (List<Long>)result.getProperty("itemIds")) {
 - 
 
200 
                if (itemsResultMap.containsKey(catalogItemId)) {
 - 
 
201 
                    Map<String, Long> itemMap = itemsResultMap.get(catalogItemId);
 - 
 
202 
                    if (itemMap.containsKey("AddToResearchCount")) {
 - 
 
203 
                        Long count = itemMap.get("AddToResearchCount");
 - 
 
204 
                        itemMap.put("AddToResearchCount", ++count);
 - 
 
205 
                    }
 - 
 
206 
                    else {
 236 
            if (itemIds == null) {
207 
                        itemMap.put("AddToResearchCount", 1l);
 - 
 
208 
                    }
 237 
                continue;
209 
                }
 238 
            }
210 
                else {
 239 
            for (Long itemId : itemIds) {
211 
                    Map<String, Long> itemMap = new HashMap<String, Long>();
 - 
 
212 
                    itemMap.put("AddToResearchCount", 1l);
 240 
                if (itemId == null) {
213 
                    itemsResultMap.put(catalogItemId, itemMap);
 241 
                    continue;
214 
                }
 242 
                }
215 
                String uniqueKey = sessionId + catalogItemId;
 - 
 
216 
                if (!uniqueSet.contains(uniqueKey)) {
 243 
                if (!isCatalogIdEvent) {
217 
                    Map<String, Long> itemMap = itemsResultMap.get(catalogItemId);
 - 
 
218 
                    if (itemMap.containsKey("uniqueAddToResearchCount")) {
 244 
                    if (itemsMap.containsKey(itemId)) {
219 
                        Long count = itemMap.get("uniqueAddToResearchCount");
 245 
                        itemId = itemsMap.get(itemId).getCatalogId();
220 
                        itemMap.put("uniqueAddToResearchCount", ++count);
 - 
 
221 
                    }
 - 
 
222 
                    else {
 - 
 
223 
                        itemMap.put("uniqueAddToResearchCount", 1l);
 - 
 
224 
                    }
 246 
                    }
225 
                    uniqueSet.add(uniqueKey);
 - 
 
226 
                }
 247 
                }
227 
            }
 - 
 
228 
        }
 - 
 
229
- 
 
230 
        query = new Query("DataLog");
 - 
 
231 
        query.addFilter("eventType", Query.FilterOperator.EQUAL, "RESEARCH_DELETE");
 - 
 
232 
        query.addFilter("date", Query.FilterOperator.GREATER_THAN_OR_EQUAL, fromDate);
 - 
 
233 
        query.addFilter("date", Query.FilterOperator.LESS_THAN, toDate);
 - 
 
234 
        pq = datastore.prepare(query);
 - 
 
235 
        uniqueSet = new HashSet<String>();
 - 
 
236 
        for (Entity result : pq.asIterable()) {
 - 
 
237 
            String sessionId = (String)result.getProperty("sessionId");
 - 
 
238 
            for (Long catalogItemId : (List<Long>)result.getProperty("itemIds")) {
 - 
 
239 
                if (itemsResultMap.containsKey(catalogItemId)) {
 248 
                if (itemsResultMap.containsKey(itemId)) {
240 
                    Map<String, Long> itemMap = itemsResultMap.get(catalogItemId);
 249 
                    Map<String, Long> itemMap = itemsResultMap.get(itemId);
241 
                    if (itemMap.containsKey("DeleteFromResearchCount")) {
 250 
                    if (itemMap.containsKey(countKey)) {
242 
                        Long count = itemMap.get("DeleteFromResearchCount");
 251 
                        Long count = itemMap.get(countKey);
243 
                        itemMap.put("DeleteFromResearchCount", ++count);
 252 
                        itemMap.put(countKey, ++count);
244 
                    }
 253 
                    }
245 
                    else {
 254 
                    else {
246 
                        itemMap.put("DeleteFromResearchCount", 1l);
 255 
                        itemMap.put(countKey, 1l);
247 
                    }
 256 
                    }
248 
                }
 257 
                }
249 
                else {
 258 
                else {
250 
                    Map<String, Long> itemMap = new HashMap<String, Long>();
 259 
                    Map<String, Long> itemMap = new HashMap<String, Long>();
251 
                    itemMap.put("DeleteFromResearchCount", 1l);
 260 
                    itemMap.put(countKey, 1l);
252 
                    itemsResultMap.put(catalogItemId, itemMap);
 261 
                    itemsResultMap.put(itemId, itemMap);
253 
                }
 262 
                }
254 
                String uniqueKey = sessionId + catalogItemId;
 263 
                String uniqueKey = sessionId + itemId;
255 
                if (!uniqueSet.contains(uniqueKey)) {
 264 
                if (!uniqueSet.contains(uniqueKey)) {
256 
                    Map<String, Long> itemMap = itemsResultMap.get(catalogItemId);
 265 
                    Map<String, Long> itemMap = itemsResultMap.get(itemId);
257 
                    if (itemMap.containsKey("uniqueDeleteFromResearchCount")) {
 266 
                    if (itemMap.containsKey(uniqueCountKey)) {
258 
                        Long count = itemMap.get("uniqueDeleteFromResearchCount");
 267 
                        Long count = itemMap.get(uniqueCountKey);
259 
                        itemMap.put("uniqueDeleteFromResearchCount", ++count);
 268 
                        itemMap.put(uniqueCountKey, ++count);
260 
                    }
 269 
                    }
261 
                    else {
 270 
                    else {
262 
                        itemMap.put("uniqueDeleteFromResearchCount", 1l);
 271 
                        itemMap.put(uniqueCountKey, 1l);
263 
                    }
 272 
                    }
264 
                    uniqueSet.add(uniqueKey);
 273 
                    uniqueSet.add(uniqueKey);
265 
                }
 274 
                }
266 
            }
 275 
            }
267 
        }
 276 
        }
268
- 
 
269 
        List<ItemActivity> itemActivities = new ArrayList<ItemActivity>();
 - 
 
270 
        ItemActivityRepository itemActivityRepository = new ItemActivityRepository();
 - 
 
271 
        for (Entry<Long, Map<String, Long>> entry : itemsResultMap.entrySet()) {
 - 
 
272 
            Long catalogItemId = (Long)entry.getKey();
 - 
 
273 
            Map<String, Long> itemMap = (Map<String, Long>)entry.getValue();
 - 
 
274
- 
 
275 
            ItemActivity itemActivity = new ItemActivity();
 - 
 
276 
            itemActivity.setCatalogId(catalogItemId);
 - 
 
277 
            itemActivity.setDate(fromDate);
 - 
 
278
- 
 
279 
            itemActivity.setView(itemMap.get("ViewCount"));
 - 
 
280 
            itemActivity.setAddToCart(itemMap.get("AddToCartCount"));
 - 
 
281 
            itemActivity.setAddToResearch(itemMap.get("AddToResearchCount"));
 - 
 
282 
            itemActivity.setDeleteFromCart(itemMap.get("DeleteFromCartCount"));
 - 
 
283 
            itemActivity.setDeleteFromResearch(itemMap.get("DeleteFromResearchCount"));
 - 
 
284
- 
 
285 
            itemActivity.setUniqueView(itemMap.get("uniqueViewCount"));
 - 
 
286 
            itemActivity.setUniqueAddToCart(itemMap.get("uniqueAddToCartCount"));
 - 
 
287 
            itemActivity.setUniqueAddToResearch(itemMap.get("uniqueAddToResearchCount"));
 - 
 
288 
            itemActivity.setUniqueDeleteFromCart(itemMap.get("uniqueDeleteFromCartCount"));
 - 
 
289 
            itemActivity.setUniqueDeleteFromResearch(itemMap.get("uniqueDeleteFromResearchCount"));
 - 
 
290
- 
 
291 
            itemActivities.add(itemActivity);
 - 
 
292 
        }
 - 
 
293 
        itemActivityRepository.createAll(itemActivities);
 - 
 
294 
    }
 - 
 
295
- 
 
296 
    public void doGet(HttpServletRequest req, HttpServletResponse resp) {
 - 
 
297 
        doPost(req, resp);
 - 
 
298 
    }
 277 
    }
299 
}
 278 
}
300 

            279