dash_creator 0.1.2

data/app/helpers/dash_creator/dashboard_helper.rb

@@ -0,0 +1,4 @@
+module DashCreator
+  module DashboardHelper
+  end
+end

data/app/helpers/dash_creator/dashboard_object_helper.rb

@@ -0,0 +1,4 @@
+module DashCreator
+  module DashboardObjectHelper
+  end
+end

data/app/helpers/dash_creator/filter_helper.rb

@@ -0,0 +1,237 @@
+module DashCreator
+  module FilterHelper
+    def filter_data(data)
+      mods = {}
+      data.keys.each do |k|
+        filter_hash = data[k]
+
+        mods[k] = filter_model(k.safe_constantize, filter_hash)
+      end
+
+      mods
+    end
+
+    def prepare_data(params)
+      mods = filter_data(params['filters'])
+
+      data = params
+
+      data['y_data'] = data['y_data'].map { |d| mods[d] }
+
+      x_model_data = mods[data['x_data']['attribute']]
+      data['x_data'] = x_model_data unless x_model_data.nil?
+
+      data
+    end
+
+    # Query on model with data from filter_hash
+    def filter_model(model, filter_hash)
+      mods = model.all
+      # For each key of the model, recursively query (attributes, submodels)
+      filter_hash.keys.each do |k|
+        next if k == 'num_records'
+        attribute = k.split('_').last == 'id' ? k[0..-4] : k
+        mods = recursive_filter_attribute(mods, attribute, filter_hash[k])
+      end
+      return nil if mods.nil?
+
+      # Limit results if num_records is given
+      limit = filter_hash['num_records']
+      return mods.limit(limit.to_i) unless limit.empty?
+      mods
+    end
+
+    # Recursively query attributes depending on type associated to hash
+    def recursive_filter_attribute(models, attribute, filter_hash)
+      return nil if models.nil? || models.empty?
+
+      case filter_hash['type']
+        when 'datetime'
+          mods = filter_datetime(models, attribute, filter_hash)
+
+        when 'text'
+          mods = filter_text(models, attribute, filter_hash)
+
+        when 'numeric'
+          mods = filter_numeric(models, attribute, filter_hash)
+
+        when 'boolean'
+          mods = filter_boolean(models, attribute, filter_hash)
+
+        when 'has'
+          mods = filter_has(models, attribute, filter_hash)
+
+        when 'ref'
+          mods = filter_ref(models, attribute, filter_hash)
+
+        else
+          raise ArgumentError, 'type_' + filter_hash['type'] + '_is_unknown'
+      end
+      mods
+    end
+
+    # Helper functions for each type
+    # Query on models for attribute according to data in filter_hash
+
+    def filter_datetime(models, attribute, filter_hash)
+      mods = models
+      model_string = models.first.class.name.underscore
+      query_attribute = model_string.pluralize + '.' + attribute
+      start_date = DateTime.strptime(filter_hash['start'], '%b %d, %Y').beginning_of_day
+      end_date = DateTime.strptime(filter_hash['end'], '%b %d, %Y').beginning_of_day + 1.days
+      mods = mods.where("#{query_attribute}": start_date..end_date) if filter_hash.key?('start')
+      mods
+    end
+
+    def filter_text(models, attribute, filter_hash)
+      return models unless filter_hash.key?('present')
+      mods = models
+
+      model_string = models.first.class.name.underscore
+      query_attribute = model_string.pluralize + '.' + attribute
+
+      if !true_string?(filter_hash['present'])
+        mods = mods.where("#{attribute}": [nil, ''])
+      else
+        if filter_hash.key?('contains')
+          mods = mods.where(query_attribute + ' ~* ?', filter_hash['contains'])
+        else
+          mods = mods.where.not("#{attribute}": [nil, ''])
+        end
+      end
+      mods
+    end
+
+    def filter_numeric(models, attribute, filter_hash)
+      return models unless filter_hash.key?('value')
+
+      mods = models.where("#{attribute}": filter_hash['value'].to_i)
+      mods
+    end
+
+    def filter_boolean(models, attribute, filter_hash)
+      return models unless filter_hash.key?('value')
+
+      mods = models.where("#{attribute}": true_string?(filter_hash['value']))
+      mods
+    end
+
+    def filter_has(models, attribute, filter_hash)
+      return models unless filter_hash.key?('has')
+      mods = models
+
+      has_models = attribute.pluralize
+      model_string = models.first.class.name.underscore
+
+      if true_string?(filter_hash['has'])
+        mods = mods.includes("#{has_models}")
+                   .where.not("#{has_models}": {"#{model_string}_id": nil})
+
+        mods = mods.joins("LEFT JOIN #{has_models} ON #{has_models}.#{model_string}_id = #{model_string.pluralize}.id")
+                   .group("#{model_string.pluralize}.id")
+                   .having("count(#{has_models}.id) >= ?", filter_hash['has-inf'].to_i) if filter_hash.key?('has-inf')
+        mods = mods.joins("LEFT JOIN #{has_models} ON #{has_models}.#{model_string}_id = #{model_string.pluralize}.id")
+                   .group("#{model_string.pluralize}.id")
+                   .having("count(#{has_models}.id) <= ?", filter_hash['has-sup'].to_i) if filter_hash.key?('has-sup')
+        return nil if mods.nil?
+
+        # Go recursively through has model params
+        attribute_models = attribute.classify.safe_constantize.where("#{model_string}": mods)
+        main_keys = %w[has-sup has-inf has type]
+        filter_hash.keys.each do |k|
+          attribute_models = recursive_filter_attribute(attribute_models, k.underscore, filter_hash[k]) unless main_keys.include?(k)
+        end
+        return nil if attribute_models.nil?
+        mods_ids = []
+        attribute_models.each { |m| mods_ids.push(m[model_string + '_id']) }
+        mods = mods.where(id: mods_ids)
+      else
+        mods = mods.includes(:"#{has_models}")
+                   .where("#{has_models}": {"#{model_string}_id": nil})
+      end
+      mods
+    end
+
+    def filter_ref(models, attribute, filter_hash)
+      return models unless filter_hash.key?('ref')
+      mods = models
+
+      if true_string?(filter_hash['ref'])
+        mods = mods.where.not("#{attribute}": nil)
+        return nil if mods.nil?
+
+        # Go recursively through ref model params
+        attributes_ids = []
+        mods.each { |m| attributes_ids.push(m[attribute + '_id']) }
+        attribute_models = attribute.classify.safe_constantize
+                               .where(id: attributes_ids)
+        main_keys = %w[ref type]
+        filter_hash.keys.each do |k|
+          attribute_models = recursive_filter_attribute(attribute_models, k.underscore, filter_hash[k]) unless main_keys.include?(k)
+        end
+        mods = mods.where("#{attribute}": attribute_models)
+      else
+        mods = mods.where("#{attribute}": nil)
+      end
+      mods
+    end
+
+    def filter_data_count_from_redis(data)
+      redis_data = nil
+      refresh = data.delete('refresh')
+      redis_filter_data = encode_filter_data(data)
+
+      unless refresh == true || DashCreator.redis_store_variable.nil?
+        redis_data = DashCreator.redis_store_variable.get(redis_filter_data)
+      end
+
+      unless redis_data.nil?
+        processed_data = JSON.parse(redis_data)
+      else
+        processed_data = filter_data(data).deep_stringify_keys
+        processed_data.keys.each { |k| processed_data[k] = processed_data[k].count }
+        processed_data['last_updated'] = DateTime.now.strftime('%d/%m/%Y - %T')
+
+        # Add chart data to redis
+        DashCreator.redis_store_variable.set(redis_filter_data, processed_data.to_json) unless DashCreator.redis_store_variable.nil?
+      end
+
+      processed_data
+    end
+
+    def encode_filter_data(data)
+      # Prepare data to encode
+      encoded_data = data.clone
+      encoded_data = encoded_data.to_unsafe_h unless encoded_data.is_a?(Hash)
+
+      # Encode
+      hash_hash(encoded_data)
+    end
+
+    # This helper function is used in create_chart.js.erb to hash param hash to store it in Redis
+    def hash_hash(h)
+      require 'digest/sha1'
+      str = recursive_flatten(h).sort.join
+      Digest::SHA1.hexdigest(str)
+    end
+
+    def recursive_flatten(h)
+      h.flatten(-1).map{|el| el.is_a?(Hash) ? recursive_flatten(el) : el}.flatten
+    end
+
+    # Check if string is 'true'
+    def true_string?(string)
+      string == 'true'
+    end
+
+    def get_csv(models)
+      CSV.generate do |csv|
+        columns = models.first.keys.map { |k| k.to_s }
+        csv << columns
+        models.each do |m|
+          csv << m.attributes.values_at(*columns)
+        end
+      end
+    end
+  end
+end

