Subversion Repositories SmartDukaan

Rev

Rev 3122 | Rev 3238 | Go to most recent revision | Details | Compare with Previous | Last modification | View Log | RSS feed

Rev Author Line No. Line
3116 vikas 1 
package in.shop2020.web;
2 
 
3 
import in.shop2020.model.Item;
4 
import in.shop2020.model.ItemActivity;
5 
import in.shop2020.server.ItemActivityRepository;
6 
import in.shop2020.server.ItemRepository;
7 
 
8 
import java.text.ParseException;
9 
import java.text.SimpleDateFormat;
3122 vikas 10 
import java.util.ArrayList;
3116 vikas 11 
import java.util.Calendar;
12 
import java.util.Date;
13 
import java.util.HashMap;
14 
import java.util.HashSet;
15 
import java.util.List;
16 
import java.util.Map;
17 
import java.util.Map.Entry;
18 
import java.util.Set;
19 
import java.util.TimeZone;
20 
 
21 
import javax.servlet.http.HttpServlet;
22 
import javax.servlet.http.HttpServletRequest;
23 
import javax.servlet.http.HttpServletResponse;
24 
 
25 
import com.google.appengine.api.datastore.DatastoreService;
26 
import com.google.appengine.api.datastore.DatastoreServiceFactory;
27 
import com.google.appengine.api.datastore.Entity;
28 
import com.google.appengine.api.datastore.PreparedQuery;
29 
import com.google.appengine.api.datastore.Query;
30 
 
31 
public class DailyAggregatorServlet extends HttpServlet {
32 
    private static final long serialVersionUID = -8236918415987438049L;
33 
 
34 
    public void doPost(HttpServletRequest req, HttpServletResponse resp) {
35 
        SimpleDateFormat sdf = new SimpleDateFormat("yyyyMMdd");
36 
        Calendar cal = Calendar.getInstance(TimeZone.getTimeZone("IST"));
37 
        String dateStr = req.getParameter("date");
38 
        if (dateStr != null && !dateStr.isEmpty()) {
39 
            try {
40 
                cal.setTime(sdf.parse(dateStr));
41 
                cal.add(Calendar.DAY_OF_MONTH, 1);
42 
            } catch (ParseException e) {
43 
                e.printStackTrace();
44 
            }
45 
        }
46 
        cal.set(Calendar.HOUR_OF_DAY, 0);
47 
        cal.set(Calendar.MINUTE, 0);
48 
        cal.set(Calendar.SECOND, 0);
49 
        cal.set(Calendar.MILLISECOND, 0);
50 
        Date toDate = cal.getTime();
51 
        cal.add(Calendar.DAY_OF_MONTH, -1);
52 
        Date fromDate = cal.getTime();
53 
 
54 
        ItemRepository itemRepository = new ItemRepository();
55 
        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) {
61 
            itemsMap.put(item.getId(), item);
62 
            itemsCatalogIdMap.put(item.getCatalogId(), item);
63 
            itemsNameMap.put(item.getName().trim(), item);
64 
        }
65 
 
66 
        DatastoreService datastore = DatastoreServiceFactory.getDatastoreService();
67 
        Query query = new Query("DataLog");
68 
        query.addFilter("eventType", Query.FilterOperator.EQUAL, "PRODUCT_VIEW");
69 
        query.addFilter("date", Query.FilterOperator.GREATER_THAN_OR_EQUAL, fromDate);
70 
        query.addFilter("date", Query.FilterOperator.LESS_THAN, toDate);
71 
        PreparedQuery pq = datastore.prepare(query);
72 
        Set<String> uniqueSet = new HashSet<String>();
73 
        for (Entity result : pq.asIterable()) {
74 
            String sessionId = (String)result.getProperty("sessionId");
75 
            Long catalogItemId = (Long)result.getProperty("itemId");
76 
            if(catalogItemId == null) {
77 
                String name = (String)result.getProperty("productName");
78 
                if (itemsNameMap.containsKey(name.trim())) {
79 
                    catalogItemId = itemsNameMap.get(name.trim()).getCatalogId();
80 
                }
81 
            }
82 
            if (itemsResultMap.containsKey(catalogItemId)) {
83 
                Map<String, Long> itemMap = itemsResultMap.get(catalogItemId);
84 
                if (itemMap.containsKey("ViewCount")) {
85 
                    Long count = itemMap.get("ViewCount");
86 
                    itemMap.put("ViewCount", ++count);
87 
                }
88 
                else {
89 
                    itemMap.put("ViewCount", 1l);
90 
                }
91 
            }
92 
            else {
93 
                Map<String, Long> itemMap = new HashMap<String, Long>();
94 
                itemMap.put("ViewCount", 1l);
95 
                itemsResultMap.put(catalogItemId, itemMap);
96 
            }
97 
            String uniqueKey = sessionId + catalogItemId;
98 
            if (!uniqueSet.contains(uniqueKey)) {
99 
                Map<String, Long> itemMap = itemsResultMap.get(catalogItemId);
100 
                if (itemMap.containsKey("uniqueViewCount")) {
101 
                    Long count = itemMap.get("uniqueViewCount");
102 
                    itemMap.put("uniqueViewCount", ++count);
103 
                }
104 
                else {
105 
                    itemMap.put("uniqueViewCount", 1l);
106 
                }
107 
                uniqueSet.add(uniqueKey);
108 
            }
109 
        }
110 
 
111 
        query = new Query("DataLog");
112 
        query.addFilter("eventType", Query.FilterOperator.EQUAL, "ADD_TO_CART");
113 
        query.addFilter("date", Query.FilterOperator.GREATER_THAN_OR_EQUAL, fromDate);
114 
        query.addFilter("date", Query.FilterOperator.LESS_THAN, toDate);
115 
        pq = datastore.prepare(query);
116 
        uniqueSet = new HashSet<String>();
117 
        for (Entity result : pq.asIterable()) {
118 
            String sessionId = (String)result.getProperty("sessionId");
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 {
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)) {
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 {
144 
                        itemMap.put("uniqueAddToCartCount", 1l);
145 
                    }
146 
                    uniqueSet.add(uniqueKey);
147 
                }
148 
            }
