Subversion Repositories SmartDukaan

package in.shop2020.web;

import in.shop2020.model.ProductSearchActivity;
import in.shop2020.model.SearchMetadata;
import in.shop2020.server.ProductSearchActivityRepository;

import java.net.URLDecoder;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Calendar;
import java.util.Date;
import java.util.Hashtable;
import java.util.List;
import java.util.Map;
import java.util.TimeZone;
import java.util.logging.Level;
import java.util.logging.Logger;

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 DailySearchQueryAggregatorServlet extends HttpServlet {

        private static final long serialVersionUID = -5899643747361932442L;
        private static Logger logger = Logger.getLogger(DailySearchQueryAggregatorServlet.class.getName());
        Map<String,SearchMetadata> productSearchFreq = new Hashtable<String,SearchMetadata>();
        Map<String,Double> searchClickMap = new Hashtable<String,Double>();
        private Date toDate = null;
        private Date fromDate = null;
        
        
        public void doGet(HttpServletRequest req, HttpServletResponse resp) {
        doPost(req, resp);
    }
        
        
        public void doPost(HttpServletRequest req, HttpServletResponse resp) {
                productSearchFreq = new Hashtable<String,SearchMetadata>();
                Calendar cal = Calendar.getInstance(TimeZone.getTimeZone("IST"));
                SimpleDateFormat sdf = new SimpleDateFormat("yyyyMMdd");
                sdf.setTimeZone(TimeZone.getTimeZone("IST"));
        String dateStr = req.getParameter("date");
        if (dateStr != null && !dateStr.isEmpty()) {
            try {
                fromDate = sdf.parse(dateStr);
                cal.setTime(fromDate);
                cal.add(Calendar.DATE, 1);
                toDate = cal.getTime();
            } catch (ParseException e) {
                e.printStackTrace();
            }
        }else {
                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.DATE, -1);
                fromDate = cal.getTime();
        }
                
                logger.warning("toDate = "+toDate + "fromDate" + fromDate);
                //logger.warning("Product Search Frequency " + productSearchFreq.toString());
        
        DatastoreService datastore = DatastoreServiceFactory.getDatastoreService();
        Query query = new Query("DataLog");
        query.addFilter("eventType", Query.FilterOperator.IN,Arrays.asList("PRODUCT_SEARCH","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);
        
        for (Entity result : pq.asIterable()) {
                //logger.warning(result.toString());
                if(result.getProperty("eventType").equals("PRODUCT_SEARCH")){
                        Map<String,SearchMetadata>  updatedSearchFreqMap = populateSearchDataMap(productSearchFreq, result);
                        if(updatedSearchFreqMap!=null){
                                productSearchFreq = updatedSearchFreqMap;
                        }
                }else{
                        //Calculating the frequency of ProductViews originating from ProductSearch
                        Map<String,Double> updatedClickMap = populateSearchClickMap(searchClickMap,result);
                        if(updatedClickMap!=null) {
                                searchClickMap = updatedClickMap;
                        }
                }
        }
        
        List<ProductSearchActivity> searchActivities = new ArrayList<ProductSearchActivity>();
        ProductSearchActivityRepository searchActivityRepository = new ProductSearchActivityRepository();
        
        //logger.warning(productSearchFreq.toString());
        
        for(String queryString : productSearchFreq.keySet()){
                ProductSearchActivity  searchActivity = new ProductSearchActivity();
                searchActivity.setQueryString(queryString);
                searchActivity.setDate(fromDate);
                searchActivity.setSearchCount(productSearchFreq.get(queryString).getTotalSearches());
                
                        
                        searchActivity.setSessionCountForQuery(new Long((productSearchFreq.get(queryString).getSessionIds()==null ? 0 : productSearchFreq.get(queryString).getSessionIds().size())));

                        Long tempSum = new Long(0);
                        for(Long numOfSearchResults : productSearchFreq.get(queryString).getSearchResults()){
                                tempSum+=numOfSearchResults;
                        }
                        searchActivity.setAvgNumResults(new Integer((int) (tempSum/productSearchFreq.get(queryString).getTotalSearches())));
                        searchActivity.setSearchResultClickedCount((long) ((searchClickMap.get(queryString))==null ? 0 : searchClickMap.get(queryString)));
                        
                        Double searchConversionRate = (((searchClickMap.get(queryString))==null ? 0 : searchClickMap.get(queryString))*100/(productSearchFreq.get(queryString).getTotalSearches()));
                        searchConversionRate = ((double)((long)(searchConversionRate*100)))/100; //Truncating to 2 decimal places
                        searchActivity.setSearchConvRate(searchConversionRate);
                        searchActivities.add(searchActivity);
                        //logger.warning(searchActivity.toString());
        }
        //logger.warning(searchActivities.toString());
        searchActivityRepository.createAll(searchActivities);
        }
        
        
        private Map<String,SearchMetadata> populateSearchDataMap(Map<String,SearchMetadata> productSearchFreq, Entity result){
                String searchString = (String)result.getProperty("query");
                if(searchString!=null){
                        if(productSearchFreq.containsKey(searchString)){
                                try{
                                        SearchMetadata searchObject = productSearchFreq.get(searchString);
                                        
                                        //Setting number of searches
                                        searchObject.setTotalSearches(searchObject.getTotalSearches()+1);
                                
                                        //setting number of search results
                                        List<Long> numSearchResults =searchObject.getSearchResults();
                                        numSearchResults.add((Long)result.getProperty("totalResults"));
                                        searchObject.setSearchResults(numSearchResults);
                                        
                                        //Setting frequency by category
                                        /*String categoryId = Category.findByValue(Integer.parseInt(result.getProperty("categoryId").toString())).toString();
                                        if(searchObject.getcategoryFrequency().containsKey(categoryId)) {
                                                searchObject.getcategoryFrequency().put(categoryId, (searchObject.getcategoryFrequency().get(categoryId))+1);
                                        }else {
                                                searchObject.getcategoryFrequency().put(categoryId,Long.parseLong("1"));
                                        }*/
                                        
                                        //Storing session Id of query
                                        if(!searchObject.getSessionIds().contains(result.getProperty("sessionId"))){
                                                searchObject.getSessionIds().add(result.getProperty("sessionId"));
                                        }
                                        
                                        productSearchFreq.put(searchString, searchObject);
                                }catch(Exception ex){
                                        logger.log(Level.SEVERE, "Error while populating SearchQueryMap for an existing query");
                                        return null;
                                }
                        }else{
                                try {
                                        SearchMetadata searchObject = new SearchMetadata();
                                        
                                        //Setting frequency by category
                                        /*String categoryId = Category.findByValue(Integer.parseInt(result.getProperty("categoryId").toString())).toString();
                                        Map<String, Long> categoryFrequency = new Hashtable<String, Long>();
                                        categoryFrequency.put(categoryId,Long.parseLong("1"));
                                        searchObject.setcategoryFrequency(categoryFrequency);*/
                                        
                                        //Setting number of searches
                                        searchObject.setTotalSearches(Long.parseLong("1"));
                                        
                                        //setting number of search results
                                        List<Long> numSearchResults = new ArrayList<Long>();
                                        numSearchResults.add((Long)result.getProperty("totalResults"));
                                        searchObject.setSearchResults(numSearchResults);
                                        
                                        //Storing session Id of query
                                        List<Object> sessionList = new ArrayList<Object>();
                                        sessionList.add(result.getProperty("sessionId"));
                                        searchObject.setSessionIds(sessionList);
                
                                        productSearchFreq.put(searchString,searchObject);
                                }catch(Exception ex) {
                                        logger.log(Level.SEVERE, "Exception while populating searchQueryMap for new query");
                                        return null;
                                }
                        }
                }
                return productSearchFreq;
        }

        
        private Map<String,Double> populateSearchClickMap(Map<String,Double> searchClickMap, Entity result){
                String refererUrl = (String)result.getProperty("refererUrl");
                if(refererUrl!=null){
                        if(refererUrl.contains("search?")){
                                try{
                                        String clickQuery = "";
                                        refererUrl = URLDecoder.decode(refererUrl);
                                        clickQuery = refererUrl.split("q=")[1].split("&")[0];
                                        if(searchClickMap.containsKey(clickQuery)){
                                                searchClickMap.put(clickQuery, searchClickMap.get(clickQuery)+1);
                                        }else{
                                                searchClickMap.put(clickQuery, Double.parseDouble("1"));
                                        }
                                }catch(Exception ex){
                                        logger.log(Level.SEVERE, "Error while populating SearchClickMap for refererUrl : "+refererUrl);
                                }
                        }
                }
                return searchClickMap;
        }
        
}