data/app/helpers/dash_creator/user_helper.rb

@@ -0,0 +1,4 @@
+module DashCreator
+  module UserHelper
+  end
+end

data/app/jobs/dash_creator/application_job.rb

@@ -0,0 +1,4 @@
+module DashCreator
+  class ApplicationJob < ActiveJob::Base
+  end
+end

data/app/mailers/dash_creator/application_mailer.rb

@@ -0,0 +1,6 @@
+module DashCreator
+  class ApplicationMailer < ActionMailer::Base
+    default from: 'from@example.com'
+    layout 'mailer'
+  end
+end

data/app/models/dash_creator/application_record.rb

@@ -0,0 +1,5 @@
+module DashCreator
+  class ApplicationRecord < ActiveRecord::Base
+    self.abstract_class = true
+  end
+end

data/app/models/dash_creator/chart.rb

@@ -0,0 +1,21 @@
+module DashCreator
+  class Chart < ApplicationRecord
+    attr_accessor :user_id
+    belongs_to :user, class_name: DashCreator.user_class.to_s
+
+    before_validation :set_user
+
+    def as_json(options = {})
+      json = {
+          name: name,
+          data: data
+      }
+      json
+    end
+
+    private
+      def set_user
+        self.user = DashCreator.user_class.find(user_id)
+      end
+  end
+end