149 
        }
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")) {
160 
                Long catalogItemId = itemsMap.get(itemId).getCatalogId();
161 
                if (itemsResultMap.containsKey(catalogItemId)) {
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 
                    }
167 
                    else {
168 
                        itemMap.put("DeleteFromCartCount", 1l);
169 
                    }
170 
                }
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 {
184 
                        itemMap.put("uniqueDeleteFromCartCount", 1l);
185 
                    }
186 
                    uniqueSet.add(uniqueKey);
187 
                }
188 
            }
189 
        }
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 {
207 
                        itemMap.put("AddToResearchCount", 1l);
208 
                    }
209 
                }
210 
                else {
211 
                    Map<String, Long> itemMap = new HashMap<String, Long>();
212 
                    itemMap.put("AddToResearchCount", 1l);
213 
                    itemsResultMap.put(catalogItemId, itemMap);
214 
                }
215 
                String uniqueKey = sessionId + catalogItemId;
216 
                if (!uniqueSet.contains(uniqueKey)) {
217 
                    Map<String, Long> itemMap = itemsResultMap.get(catalogItemId);
218 
                    if (itemMap.containsKey("uniqueAddToResearchCount")) {
219 
                        Long count = itemMap.get("uniqueAddToResearchCount");
220 
                        itemMap.put("uniqueAddToResearchCount", ++count);
221 
                    }
222 
                    else {
223 
                        itemMap.put("uniqueAddToResearchCount", 1l);
224 
                    }
225 
                    uniqueSet.add(uniqueKey);
226 
                }
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)) {
240 
                    Map<String, Long> itemMap = itemsResultMap.get(catalogItemId);
241 
                    if (itemMap.containsKey("DeleteFromResearchCount")) {
242 
                        Long count = itemMap.get("DeleteFromResearchCount");
243 
                        itemMap.put("DeleteFromResearchCount", ++count);
244 
                    }
245 
                    else {
246 
                        itemMap.put("DeleteFromResearchCount", 1l);
247 
                    }
248 
                }
249 
                else {
250 
                    Map<String, Long> itemMap = new HashMap<String, Long>();
251 
                    itemMap.put("DeleteFromResearchCount", 1l);
252 
                    itemsResultMap.put(catalogItemId, itemMap);
253 
                }
254 
                String uniqueKey = sessionId + catalogItemId;
255 
                if (!uniqueSet.contains(uniqueKey)) {
256 
                    Map<String, Long> itemMap = itemsResultMap.get(catalogItemId);
257 
                    if (itemMap.containsKey("uniqueDeleteFromResearchCount")) {
258 
                        Long count = itemMap.get("uniqueDeleteFromResearchCount");
259 
                        itemMap.put("uniqueDeleteFromResearchCount", ++count);
260 
                    }
261 
                    else {
262 
                        itemMap.put("uniqueDeleteFromResearchCount", 1l);
263 
                    }
264 
                    uniqueSet.add(uniqueKey);
265 
                }
266 
            }
267 
        }
268 
 
3122 vikas 269 
        List<ItemActivity> itemActivities = new ArrayList<ItemActivity>();
270 
        ItemActivityRepository itemActivityRepository = new ItemActivityRepository();
3116 vikas 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"));
3141 vikas 283 
            itemActivity.setDeleteFromResearch(itemMap.get("DeleteFromResearchCount"));
3116 vikas 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 
 
3122 vikas 291 
            itemActivities.add(itemActivity);
3116 vikas 292 
        }
3122 vikas 293 
        itemActivityRepository.createAll(itemActivities);
3116 vikas 294 
    }
295 
 
296 
    public void doGet(HttpServletRequest req, HttpServletResponse resp) {
297 
        doPost(req, resp);
298 
    }
299 
}