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;

    private static final String KIND = "DataLog";

    private static final String SESSION_ID_FILED = "sessionId";

    private static final String ITEMID_FILED = "itemId";

    private static final String ITEMIDS_FILED = "itemIds";

    private static final String PRODUCTNAME_FILED = "productName";

    private static final String EVENTTYPE_FILED = "eventType";

    private static final String DATE_FILED = "date";

    private static final String PRODUCT_VIEW_EVENT = "PRODUCT_VIEW";

    private static final String ADD_TO_CART_EVENT = "ADD_TO_CART";

    private static final String DELETE_FROM_CART_EVENT = "DELETE_FROM_CART";

    private static final String RESEARCH_ADD_EVENT = "RESEARCH_ADD";

    private static final String RESEARCH_DELETE_EVENT = "RESEARCH_DELETE";

    private static final String SHIPPING_ACCESS_EVENT = "SHIPPINIG_ACCESS";

    private static final String PAYMENT_SUCCESS_EVENT = "PAYMENT_SUCCESS";

    private static final String ORDER_CREATION_EVENT = "ORDER_CREATION";

    private static final String PAYMENT_FAILURE_EVENT = "PAYMENT_FAILURE";

    private static final String PROCEED_TO_PAY_EVENT = "PROCEED_TO_PAY";

    private static final String VIEW_COUNT_KEY = "ViewCount";

    private static final String UNIQUE_VIEW_COUNT_KEY = "UniqueViewCount";

    private static final String ADD_TO_CART_COUNT_KEY = "AddToCartCount";

    private static final String UNIQUE_ADD_TO_CART_COUNT_KEY = "UniqueAddToCartCount";

    private static final String DELETE_FROM_CART_COUNT_KEY = "DeleteFromCartCount";

    private static final String UNIQUE_DELETE_FROM_CART_COUNT_KEY = "UniqueDeleteFromCartCount";

    private static final String ADD_TO_RESEARCH_COUNT_KEY = "AddToResearchCount";

    private static final String UNIQUE_ADD_TO_RESEARCH_COUNT_KEY = "UniqueAddToResearchCount";

    private static final String DELETE_FROM_RESEARCH_COUNT_KEY = "DeleteFromResearchCount";

    private static final String UNIQUE_DELETE_FROM_RESEARCH_COUNT_KEY = "UniqueDeleteFromResearchCount";

    private static final String SHIPPING_ACCESS_COUNT_KEY = "ShippingAccessCount";

    private static final String UNIQUE_SHIPPING_ACCESS_COUNT_KEY = "UniqueShippingAccessCount";

    private static final String PAYMENT_SUCCESS_COUNT_KEY = "PaymentSuccessCount";

    private static final String UNIQUE_PAYMENT_SUCCESS_COUNT_KEY = "UniquePaymentSuccessCount";

    private static final String ORDER_CREATION_COUNT_KEY = "OrderCreationCount";

    private static final String UNIQUE_ORDER_CREATION_COUNT_KEY = "UniqueOrderCreationCount";

    private static final String PAYMENT_FAILURE_COUNT_KEY = "PaymentFailureCount";

    private static final String UNIQUE_PAYMENT_FAILURE_COUNT_KEY = "UniquePaymentFailureCount";

    private static final String PROCEED_TO_PAY_COUNT_KEY = "ProceedToPayCount";

    private static final String UNIQUE_PROCEED_TO_PAY_COUNT_KEY = "UniqueProceedToPayCount";

    private Map<Long, Item> itemsMap = new HashMap<Long, Item>();

    private Map<Long, Item> itemsCatalogIdMap = new HashMap<Long, Item>();

    private Map<String, Item> itemsNameMap = new HashMap<String, Item>();

    private Map<Long, Map<String, Long>> itemsResultMap = new HashMap<Long, Map<String, Long>>();

    private Date fromDate;

    private Date toDate;

    private DatastoreService datastore;

    public void doPost(HttpServletRequest req, HttpServletResponse resp) {

        datastore = DatastoreServiceFactory.getDatastoreService();

        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);

        toDate = cal.getTime();

        cal.add(Calendar.DAY_OF_MONTH, -1);

        fromDate = cal.getTime();

        ItemRepository itemRepository = new ItemRepository();

        List<Item> items = itemRepository.getAll();

        for (Item item : items) {

            itemsMap.put(item.getId(), item);

            itemsCatalogIdMap.put(item.getCatalogId(), item);

            itemsNameMap.put(item.getName().trim(), item);

        }

        UpdateViewCount(PRODUCT_VIEW_EVENT, VIEW_COUNT_KEY, UNIQUE_VIEW_COUNT_KEY);

        UpdateItemIdEventCount(ADD_TO_CART_EVENT, ADD_TO_CART_COUNT_KEY, UNIQUE_ADD_TO_CART_COUNT_KEY, false);

        UpdateItemIdEventCount(DELETE_FROM_CART_EVENT, DELETE_FROM_CART_COUNT_KEY, UNIQUE_DELETE_FROM_CART_COUNT_KEY, false);

        UpdateItemIdEventCount(RESEARCH_ADD_EVENT, ADD_TO_RESEARCH_COUNT_KEY, UNIQUE_ADD_TO_RESEARCH_COUNT_KEY, true);

        UpdateItemIdEventCount(RESEARCH_DELETE_EVENT, DELETE_FROM_RESEARCH_COUNT_KEY, UNIQUE_DELETE_FROM_RESEARCH_COUNT_KEY, true);

        UpdateItemIdEventCount(SHIPPING_ACCESS_EVENT, SHIPPING_ACCESS_COUNT_KEY, UNIQUE_SHIPPING_ACCESS_COUNT_KEY, false);

        UpdateItemIdEventCount(PAYMENT_SUCCESS_EVENT, PAYMENT_SUCCESS_COUNT_KEY, UNIQUE_PAYMENT_SUCCESS_COUNT_KEY, false);

        UpdateItemIdEventCount(ORDER_CREATION_EVENT, ORDER_CREATION_COUNT_KEY, UNIQUE_ORDER_CREATION_COUNT_KEY, false);

        UpdateItemIdEventCount(PAYMENT_FAILURE_EVENT, PAYMENT_FAILURE_COUNT_KEY, UNIQUE_PAYMENT_FAILURE_COUNT_KEY, false);

        UpdateItemIdEventCount(PROCEED_TO_PAY_EVENT, PROCEED_TO_PAY_COUNT_KEY, UNIQUE_PROCEED_TO_PAY_COUNT_KEY, false);

        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(VIEW_COUNT_KEY));

            itemActivity.setAddToCart(itemMap.get(ADD_TO_CART_COUNT_KEY));

            itemActivity.setAddToResearch(itemMap.get(ADD_TO_RESEARCH_COUNT_KEY));

            itemActivity.setDeleteFromCart(itemMap.get(DELETE_FROM_CART_COUNT_KEY));

            itemActivity.setDeleteFromResearch(itemMap.get(DELETE_FROM_RESEARCH_COUNT_KEY));

            itemActivity.setShippingAccess(itemMap.get(SHIPPING_ACCESS_COUNT_KEY));

            itemActivity.setPaymentSuccess(itemMap.get(PAYMENT_SUCCESS_COUNT_KEY));

            itemActivity.setOrderCreation(itemMap.get(ORDER_CREATION_COUNT_KEY));

            itemActivity.setPaymentFailure(itemMap.get(PAYMENT_FAILURE_COUNT_KEY));

            itemActivity.setProceedToPay(itemMap.get(PROCEED_TO_PAY_COUNT_KEY));

            itemActivity.setUniqueView(itemMap.get(UNIQUE_VIEW_COUNT_KEY));

            itemActivity.setUniqueAddToCart(itemMap.get(UNIQUE_ADD_TO_CART_COUNT_KEY));

            itemActivity.setUniqueAddToResearch(itemMap.get(UNIQUE_ADD_TO_RESEARCH_COUNT_KEY));

            itemActivity.setUniqueDeleteFromCart(itemMap.get(UNIQUE_DELETE_FROM_CART_COUNT_KEY));

            itemActivity.setUniqueDeleteFromResearch(itemMap.get(UNIQUE_ADD_TO_RESEARCH_COUNT_KEY));

            itemActivity.setUniqueShippingAccess(itemMap.get(UNIQUE_SHIPPING_ACCESS_COUNT_KEY));

            itemActivity.setUniquePaymentSuccess(itemMap.get(UNIQUE_PAYMENT_SUCCESS_COUNT_KEY));

            itemActivity.setUniqueOrderCreation(itemMap.get(UNIQUE_ORDER_CREATION_COUNT_KEY));

            itemActivity.setUniquePaymentFailure(itemMap.get(UNIQUE_PAYMENT_FAILURE_COUNT_KEY));

            itemActivity.setUniqueProceedToPay(itemMap.get(UNIQUE_PROCEED_TO_PAY_COUNT_KEY));

            itemActivities.add(itemActivity);

        }

        itemActivityRepository.createAll(itemActivities);

    }

    public void doGet(HttpServletRequest req, HttpServletResponse resp) {

        doPost(req, resp);

    }

    private void UpdateViewCount(String event, String viewCountKey, String uniqueViewCountKey) {

        Query query = new Query(KIND);

        query.addFilter(EVENTTYPE_FILED, Query.FilterOperator.EQUAL, event);

        query.addFilter(DATE_FILED, Query.FilterOperator.GREATER_THAN_OR_EQUAL, fromDate);

        query.addFilter(DATE_FILED, 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(SESSION_ID_FILED);

            Long catalogItemId = (Long)result.getProperty(ITEMID_FILED);

            if(catalogItemId == null) {

                String name = (String)result.getProperty(PRODUCTNAME_FILED);

                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(VIEW_COUNT_KEY)) {

                    Long count = itemMap.get(VIEW_COUNT_KEY);

                    itemMap.put(VIEW_COUNT_KEY, ++count);

                }

                else {

                    itemMap.put(VIEW_COUNT_KEY, 1l);

                }

            }

            else {

                Map<String, Long> itemMap = new HashMap<String, Long>();

                itemMap.put(VIEW_COUNT_KEY, 1l);

                itemsResultMap.put(catalogItemId, itemMap);

            }

            String uniqueKey = sessionId + catalogItemId;

            if (!uniqueSet.contains(uniqueKey)) {

                Map<String, Long> itemMap = itemsResultMap.get(catalogItemId);

                if (itemMap.containsKey(UNIQUE_VIEW_COUNT_KEY)) {

                    Long count = itemMap.get(UNIQUE_VIEW_COUNT_KEY);

                    itemMap.put(UNIQUE_VIEW_COUNT_KEY, ++count);

                }

                else {

                    itemMap.put(UNIQUE_VIEW_COUNT_KEY, 1l);

                }

                uniqueSet.add(uniqueKey);

            }

        }

    }

    private void UpdateItemIdEventCount(String event, String countKey, String uniqueCountKey, boolean isCatalogIdEvent) {

        Query query = new Query(KIND);

        query.addFilter(EVENTTYPE_FILED, Query.FilterOperator.EQUAL, event);

        query.addFilter(DATE_FILED, Query.FilterOperator.GREATER_THAN_OR_EQUAL, fromDate);

        query.addFilter(DATE_FILED, 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(SESSION_ID_FILED);

            List<Long> itemIds = null;

            if (!result.hasProperty(ITEMIDS_FILED)) {

                continue;

            }

            try {

                itemIds = (List<Long>)result.getProperty(ITEMIDS_FILED);

            } catch (ClassCastException e) {

                try {

                    itemIds = new ArrayList<Long>();

                    itemIds.add((Long)result.getProperty(ITEMIDS_FILED));

                }

                catch(Exception ex) {

                    log(e.getMessage());

                }

            }

            if (itemIds == null) {

                continue;

            }

            for (Long itemId : itemIds) {

                if (itemId == null) {

                    continue;

                }

                if (!isCatalogIdEvent) {

                    if (itemsMap.containsKey(itemId)) {

                        itemId = itemsMap.get(itemId).getCatalogId();

                    }

                }

                if (itemsResultMap.containsKey(itemId)) {

                    Map<String, Long> itemMap = itemsResultMap.get(itemId);

                    if (itemMap.containsKey(countKey)) {

                        Long count = itemMap.get(countKey);

                        itemMap.put(countKey, ++count);

                    }

                    else {

                        itemMap.put(countKey, 1l);

                    }

                }

                else {

                    Map<String, Long> itemMap = new HashMap<String, Long>();

                    itemMap.put(countKey, 1l);

                    itemsResultMap.put(itemId, itemMap);

                }

                String uniqueKey = sessionId + itemId;

                if (!uniqueSet.contains(uniqueKey)) {

                    Map<String, Long> itemMap = itemsResultMap.get(itemId);

                    if (itemMap.containsKey(uniqueCountKey)) {

                        Long count = itemMap.get(uniqueCountKey);

                        itemMap.put(uniqueCountKey, ++count);

                    }

                    else {

                        itemMap.put(uniqueCountKey, 1l);

                    }

                    uniqueSet.add(uniqueKey);

                }

            }

        }

    }

}