data/app/models/dash_creator/dashboard.rb

@@ -0,0 +1,13 @@
+module DashCreator
+  class Dashboard < ApplicationRecord
+    attr_accessor :user_id
+    belongs_to :user, class_name: DashCreator.user_class.to_s
+
+    before_validation :set_user
+
+    private
+    def set_user
+      self.user = DashCreator.user_class.find(user_id)
+    end
+  end
+end

data/app/models/dash_creator/dashboard_object.rb

@@ -0,0 +1,7 @@
+module DashCreator
+  class DashboardObject < ApplicationRecord
+    validates_presence_of :code, unique: true
+
+    # Acts as dashboard object for objects you want to display in your dashboard
+  end
+end

data/app/models/dash_creator/filter.rb

@@ -0,0 +1,22 @@
+module DashCreator
+  class Filter < ApplicationRecord
+    attr_accessor :user_id
+    belongs_to :user, class_name: DashCreator.user_class.to_s
+
+    before_validation :set_user
+
+    def as_json (opts={})
+      json = {
+          'id': id,
+          'name': name,
+          'options': options
+      }
+      json
+    end
+
+    private
+    def set_user
+      self.user = DashCreator.user_class.find(user_id)
+    end
+  end
+end

data/app/views/dash_creator/chart/_chart_creator.html.erb

