Subversion Repositories SmartDukaan

package in.shop2020.web;

import in.shop2020.model.Item;
import in.shop2020.model.ItemActivity;
import in.shop2020.server.ItemActivityRepository;
import in.shop2020.server.ItemRepository;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Date;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
import java.util.TimeZone;

import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import com.google.appengine.api.datastore.DatastoreService;
import com.google.appengine.api.datastore.DatastoreServiceFactory;
import com.google.appengine.api.datastore.Entity;
import com.google.appengine.api.datastore.PreparedQuery;
import com.google.appengine.api.datastore.Query;

public class DailyAggregatorServlet extends HttpServlet {
    private static final long serialVersionUID = -8236918415987438049L;

    public void doPost(HttpServletRequest req, HttpServletResponse resp) {
        SimpleDateFormat sdf = new SimpleDateFormat("yyyyMMdd");
        Calendar cal = Calendar.getInstance(TimeZone.getTimeZone("IST"));
        String dateStr = req.getParameter("date");  
        if (dateStr != null && !dateStr.isEmpty()) {
            try {
                cal.setTime(sdf.parse(dateStr));
                cal.add(Calendar.DAY_OF_MONTH, 1);
            } catch (ParseException e) {
                e.printStackTrace();
            }
        }
        cal.set(Calendar.HOUR_OF_DAY, 0);  
        cal.set(Calendar.MINUTE, 0);  
        cal.set(Calendar.SECOND, 0);  
        cal.set(Calendar.MILLISECOND, 0);
        Date toDate = cal.getTime();
        cal.add(Calendar.DAY_OF_MONTH, -1);
        Date fromDate = cal.getTime();
        
        ItemRepository itemRepository = new ItemRepository();
        List<Item> items = itemRepository.getAll();
        Map<Long, Item> itemsMap = new HashMap<Long, Item>();
        Map<Long, Item> itemsCatalogIdMap = new HashMap<Long, Item>();
        Map<String, Item> itemsNameMap = new HashMap<String, Item>();
        Map<Long, Map<String, Long>> itemsResultMap = new HashMap<Long, Map<String, Long>>();
        for (Item item : items) {
            itemsMap.put(item.getId(), item);
            itemsCatalogIdMap.put(item.getCatalogId(), item);
            itemsNameMap.put(item.getName().trim(), item);
        }
        
        DatastoreService datastore = DatastoreServiceFactory.getDatastoreService();
        Query query = new Query("DataLog");
        query.addFilter("eventType", Query.FilterOperator.EQUAL, "PRODUCT_VIEW");
        query.addFilter("date", Query.FilterOperator.GREATER_THAN_OR_EQUAL, fromDate);
        query.addFilter("date", Query.FilterOperator.LESS_THAN, toDate);
        PreparedQuery pq = datastore.prepare(query);
        Set<String> uniqueSet = new HashSet<String>();
        for (Entity result : pq.asIterable()) {
            String sessionId = (String)result.getProperty("sessionId");
            Long catalogItemId = (Long)result.getProperty("itemId");
            if(catalogItemId == null) {
                String name = (String)result.getProperty("productName");
                if (itemsNameMap.containsKey(name.trim())) {
                    catalogItemId = itemsNameMap.get(name.trim()).getCatalogId();
                }
            }
            if (itemsResultMap.containsKey(catalogItemId)) {
                Map<String, Long> itemMap = itemsResultMap.get(catalogItemId);
                if (itemMap.containsKey("ViewCount")) {
                    Long count = itemMap.get("ViewCount");
                    itemMap.put("ViewCount", ++count);
                }
                else {
                    itemMap.put("ViewCount", 1l);
                }
            }
            else {
                Map<String, Long> itemMap = new HashMap<String, Long>();
                itemMap.put("ViewCount", 1l);
                itemsResultMap.put(catalogItemId, itemMap);
            }
            String uniqueKey = sessionId + catalogItemId;
            if (!uniqueSet.contains(uniqueKey)) {
                Map<String, Long> itemMap = itemsResultMap.get(catalogItemId);
                if (itemMap.containsKey("uniqueViewCount")) {
                    Long count = itemMap.get("uniqueViewCount");
                    itemMap.put("uniqueViewCount", ++count);
                }
                else {
                    itemMap.put("uniqueViewCount", 1l);
                }
                uniqueSet.add(uniqueKey);
            }
        }
        
        query = new Query("DataLog");
        query.addFilter("eventType", Query.FilterOperator.EQUAL, "ADD_TO_CART");
        query.addFilter("date", Query.FilterOperator.GREATER_THAN_OR_EQUAL, fromDate);
        query.addFilter("date", Query.FilterOperator.LESS_THAN, toDate);
        pq = datastore.prepare(query);
        uniqueSet = new HashSet<String>();
        for (Entity result : pq.asIterable()) {
            String sessionId = (String)result.getProperty("sessionId");
            for (Long itemId : (List<Long>)result.getProperty("itemIds")) {
                Long catalogItemId = itemsMap.get(itemId).getCatalogId();
                if (itemsResultMap.containsKey(catalogItemId)) {
                    Map<String, Long> itemMap = itemsResultMap.get(catalogItemId);
                    if (itemMap.containsKey("AddToCartCount")) {
                        Long count = itemMap.get("AddToCartCount");
                        itemMap.put("AddToCartCount", ++count);
                    }
                    else {
                        itemMap.put("AddToCartCount", 1l);
                    }
                }
                else {
                    Map<String, Long> itemMap = new HashMap<String, Long>();
                    itemMap.put("AddToCartCount", 1l);
                    itemsResultMap.put(catalogItemId, itemMap);
                }
                String uniqueKey = sessionId + catalogItemId;
                if (!uniqueSet.contains(uniqueKey)) {
                    Map<String, Long> itemMap = itemsResultMap.get(catalogItemId);
                    if (itemMap.containsKey("uniqueAddToCartCount")) {
                        Long count = itemMap.get("uniqueAddToCartCount");
                        itemMap.put("uniqueAddToCartCount", ++count);
                    }
                    else {
                        itemMap.put("uniqueAddToCartCount", 1l);
                    }
                    uniqueSet.add(uniqueKey);
                }
            }
        }
        
        query = new Query("DataLog");
        query.addFilter("eventType", Query.FilterOperator.EQUAL, "DELETE_FROM_CART");
        query.addFilter("date", Query.FilterOperator.GREATER_THAN_OR_EQUAL, fromDate);
        query.addFilter("date", Query.FilterOperator.LESS_THAN, toDate);
        pq = datastore.prepare(query);
        uniqueSet = new HashSet<String>();
        for (Entity result : pq.asIterable()) {
            String sessionId = (String)result.getProperty("sessionId");
            for (Long itemId : (List<Long>)result.getProperty("itemIds")) {
                Long catalogItemId = itemsMap.get(itemId).getCatalogId();
                if (itemsResultMap.containsKey(catalogItemId)) {
                    Map<String, Long> itemMap = itemsResultMap.get(catalogItemId);
                    if (itemMap.containsKey("DeleteFromCartCount")) {
                        Long count = itemMap.get("DeleteFromCartCount");
                        itemMap.put("DeleteFromCartCount", ++count);
                    }
                    else {
                        itemMap.put("DeleteFromCartCount", 1l);
                    }
                }
                else {
                    Map<String, Long> itemMap = new HashMap<String, Long>();
                    itemMap.put("DeleteFromCartCount", 1l);
                    itemsResultMap.put(catalogItemId, itemMap);
                }
                String uniqueKey = sessionId + catalogItemId;
                if (!uniqueSet.contains(uniqueKey)) {
                    Map<String, Long> itemMap = itemsResultMap.get(catalogItemId);
                    if (itemMap.containsKey("uniqueDeleteFromCartCount")) {
                        Long count = itemMap.get("uniqueDeleteFromCartCount");
                        itemMap.put("uniqueDeleteFromCartCount", ++count);
                    }
                    else {
                        itemMap.put("uniqueDeleteFromCartCount", 1l);
                    }
                    uniqueSet.add(uniqueKey);
                }
            }
        }
        
        query = new Query("DataLog");
        query.addFilter("eventType", Query.FilterOperator.EQUAL, "RESEARCH_ADD");
        query.addFilter("date", Query.FilterOperator.GREATER_THAN_OR_EQUAL, fromDate);
        query.addFilter("date", Query.FilterOperator.LESS_THAN, toDate);
        pq = datastore.prepare(query);
        uniqueSet = new HashSet<String>();
        for (Entity result : pq.asIterable()) {
            String sessionId = (String)result.getProperty("sessionId");
            for (Long catalogItemId : (List<Long>)result.getProperty("itemIds")) {
                if (itemsResultMap.containsKey(catalogItemId)) {
                    Map<String, Long> itemMap = itemsResultMap.get(catalogItemId);
                    if (itemMap.containsKey("AddToResearchCount")) {
                        Long count = itemMap.get("AddToResearchCount");
                        itemMap.put("AddToResearchCount", ++count);
                    }
                    else {
                        itemMap.put("AddToResearchCount", 1l);
                    }
                }
                else {
                    Map<String, Long> itemMap = new HashMap<String, Long>();
                    itemMap.put("AddToResearchCount", 1l);
                    itemsResultMap.put(catalogItemId, itemMap);
                }
                String uniqueKey = sessionId + catalogItemId;
                if (!uniqueSet.contains(uniqueKey)) {
                    Map<String, Long> itemMap = itemsResultMap.get(catalogItemId);
                    if (itemMap.containsKey("uniqueAddToResearchCount")) {
                        Long count = itemMap.get("uniqueAddToResearchCount");
                        itemMap.put("uniqueAddToResearchCount", ++count);
                    }
                    else {
                        itemMap.put("uniqueAddToResearchCount", 1l);
                    }
                    uniqueSet.add(uniqueKey);
                }
            }
        }
        
        query = new Query("DataLog");
        query.addFilter("eventType", Query.FilterOperator.EQUAL, "RESEARCH_DELETE");
        query.addFilter("date", Query.FilterOperator.GREATER_THAN_OR_EQUAL, fromDate);
        query.addFilter("date", Query.FilterOperator.LESS_THAN, toDate);
        pq = datastore.prepare(query);
        uniqueSet = new HashSet<String>();
        for (Entity result : pq.asIterable()) {
            String sessionId = (String)result.getProperty("sessionId");
            for (Long catalogItemId : (List<Long>)result.getProperty("itemIds")) {
                if (itemsResultMap.containsKey(catalogItemId)) {
                    Map<String, Long> itemMap = itemsResultMap.get(catalogItemId);
                    if (itemMap.containsKey("DeleteFromResearchCount")) {
                        Long count = itemMap.get("DeleteFromResearchCount");
                        itemMap.put("DeleteFromResearchCount", ++count);
                    }
                    else {
                        itemMap.put("DeleteFromResearchCount", 1l);
                    }
                }
                else {
                    Map<String, Long> itemMap = new HashMap<String, Long>();
                    itemMap.put("DeleteFromResearchCount", 1l);
                    itemsResultMap.put(catalogItemId, itemMap);
                }
                String uniqueKey = sessionId + catalogItemId;
                if (!uniqueSet.contains(uniqueKey)) {
                    Map<String, Long> itemMap = itemsResultMap.get(catalogItemId);
                    if (itemMap.containsKey("uniqueDeleteFromResearchCount")) {
                        Long count = itemMap.get("uniqueDeleteFromResearchCount");
                        itemMap.put("uniqueDeleteFromResearchCount", ++count);
                    }
                    else {
                        itemMap.put("uniqueDeleteFromResearchCount", 1l);
                    }
                    uniqueSet.add(uniqueKey);
                }
            }
        }
        
        List<ItemActivity> itemActivities = new ArrayList<ItemActivity>();
        ItemActivityRepository itemActivityRepository = new ItemActivityRepository();
        for (Entry<Long, Map<String, Long>> entry : itemsResultMap.entrySet()) {
            Long catalogItemId = (Long)entry.getKey();
            Map<String, Long> itemMap = (Map<String, Long>)entry.getValue();
            
            ItemActivity itemActivity = new ItemActivity();
            itemActivity.setCatalogId(catalogItemId);
            itemActivity.setDate(fromDate);
            
            itemActivity.setView(itemMap.get("ViewCount"));
            itemActivity.setAddToCart(itemMap.get("AddToCartCount"));
            itemActivity.setAddToResearch(itemMap.get("AddToResearchCount"));
            itemActivity.setDeleteFromCart(itemMap.get("DeleteFromCartCount"));
            itemActivity.setDeleteFromResearch(itemMap.get("DeleteFromResearchCount"));
            
            itemActivity.setUniqueView(itemMap.get("uniqueViewCount"));
            itemActivity.setUniqueAddToCart(itemMap.get("uniqueAddToCartCount"));
            itemActivity.setUniqueAddToResearch(itemMap.get("uniqueAddToResearchCount"));
            itemActivity.setUniqueDeleteFromCart(itemMap.get("uniqueDeleteFromCartCount"));
            itemActivity.setUniqueDeleteFromResearch(itemMap.get("uniqueDeleteFromResearchCount"));
            
            itemActivities.add(itemActivity);
        }
        itemActivityRepository.createAll(itemActivities);
    }
    
    public void doGet(HttpServletRequest req, HttpServletResponse resp) {
        doPost(req, resp);
    }
}