quick_search-core 0.1.1 → 0.2.0

data/app/assets/javascripts/quick_search/event_tracking.js.erb

@@ -14,6 +14,8 @@ var quickSearchEventTracking = (function () {
         logQueryDataAttribute: 'quicksearch-ga-query'
     }
 
+    <% url_helper = QuickSearch::Engine.routes.url_helpers %>
+
     // Public Methods
 
     function listenForClicks () {
@@ -53,7 +55,7 @@ var quickSearchEventTracking = (function () {
     function checkForServes(val) {
         var link = $(val).find('a');
         var eventValuesDefined = eventValues(link);
-        eventValuesDefined.category = eventValuesDefined.category + '-serve';
+        eventValuesDefined.action_type = 'serve';
         sendEventData(eventValuesDefined, '');
     }
 
@@ -67,6 +69,7 @@ var quickSearchEventTracking = (function () {
         ga_event.category = eventCategory(link);
         ga_event.action = eventAction(link);
         ga_event.label = eventLabel(link);
+	ga_event.action_type = 'click';
         return ga_event;
     }
 
@@ -142,37 +145,34 @@ var quickSearchEventTracking = (function () {
         
         // Universal Analytics
 
-        // ga('send', 'event', {
-        //     'hitType': 'event',
-        //     'eventCategory': eventValues.category,
-        //     'eventAction': eventValues.action,
-        //     'eventLabel': eventValues.label,
-        //     'hitCallback': function () {
-        //         if (link !== '') {
-        //             document.location = link;
-        //         }
-        //     }
-        // });
+        var category = eventValues.action_type == 'serve' ? eventValues.category + '-serve' : eventValues.category;
+
+
+         ga('send', {
+             hitType: 'event',
+             eventCategory: category,
+             eventAction: eventValues.action,
+             eventLabel: eventValues.label,
+             hitCallback: function () {
+                 if (link !== '') {
+                     document.location = link;
+                 }
+             }
+         });
         
-        // Classic Analytics
-        _gaq.push(['_set','hitCallback',function() {
-            if (link !== '') {
-                document.location = link;
-            }
-        }]);
-        _gaq.push(['_trackEvent', eventValues.category, eventValues.action, eventValues.label]);
     }
 
     function logEventToDatabase(eventValues) {
 
-        url = logging_url('log_event');
+        url = '<%= url_helper.log_event_path %>';
 
         return $.ajax({
             url: url,
             data: {
                 category: eventValues.category,
                 event_action: eventValues.action,
-                label: eventValues.label
+                label: eventValues.label,
+                action_type: eventValues.action_type
             }
         });
     }
@@ -204,7 +204,7 @@ var quickSearchEventTracking = (function () {
 
     function logSearchToDatabase(searchValues) {
         console.log(searchValues);
-        url = logging_url('log_search');
+        url = '<%= url_helper.log_search_path %>';
 
         return $.ajax({
             url: url,
@@ -215,17 +215,6 @@ var quickSearchEventTracking = (function () {
         });
     }
 
-    function logging_url(log_path) {
-        var pathname = window.location.pathname;
-        var url = pathname;
-        if (url.substr(-1) != '/'){
-            url += '/';
-        }
-        url += log_path;
-
-        return url;
-    }
-
 
     return {
 

data/app/assets/javascripts/quick_search/xhr_search.js

@@ -3,11 +3,15 @@ function remove_timedout_spinners(){
   $('#no-results-trying-again').remove();
 }
 
-function add_found_item_types(endpoint) {
+function add_found_item_types(endpoint, result_count) {
+  var result_count_display = "";
+  if (result_count) {
+    result_count_display = " (" + String(result_count) + ")";
+  }
   var dasherized_endpoint = endpoint.replace("_", "-")
   $('.result-types li.' + dasherized_endpoint + " .no-results-label")
     .replaceWith('<a href="#' + dasherized_endpoint + '" data-quicksearch-ga-action="' + 
-      dasherized_endpoint + '">' + I18n["en"][endpoint + "_search"]["display_name"]);
+      dasherized_endpoint + '">' + I18n["en"][endpoint + "_search"]["display_name"] + result_count_display);
 }
 
 var xhr_searches = function(){
@@ -79,4 +83,4 @@ var xhr_searches = function(){
 
 $(document).ready(function() {
   xhr_searches();
-});
+});

data/app/assets/stylesheets/quick_search/appstats.scss

@@ -5,3 +5,151 @@
 #appstats-date-filter {
   display: none;
 }
+
+// Added for appstats graph styling
+// Icon and general graph styling
+.graphGroup {
+    position: relative;
+}
+
+.graph {    
+    position: relative;
+}
+
+.graph_mini {
+    float: left;
+}
+
+.iconContainer {
+    position: absolute;
+    z-index: 1;
+}
+
+.big-icon {
+    font-size: 15em !important;
+}
+
+.big-icon::before {
+	opacity: .5;
+}
+
+.clearfix {
+    clear: both;
+}
+
+.zoom {
+    cursor: move;
+    fill: none;
+    pointer-events: all;
+}
+
+// Date range styling
+#dateButton {
+	width: 100%;
+}
+
+.inputLabel, #datePickerText, #numDays {
+	width: 50%;
+	float: left;
+	color: 	#000;
+	font-size: 20px;
+}
+
+#datePickerText {
+	width: 60%;
+}
+
+#numDays {
+	width: 40%;
+	text-align: right;
+}
+
+#from, #to, #num {
+	float: left;
+	width: 50%;
+}
+
+// Text styling
+.chartTitle {
+	text-anchor: middle;
+	fill: 	#333333;
+	font-size: 30px;
+	font-family: "Lucida Console";
+    pointer-events: none;
+}
+
+.headText, .totalText, .perDayText, .perClickText, .perServeText, .perSearchText, .perSessionText, .dataRank, .dataLabel, .dataClick, .dataServe, .dataRatio,
+.percentText, .dataPercent, .dataCumPercent, .legendText
+ {
+    text-anchor: start;
+    fill:   #000000;
+    font-size: 13px;
+    font-family: "Lucida Console";
+}
+
+.headText, .percentText, .legendText {
+    font-size: 16px;
+}
+
+.percentText, .dataPercent {
+	text-anchor: end;
+}
+
+// Data bars and areas
+.area {
+    fill: steelblue;
+    clip-path: url(#clip);
+}
+
+.areaLight {
+    fill: lightsteelblue;
+    clip-path: url(#clip);
+}
+
+.areaMini {
+    fill: steelblue;
+    clip-path: url(#clipMini);
+    pointer-events: none;
+}
+
+.dataBar, .serveBar, .clickBar, .ratioBar, .percBar, .cumPercBar, .legendRect {
+	fill: steelblue;
+}
+
+.lightLegendRect, .lightDataBar, .lightServeBar, .lightClickBar, .lightRatioBar, .lightPercBar, .lightCumPercBar,
+.dataBar:hover, .serveBar:hover,  .clickBar:hover, .ratioBar:hover, .percBar:hover,  .cumPercBar:hover {
+	fill: lightsteelblue;
+}
+
+// Background rects, borders, and lines
+.sortRect {
+	cursor: pointer;
+	opacity: 0.000001;
+}
+
+.darkBorder {
+	fill: none;
+	stroke-width: 2px;
+	stroke: #333;
+}
+
+.lightBorder {
+	fill: none;
+	stroke-width: 2px;
+	stroke: #DDD;
+}
+
+.darkBar {
+	fill: #F5F5F5;
+	stroke-width: 1px;
+	stroke: #DDD;
+}
+
+.lightBar {
+	fill: none;
+}
+
+.gridLine {
+    stroke: #333;
+    stroke-width: 1px;
+}

data/app/assets/stylesheets/quick_search/quick_search.scss

@@ -9,22 +9,6 @@
   #main-content {
     #quicksearch {
 
-        .twitter-typeahead {
-                    width: 100%;
-
-            img {
-                max-width: 79.578125px;
-            }
-            .space-container {
-                max-width: 438.3125px;
-            }
-
-            .bestbet-container {
-                padding: 0;
-            }
-
-        }
-
         h3 {
             padding-top: 0;
             font-weight: normal;

data/app/controllers/concerns/quick_search/doi_trap.rb

@@ -8,7 +8,7 @@ module QuickSearch::DoiTrap
   def doi_trap
     unless params_q_scrubbed.nil?
       if is_a_doi?(doi_query)
-        Event.create(category: 'doi-trap', action: doi_query, label: '')
+        Event.create(category: 'doi-trap', query: doi_query, action: 'click')
         redirect_to doi_loaded_link
         # Alternately insert a loaded link into the results interface
         # @doi_loaded_link = loaded_link

data/app/controllers/quick_search/appstats_controller.rb

@@ -2,193 +2,303 @@ module QuickSearch
   class AppstatsController < ApplicationController
     include Auth
 
-    before_action :auth, :start_date, :end_date, :days_in_sample
+    before_action :auth, :get_dates, :days_in_sample
 
-    def index
-      @page_title = 'Search Statistics'
-      search_click_ratio
-    end
+    def data_general_statistics
+      @result = []
 
-    def clicks_overview
-      @page_title = 'Clicks Overview'
-      module_clicks
-      result_types_clicks
-      typeahead_clicks
-    end
+      clicks = Event.where(@range).where(:action => 'click').group(:created_at_string).order("created_at_string ASC").count(:created_at_string)
+      @result << process_time_query(clicks)
 
-    def top_searches
-      @page_title = 'Top Searches'
-      searches_count
-      searches = Search.where(page: '/').where(date_range)
-      queries = []
-      searches.each do |search|
-        queries << search["query"].downcase
-      end
-      @query_counts = Hash.new(0)
-      queries.each do |query|
-        @query_counts[query] += 1
-      end
-      @query_counts = @query_counts.sort_by {|k,v| v}.reverse[0..199]
+      sessions = Session.where(@range).group(:created_at_string).order("created_at_string ASC").count(:created_at_string)
+      @result << process_time_query(sessions)
+
+      searches = Search.where(@range).group(:created_at_string).order("created_at_string ASC").count(:created_at_string)
+      @result << process_time_query(searches)
+
+      render_data
     end
 
-    def top_spot
-      @page_title = params[:ga_top_spot_module]
-      top_spot_reporting(params[:ga_top_spot_module])
-    end
-
-    def detail
-      start_date
-      end_date
-      @category = params[:ga_category]
-      if params[:ga_scope] == 'action'
-        @action = params[:ga_action]
-        @page_title = "#{@category} (#{URI.decode(@action)})"
-        top_spot_detail(@category, @action)
-        render "top_spot_detail"
-      elsif params[:ga_scope] == 'category'
-        @page_title = "#{@category}"
-        module_click_detail(@category)
-        render "module_click_detail"
-      end
+    def data_general_table
+      @result = []
+
+      @result << { "clicks" => Event.where(@range).where(:action => 'click').count }
+      @result << { "searches" => Search.where(@range).count }
+      @result << { "sessions" => Session.where(@range).count }
+
+      render_data
     end
 
-    def realtime
+    def data_module_clicks
+      clicks = Event.where(@range).where(excluded_categories).where(:action => 'click').group(:category).order("count_category DESC").count(:category)
+      total_clicks = clicks.values.sum
+
+      @result = process_module_result_query(clicks, "module", 0, 100, total_clicks)
+
+      render_data
     end
 
-    private
+    def data_result_clicks
+      clicks = Event.where(@range).where(:category => "result-types").where(:action => 'click').group(:item).order("count_item DESC").count(:item)
+      total_clicks = clicks.values.sum
+
+      @result = process_module_result_query(clicks, "result", 0, 100, total_clicks)
 
-    def module_clicks
-      @module_clicks = Event.where(date_range).where(excluded_categories).group(:category).order("count_category DESC").count(:category)
-      @module_click_total = calculate_total_clicks(@module_clicks)
+      render_data
     end
 
-    def typeahead_clicks
-      searches_count
-      @typeahead_clicks = Event.where(date_range).where("category LIKE 'typeahead-%'").group(:category).order("count_category DESC").count(:category)
-      @typeahead_clicks_total = calculate_total_clicks(@typeahead_clicks)
+    def data_module_details
+      category = params[:category]
+      clicks = Event.where(:category => category).where(:action => 'click').where(@range).group(:item).order('count_category DESC').count(:category)
+      total_clicks = clicks.values.sum
+
+      @result = process_module_result_query(clicks, "module_details", category, 15, total_clicks)
+
+      render_data
     end
 
-    def result_types_clicks
-      @result_types_clicks = Event.where(date_range).where(:category => "result-types").group(:action).order("count_action DESC").count(:action)
-      @result_types_click_total = calculate_total_clicks(@result_types_clicks)
+    def data_top_searches
+      num_results = params[:num_results] ? params[:num_results].to_i : 20
+      searches = Search.where(:page => '/').where(@range).group(:query).order('count_query DESC').count(:query)
+      total_searches = searches.sum {|k,v| v}
+
+      @result = process_searches_query(searches, num_results, total_searches)
+
+      render_data
     end
 
-    def calculate_total_clicks(clicks)
-      click_total = 0
-      clicks.each do |module_name, click_count|
-        click_total += click_count
-      end
+    def data_spelling_suggestions
+      num_results = params[:num_results] ? params[:num_results].to_i : 20
+      serves = Event.where(@range).where(:category => "spelling-suggestion", :action => 'serve').group(:item).order("count_category DESC").count(:category)
+      clicks = Event.where(@range).where(:category => "spelling-suggestion", :action => 'click').group(:item).count(:category)
 
-      click_total
+      @result = process_spelling_best_bets_query(serves, clicks, "spelling_suggestion", 0, num_results)
+
+      render_data
     end
 
-    def searches_count
-      @searches_count = Search.where(page: '/').where(date_range).count
+    def data_spelling_details
+      item = params[:item]
+      serves = Event.where(@range).where(:category => "spelling-suggestion", :action => 'serve', :item => item).group(:query).order("count_query DESC").count(:query)
+      clicks = Event.where(@range).where(:category => "spelling-suggestion", :action => 'click', :item => item).group(:query).count(:query)
+
+      @result = process_spelling_best_bets_query(serves, clicks, "spelling_details", item, 15)
+
+      render_data
     end
 
-    def search_click_ratio
-      searches_count
-      @clicks_count = Event.where(excluded_categories).where(date_range).count
-      @click_serve_ratio = (@clicks_count / @searches_count.to_f)*100
+    def data_best_bets
+      num_results = params[:num_results] ? params[:num_results].to_i : 20
+      serves = Event.where(@range).where(:category => "best-bets-regular", :action => 'serve').group(:item).order("count_category DESC").count(:category)
+      clicks = Event.where(@range).where(:category => "best-bets-regular", :action => 'click').group(:item).count(:category)
+
+      @result = process_spelling_best_bets_query(serves, clicks, "best_bet", 0, num_results)
+
+      render_data
     end
 
-    def top_spot_reporting(top_spot_module)
-      reports = {"best-bets-regular" => {:category_title => "Best Bets Regular"},
-                 "best-bets-algorithmic-journal" => {:category_title => "Journal Algorithmic Best Bets"},
-                 "best-bets-algorithmic-database" => {:category_title => "Database Algorithmic Best Bets"},
-                 "best-bets-course-tools" => {:category_title => "Course Tools Best Bets"},
-                 "spelling-suggestion" => {:category_title => "Spelling Suggestions"}
-               }
-      @top_spot_reporting = []
-      top_spot_report = base_query(top_spot_module)
-      @top_spot_reporting << {:category => top_spot_module, :category_title => reports[top_spot_module][:category_title], :report => top_spot_report}
-      # reports.each do |key, report|
-      #   top_spot_report = base_query(key)
-      #   @top_spot_reporting << {:category => key, :category_title => report[:category_title], :report => top_spot_report}
-      # end
+    def data_best_bets_details
+      item = params[:item]
+      serves = Event.where(@range).where(:category => "best-bets-regular", :action => 'serve', :item => item).group(:query).order("count_query DESC").count(:query)
+      clicks = Event.where(@range).where(:category => "best-bets-regular", :action => 'click', :item => item).group(:query).count(:query)
+
+      @result = process_spelling_best_bets_query(serves, clicks, "best_bet_details", item, 15)
+
+      render_data
     end
 
-    def module_click_detail(category)
-       modules_clicks = Event.where(:category => "#{category}").where(date_range).group(:action).order('count_category DESC').count(:category)
-       total_clicks = modules_clicks.values.sum
-       @modules_clicks_report = []
-       modules_clicks.each do |module_clicks|
-        @modules_clicks_report << {:module => module_clicks[0], :clicks => module_clicks[1], :percent => (module_clicks[1]/total_clicks.to_f)*100}
+    # In order to obtain all filter cases, an integer corresponding to the following truth table is formed:
+    # rowNumber   onCampus   offCampus    isMobile    notMobile | filters
+    # 0           0          0            0           0         | Neither filter applied (default)
+    # 1           0          0            0           1         | where(is_mobile=>false)
+    # 2           0          0            1           0         | where(is_mobile=>true)
+    # 3           0          0            1           1         | INVALID (isMobile & notMobile asserted)
+    # 4           0          1            0           0         | where(on_campus=>false)
+    # 5           0          1            0           1         | where(on_campus=>false, is_mobile=>false)
+    # 6           0          1            1           0         | where(on_campus=>false, is_mobile=>true)
+    # 7           0          1            1           1         | INVALID (isMobile & notMobile asserted)
+    # 8           1          0            0           0         | where(on_campus=>true)
+    # 9           1          0            0           1         | where(on_campus=>true, is_mobile=>false)
+    # 10          1          0            1           0         | where(on_campus=>true, is_mobile=>true)
+    # 11          1          0            1           1         | INVALID (isMobile & notMobile asserted)
+    # 12          1          1            0           0         | INVALID (onCampus & offCampus asserted)
+    # 13          1          1            0           1         | INVALID (onCampus & offCampus asserted)
+    # 14          1          1            1           0         | INVALID (onCampus & offCampus asserted)
+    # 15          1          1            1           1         | INVALID (onCampus & offCampus asserted)
+    # Thus, the integer filterCase, which corresponds to the rowNumber, can be formed by converting 4 bit
+    # binary term formed by the concatenation {onCampus, offCampus, isMobile, notMobile} into an integer.
+    # Note: This filtering cannot be obtained by passing two boolean values (one for on_campus and one for is_mobile)
+    # as this would fail to account for cases where no filter is applied to one variable (ie. where we don't care about
+    # either location or device)
+    def data_sessions_overview
+      onCampus = params[:onCampus] ? params[:onCampus].to_i : 0
+      offCampus = params[:offCampus] ? params[:offCampus].to_i : 0
+      isMobile = params[:isMobile] ? params[:isMobile].to_i : 0
+      notMobile = params[:notMobile] ? params[:notMobile].to_i : 0
+      filterCase = (2**3)*onCampus + (2**2)*offCampus + (2**1)*isMobile + notMobile
+
+      case filterCase
+      when 1 #mobile=f
+        sessions = Session.where(@range).where(:is_mobile => false).group(:created_at_string).order("created_at_string ASC").count(:created_at_string)
+      when 2 #mobile=t
+        sessions = Session.where(@range).where(:is_mobile => true).group(:created_at_string).order("created_at_string ASC").count(:created_at_string)
+      when 4 #campus=f
+        sessions = Session.where(@range).where(:on_campus => false).group(:created_at_string).order("created_at_string ASC").count(:created_at_string)
+      when 5 #campus=f, mobile=f
+        sessions = Session.where(@range).where(:on_campus => false, :is_mobile => false).group(:created_at_string).order("created_at_string ASC").count(:created_at_string)
+      when 6 #campus=f, mobile=t
+        sessions = Session.where(@range).where(:on_campus => false, :is_mobile => true).group(:created_at_string).order("created_at_string ASC").count(:created_at_string)
+      when 8 #campus=t
+        sessions = Session.where(@range).where(:on_campus => true).group(:created_at_string).order("created_at_string ASC").count(:created_at_string)
+      when 9 #campus=t, mobile=f
+        sessions = Session.where(@range).where(:on_campus => true, :is_mobile => false).group(:created_at_string).order("created_at_string ASC").count(:created_at_string)
+      when 10 #campus=t, mobile=t
+        sessions = Session.where(@range).where(:on_campus => true, :is_mobile => true).group(:created_at_string).order("created_at_string ASC").count(:created_at_string)
+      else
+        sessions = Session.where(@range).group(:created_at_string).order("created_at_string ASC").count(:created_at_string)
       end
+
+      @result = process_time_query(sessions)
+
+      render_data
     end
 
-    def top_spot_detail(category, action)
-      # Use a join here?
-      action = URI.decode(action)
-      serves = Event.where(:category => "#{category}-serve", :action => "#{action}").where(date_range).group(:label).order("count_label DESC").count(:label)
-      clicks = Event.where(:category => "#{category}", :action => "#{action}").where(date_range).group(:label).order("count_label DESC").count(:label)
+    def data_sessions_location
+      use_perc = params[:use_perc]=="true" ? true : false
+      sessions_on = Session.where(@range).where(:on_campus => true).group(:created_at_string).order("created_at_string ASC").count(:created_at_string)
+      sessions_off = Session.where(@range).where(:on_campus => false).group(:created_at_string).order("created_at_string ASC").count(:created_at_string)
 
-      @top_spot_detail = {}
+      @result = process_stacked_time_query(sessions_on, sessions_off, use_perc)
+      
+      render_data
+    end
 
+    def data_sessions_device
+      use_perc = params[:use_perc]=="true" ? true : false
+      sessions_on = Session.where(@range).where(:is_mobile => true).group(:created_at_string).order("created_at_string ASC").count(:created_at_string)
+      sessions_off = Session.where(@range).where(:is_mobile => false).group(:created_at_string).order("created_at_string ASC").count(:created_at_string)
 
-      serves.each do |label|
-        serve_count = label[1].nil? ? 0:label[1]
-        click_count = clicks[label[0].downcase].nil? ? 0:clicks[label[0].downcase]
-        @top_spot_detail[label[0]] = [serve_count, click_count, (click_count/serve_count.to_f)*100]
-      end
+      @result = process_stacked_time_query(sessions_on, sessions_off, use_perc)
+      
+      render_data
     end
 
-    def base_query(category)
-      serves = Event.where(date_range).where(:category => "#{category}-serve").group(:action).order("count_category DESC").count(:category)
-      clicks = Event.where(date_range).where(:category => "#{category}").group(:action).count(:category)
+    def process_time_query(query)
+      sub = []
+      query.each do |date , count|
+        row = { "date" => date ,
+                "count" => count}
+        sub << row
+      end
+      return sub
+    end
 
-      result = []
-      serves.each do |data, count|
-        unless clicks[data].nil?
-          click_count = clicks[data]
-        else
-          click_count = 0
-        end
+    def process_stacked_time_query(query1, query2, use_perc)
+      sub = []
+      query1.each do |date , count1|
+        count2 = query2[date] ? query2[date] : 0
+        row = { "date" => date ,
+                "on" => use_perc ? count1.to_f/(count1+count2) : count1,
+                "off" => use_perc ? count2.to_f/(count1+count2) : count2}
+        sub << row
+      end
+      return sub
+    end
 
-        row = {"action" => data,
-          "servecount" => count,
-          "clickcount" => click_count,
-          "click_serve_ratio" => (click_count/count)*100 }
-        result << row
+    def process_module_result_query(query, keyHeading, parent, num_results, total_clicks)
+      sub = []
+      query.to_a[0..num_results-1].each_with_index do |d, i|
+        label = d[0]
+        count = d[1]
+        row = {"rank" => i+1,
+               "label" => (label.blank? ? "(blank)"  : label),
+               "clickcount" => count,
+               "percentage" => ((100.0*count)/total_clicks).round(2),
+               "parent" => parent,
+               "expanded" => 0,
+               "key" => keyHeading + (label.blank? ? "(blank)"  : label) + parent.to_s}
+        sub << row
       end
+      return sub
+    end
 
-      result
+    def process_spelling_best_bets_query(serves, clicks, keyHeading, parent, num_results)
+      sub = []
+      serves.to_a[0..num_results-1].each_with_index do |d , i|
+        label = d[0]
+        serve_count = d[1]
+        click_count = clicks[label] ? clicks[label] : 0
+        row = {"rank" => i+1,
+               "label" => label,
+               "serves" => serve_count,
+               "clicks" =>  click_count,
+               "ratio" => (100.0*click_count/serve_count).round(2),
+               "parent" => parent,
+               "expanded" => 0,
+               "key" => keyHeading + label + parent.to_s}
+        sub << row
+      end
+      return sub
     end
 
-    def start_date
-      if params[:start_date]
-        # If there's a specified start date, use it
-        @start_date = convert_to_time(params[:start_date])
-      else
-        # otherwise use 6 months ago as a default, or the earliest event date if logs are younger
-        first_date = Event.first[:created_at]
-        start = Time.current - 6.months
-
-        if start < first_date
-          @start_date = first_date
-        else
-          @start_date = start
+    def process_searches_query(searches, num_results, total_searches)
+      sub = []
+      last_row = {}
+      searches.to_a[0..num_results-1].each_with_index do |d, i|
+        query = d[0]
+        count = d[1]
+        if (last_row=={}) 
+          last_cum_percentage = 0
+        else 
+          last_cum_percentage = last_row["cum_perc"]
         end
+        row = {"rank" => i+1,
+               "label" => query,
+               "count" => count,
+               "percentage" => ((100.0*count)/total_searches).round(2),
+               "cum_perc" => (last_cum_percentage + ((100.0*count)/total_searches)),
+               "cum_percentage" => (last_cum_percentage + ((100.0*count)/total_searches)).round(2),
+               "key" => "top_search" + query}
+        sub << row
+        last_row = row
       end
-
+      return sub
     end
 
-    def end_date
-      if params[:end_date]
-        # use end date, if specified
-        @end_date = convert_to_time(params[:end_date])
-      else
-        # otherwise use the current date as default
-        @end_date = Time.current
+    def render_data
+      respond_to do |format|
+        format.json {
+          render :json => @result
+        }
       end
     end
 
-    def convert_to_time(date_input)
-      year = date_input[:year]
-      month = date_input[:month]
-      day = date_input[:day]
+    def index
+      @page_title = 'Search Statistics'
+    end
+
+    def clicks_overview
+      @page_title = 'Clicks Overview'
+    end
+
+    def top_searches
+      @page_title = 'Top Searches'
+    end
+
+    def top_spot
+      @page_title = params[:ga_top_spot_module]
+    end
+
+    def sessions_overview
+      @page_title = 'Sessions Overview'
+    end
 
-      Time.new(year, month, day)
+    def sessions_details
+      @page_title = 'Sessions Details'
+    end
+
+    def convert_to_time(date_input)
+      Time.parse(date_input)
     end
 
     def days_in_sample
@@ -196,14 +306,27 @@ module QuickSearch
       if @days_in_sample < 1
         @days_in_sample = 1
       end
+
     end
 
-    def excluded_categories
-      "category NOT LIKE \"%serve\" AND category <> \"common-searches\" AND category <> \"result-types\"AND category NOT LIKE \"typeahead-%\""
+    def get_dates
+      start = params[:start_date]
+      stop = params[:end_date]
+      if (!start.blank?)
+        @start_date = convert_to_time(start)
+      else
+        @start_date = Time.current - 180.days
+      end
+      if (!stop.blank?)
+        @end_date = convert_to_time(stop)
+      else
+        @end_date = Time.current
+      end
+      @range = { :created_at => @start_date..@end_date }
     end
 
-    def date_range
-      { :created_at => start_date.beginning_of_day..end_date.end_of_day }
+    def excluded_categories
+      "category <> \"common-searches\" AND category <> \"result-types\"AND category <> \"typeahead\""
     end
 
   end