@@ -0,0 +1,230 @@
+<div class="row">
+  <div class="col-md-12">
+    <div class="card">
+      <div class="card-header">
+        Super Amazing Chart Creator
+      </div>
+      <div class="card-block" id="chart-creator" style="margin:20px 50px;">
+
+      </div>
+      <div class="card-footer">
+        <button type="submit" class="pull-left btn btn-success" id="chart-submit-btn">Draw Chart</button>
+        <a href="#" data-toggle="modal" data-target="#delete_charts_modal" class="pull-right btn btn-sm btn-danger" id="chart-unsave-btn"><%=t :delete_charts%></a>
+        <a href="#" data-toggle="modal" data-target="#edit_chart_modal" class="pull-right btn btn-sm btn-primary" id="chart-edit-btn"><%=t :modify_chart%></a>
+        <a href="#" data-toggle="modal" data-target="#save_chart_modal" class="pull-right btn btn-sm btn-success"><%=t :save_new_chart%></a>
+        <%= select_tag 'chart-select', options_for_select([]), prompt: 'Choose a chart', id: '', class: 'form-control pull-right', style: 'width: 20%; margin-right: 10%;' %>
+      </div>
+    </div>
+    <!--/.card-->
+  </div>
+</div>
+
+<script>
+    var charts = <%= raw @charts %>;
+
+    // TODO: JSON handling ??
+    // TODO: for date charts, always calculate day values and then gather ? so that changing day/week/month display doesn't need a reload
+    // TODO: if only bar/line change don't refresh
+    // TODO: Stats creator: take a filter, simply return the count of objects
+    // TODO: minicolors issue ?? Too much JS to handle for the browser when many color fields in chart creator
+
+    // Style presets
+    var minicolors_swatches = [
+        'rgb(255, 99, 132)',
+        'rgb(54, 162, 235)',
+        'rgb(255, 206, 86)',
+        'rgb(75, 192, 192)',
+        'rgb(153, 102, 255)',
+        'rgb(255, 159, 64)',
+        'rgb(216, 247, 147)',
+        'rgb(52, 85, 17)',
+        'rgb(220, 255, 253)',
+        'rgb(1, 17, 10)',
+        'rgb(219, 153, 90)',
+        'rgb(153, 134, 80)'
+    ];
+    var minicolors_options = {theme: 'bootstrap', format: 'rgb', swatches: minicolors_swatches};
+
+    $('#chart-creator').chartCreator({
+        models_data: <%= raw @models_data.to_json %>,
+        attributes_aliases: <%= raw DashCreator.attributes_aliases.to_json %>,
+        displayed_model_names: <%= raw DashCreator.displayed_model_names.to_json %>,
+        displayed_attribute_names: <%= raw DashCreator.displayed_attribute_names.to_json %>,
+        filter_creator: $('#filter-creator'),
+        minicolors_options: minicolors_options
+    });
+    var chart_creator = $('#chart-creator').data('chartCreator');
+
+
+    // --------------- Send chart data to controller ---------------
+    chart_creator.labelOptionsContainer.on('click', '#pluck-labels-btn', labelsFromPluck);
+    function labelsFromPluck() {
+        var limit = chart_creator.labelOptionsContainer.find('[name="pluck-num"]').val();
+
+        var x = chart_creator.xContainer.find('[name="x-axis"]').val().split('-');
+        var model, attribute;
+        if (x[1] === 'has' || x[1] === 'ref') {
+            model = x[0].classify();
+            attribute = chart_creator.labelOptionsContainer.find('[name="x-sub"]').val().split('-')[0];
+        }
+        else {
+            model = chart_creator.yContainer.find('[name="y-axis"]:first').val();
+            attribute = x[0];
+        }
+
+        var params = {
+            model: model,
+            attribute: attribute,
+            limit: limit
+        };
+
+        $.post('<%= pluck_labels_path %>', params, function(data) {
+            var labels = data['labels'];
+
+            chart_creator.labelOptionsContainer.find('[name="labels-num"]').val(labels.length).change();
+            chart_creator.labelOptionsContainer.find('.limit-label').each(function() {
+                $(this).val(labels.shift());
+            });
+        });
+    }
+
+
+    // --------------- Send chart data to controller ---------------
+    // Send data for controller chart actions
+    function sendChartDataCreate(chart_data) {
+        $.post("<%= create_chart_path %>", chart_data);
+    }
+
+    function sendChartDataSave(chart_data) {
+        $.post("<%= save_chart_path %>", chart_data, function(data) {
+            var chart_id = data['chart_id'], chart_name = chart_data['chart_name'];
+            charts.push([chart_name, chart_id]);
+
+            var dashboard_creator_objects_data = $('#dashboard-creator').data('dashboardCreator').objects_data;
+            dashboard_creator_objects_data['chart']['objects'].push({id: chart_id, name: chart_name});
+        });
+    }
+
+    function sendChartDataEdit(chart_data) {
+        $.post("<%= edit_chart_path %>", chart_data);
+    }
+
+    // Handle submit
+    $('#chart-submit-btn').click(function() {
+        var chart_data = chart_creator.getChartData();
+        chart_data['refresh'] = false;
+        sendChartDataCreate(chart_data);
+    });
+
+
+    // --------------- Save, unsave, show saved charts ---------------
+    var chart_id = '';
+
+    // Save a chart config
+    $(document).on('click', '#save-chart-btn', function() {
+        var chart_data = chart_creator.getChartData();
+
+        // Get the chart name
+        chart_data['chart_name'] = $('.modal#save_chart_modal').find('[name="chart-name"]').val();
+
+        // Post data with chart-save request
+        sendChartDataSave(chart_data);
+    });
+
+    // Prepare modal display for edit
+    $('#chart-edit-btn').click(function() {
+        var confirm_edit_chart_btn = $('#confirm-edit-chart-btn');
+
+        var h3_div = $('.modal#edit_chart_modal .modal-body #edit-message');
+        h3_div.empty();
+        confirm_edit_chart_btn.prop('disabled', false);
+
+        var h3_div_text;
+        if (chart_id !== '') {
+            h3_div_text = 'Are you sure you want to edit chart ';
+            for (var i = 0; i < charts.length; i++) {
+                var chart_name = charts[i][0], id = charts[i][1];
+                if (chart_id === id) {
+                    h3_div_text += chart_name;
+                    break;
+                }
+            }
+            h3_div_text += ' ?'
+        }
+        else {
+            h3_div_text = 'No chart to edit.';
+            confirm_edit_chart_btn.prop('disabled', true);
+        }
+        h3_div.text(h3_div_text);
+    });
+
+    // Prepare and send new chart data on chart edit confirm
+    $(document).on('click', '#confirm-edit-chart-btn', function() {
+        var chart_data = chart_creator.getChartData();
+        chart_data['chart_id'] = chart_id;
+
+        sendChartDataEdit(chart_data);
+    });
+
+    // Prepare list of charts for delete charts modal
+    $('#chart-unsave-btn').click(function() {
+        var checkbox_list = $('#charts-checkbox-list');
+        // First empty the checkbox list
+        checkbox_list.children().remove();
+
+        // Append charts list to div in modal
+        var checkbox_string_start = '<div class="col-sm-12"><div class="form-group">'
+            + '<input type="checkbox" class="form-control" name="chart" value="';
+        for (var i = 0; i < charts.length; i++) {
+            var chart_name = charts[i][0], id = charts[i][1];
+            var chart_string = checkbox_string_start + id + '"><label>' + chart_name + '</label><br>';
+            $(chart_string).appendTo(checkbox_list);
+        }
+        $('</div></div>').appendTo(checkbox_list);
+    });
+
+    // Delete charts
+    $(document).on('click', '#delete-charts-btn', function() {
+        // Get the charts ids
+        var charts_ids = [];
+        $(this).closest('.modal').find('[type="checkbox"]:checked').each(function() {
+            charts_ids.push($(this).attr("value"));
+        });
+
+        var params = {charts_ids: charts_ids};
+
+        $.post("<%= delete_charts_path %>", params, function() {
+            // Remove from charts list
+            for (var i = 0; i < charts.length; i++) {
+                var id = charts[i][1];
+                if ($.inArray(id, charts_ids) !== -1) {
+                    charts.splice(i, 1);
+                    i--;
+                }
+            }
+        });
+    });
+
+    $('[name="chart-select"]')
+        .focusin(displayChartList)
+        .change(displayChart);
+
+    // Display chart select list
+    function displayChartList() {
+        $(this).children().not('[value=""]').remove();
+        for (var i = 0; i < charts.length; i++) {
+            var chart_name = charts[i][0], id = charts[i][1];
+            $('<option value="' + id + '">' + chart_name + '</option>').appendTo($('[name="chart-select"]'));
+        }
+    }
+
+    // Display chosen chart
+    function displayChart() {
+        if ($(this).val() === '') { return false; }
+
+        chart_id = $(this).val();
+        var params = {chart_id: chart_id};
+
+        $.post("<%= get_chart_path %>", params);
+    }
+</script>