visual_condition_builder 0.0.2

data/app/assets/stylesheets/visual_condition_builder.css

@@ -0,0 +1,5 @@
+/*
+*= require visual_condition_builder/select2
+*= require visual_condition_builder/select2-bootstrap
+*= require visual_condition_builder/condition_builder
+*/

data/app/controllers/application_widget.rb

@@ -0,0 +1,56 @@
+class ApplicationWidget < ::ApplicationController
+  include SingletonHelper
+
+  attr_singleton :refresh_interval, 0
+
+  def initialize(request)
+    self.request = request
+  end
+
+  def render_template(view_file=nil, *args)
+    args << {template: view_file}
+    render_to_string *args
+  end
+
+  def view(view_file=nil, klass=nil)
+    class_caller = klass || (caller[0].match(/(\b\w+)\.rb/)[1] rescue '')
+    action_caller = view_file || (caller[0].match(/`(.*)'/)[1] rescue '')
+    view_file = "widgets/#{class_caller.to_s.sub('_widget','')}/#{action_caller}" unless lookup_context.find_all(view_file).any?
+    instance_variable_set(:@view_file, view_file)
+  end
+
+  def self.name?
+    instance_variable_defined?(:@widget_name) ? instance_variable_get(:@widget_name) : ''
+  end
+
+  def self.name!(value)
+    # define_singleton_method(:widget_name) {value}
+    instance_variable_set(:@widget_name, value)
+  end
+
+  def self.description?(attr=nil)
+    attr='widget' if attr.nil?
+    instance_variable_defined?("@description_#{attr}") ? instance_variable_get("@description_#{attr}") : ''
+  end
+
+  def self.description!(*args)
+    if args.size == 1
+      instance_variable_set(:@description_widget, args[0])
+    elsif args.size == 2
+      instance_variable_set("@description_#{args[0]}", args[1])
+    end
+  end
+
+  def self.widgets
+    # ApplicationWidget.descendants.map do |klass| #Não estava carregando no primeiro load...
+    Dir["#{Rails.root}/app/widgets/*.rb"].map do |file_path|
+      file_name = File.basename(file_path, ".rb")
+      klass = Object.const_get file_name.classify
+      actions = klass.instance_methods(false).map do |action|
+        {name: action, description: klass.description?(action)}
+      end
+      {code: klass.to_s.tableize.sub('_widgets',''), name: klass.name?, description: klass.description?, actions: actions}
+    end
+  end
+
+end

data/app/controllers/visual_condition_builder/application_controller.rb

@@ -0,0 +1,5 @@
+module VisualConditionBuilder
+  class ApplicationController < ::ApplicationController #< ActionController::Base #ENGINE
+
+  end
+end

data/app/controllers/visual_condition_builder/widgets_controller.rb

@@ -0,0 +1,45 @@
+require_dependency "visual_condition_builder/application_controller"
+
+module VisualConditionBuilder
+  class WidgetsController < ApplicationController
+
+    def load
+      widget = VisualConditionBuilder::Widget.new(params[:widget_name], self.request)
+      content = widget.html(params[:widget_action])
+    rescue Exception => e
+      content = e.message
+    ensure
+      render html: content, layout: false
+    end
+
+    def user
+      user_id = params[:id] || current_user.id
+      @widgets_code = VisualConditionBuilder::User.where(user_id: user_id).pluck(:widget, :action).map{|r| "#{r[0]}_#{r[1]}"}
+      render partial: 'widgets_list'
+    end
+
+    def index
+    end
+
+    def save
+      user_id = params[:user_id] || current_user.id
+      widgets = params[:widgets]
+      widget_name_user = []
+      action_user = []
+      if widgets.present?
+        widgets.each do |widget|
+          widget_name, action = widget.split('|')
+          if widget_name && action
+            widget_name_user << widget_name
+            action_user << action
+            VisualConditionBuilder::User.find_or_create_by(widget: widget_name, action: action, user_id: user_id)
+          end
+        end
+      end
+      VisualConditionBuilder::User.where(user_id: user_id).where.not(widget: widget_name_user, action: action_user).destroy_all
+      flash[:success] = 'Alterações foram salvas com sucesso!'
+      redirect_to visual_condition_builder_path
+    end
+
+  end
+end

data/app/helpers/visual_condition_builder/application_helper.rb

@@ -0,0 +1,74 @@
+module VisualConditionBuilder
+  module ApplicationHelper
+
+    def build_conditions(dictionary, *args)
+      dictionary_name = get_dictionary_name(dictionary)
+      container_name = "#{dictionary_name}_condition_container"
+
+      hArgs = (args ||= []).reduce(Hash.new, :merge)
+      hArgs = normalize_placeholder_label(hArgs)
+
+      builder_options = {
+          dictionary: ObrigacaoDictionary.dictionary
+      }.deep_merge(hArgs)
+
+      capture do
+        concat(content_tag(:div, nil, id: container_name))
+        concat(javascript_tag(<<txtjs
+            $(document).ready(function () {
+              $('##{container_name}').conditionBuilder(#{builder_options.to_json});
+            });
+txtjs
+        ))
+      end
+    end
+
+    def conditions_fields(dictionary, *args)
+      dictionary_name = get_dictionary_name(dictionary)
+      container_name = "#{dictionary_name}_condition_container"
+      capture do
+        content_tag(:div, class: 'dropdown add-condition', data: {target: "##{container_name}"}) do
+          concat(content_tag(:button, class: 'btn btn-default dropdown-toggle', data: {toggle: 'dropdown'}, type: 'button') do
+            concat(I18n.t(:dropdown, default: ['Fields'], scope: [:condition_builder]))
+            concat(content_tag(:span, nil, class:'caret'))
+          end)
+          concat(content_tag(:ul, class: 'dropdown-menu add-condition-menu') do
+            create_conditions_fields_item(ObrigacaoDictionary.fields(get_dictionary_context(dictionary)))
+          end)
+        end
+      end
+    end
+
+    private
+    def create_conditions_fields_item(fields)
+      fields.each do |field, attrs|
+        if field.is_a?(Hash) #GROUP
+          group_label = field.values.first
+          concat(content_tag(:li, group_label, class: 'dropdown-header'))
+          create_conditions_fields_item(attrs)
+        else
+          concat(content_tag(:li, link_to(attrs[:label], '#', class: 'add-condition-field', data: {field: field})))
+        end
+      end
+    end
+
+    def get_dictionary_context(dictionary)
+      dictionary.is_a?(Hash) ? dictionary.values.first : :default
+    end
+    def get_dictionary_name(dictionary)
+      "#{dictionary.is_a?(Hash) ? dictionary.keys.first : dictionary}_#{get_dictionary_context(dictionary)}"
+    end
+
+    def normalize_placeholder_label(args)
+      args[:placeholder] ||= {}
+      [:fields, :operators, :values].each do |attr|
+        unless args[:placeholder][attr].present?
+          label = I18n.t(attr, default: [''], scope: [:condition_builder, :placeholder])
+          args[:placeholder][attr] = label if label.present?
+        end
+      end
+      args
+    end
+
+  end
+end

data/app/models/visual_condition_builder/user.rb

@@ -0,0 +1,10 @@
+module VisualConditionBuilder
+  class User < ActiveRecord::Base
+
+    self.table_name = :visual_condition_builder_users
+
+    belongs_to :user
+
+    validates :widget, :action, presence: true
+  end
+end

data/app/views/visual_condition_builder/widgets/_widgets_list.html.erb

@@ -0,0 +1,24 @@
+<% ApplicationWidget.widgets.each do |widget| %>
+    <ul>
+      <li>
+        <b><%= widget[:name] %></b>
+        <br><span class="help-block"><%= widget[:description] %></span>
+        <ul>
+          <% widget[:actions].each do |action| %>
+              <% widget_code = "#{widget[:code]}_#{action[:name]}" %>
+              <li>
+                <div class="checkbox">
+                  <%= label_tag widget_code do %>
+                      <%= check_box_tag 'widgets[]', "#{widget[:code]}|#{action[:name]}", @widgets_code.include?(widget_code), {id: widget_code} %>
+                      <b><%= action[:name].to_s.humanize %></b>
+                      <% if action[:description].present? %>
+                          <br><span class="help-block"><%= action[:description] %></span>
+                      <% end %>
+                  <% end %>
+                </div>
+              </li>
+          <% end %>
+        </ul>
+      </li>
+    </ul>
+<% end %>

data/app/views/visual_condition_builder/widgets/index.html.erb

@@ -0,0 +1,25 @@
+<div class="row">
+  <div class="col-md-12">
+    <div class="panel panel-default">
+      <div class="panel-heading">
+        <div class="panel-title">Selecione os Widgets que deseja utilizar:</div>
+      </div>
+      <div class="panel-body">
+        <%= form_tag(visual_condition_builder_save_path, method: :put, class: 'widget_config') do %>
+
+          <div class="form-group">
+            <label class="control-label">Usuário:</label>
+            <%= select_tag :user_id, options_from_collection_for_select(User.all, :id, :email, current_user.id), include_blank: false, class: 'form-control widget-user-control' %>
+          </div>
+
+          <fieldset class="widgets_list">
+            <legend>Widgets</legend>
+            <div class="list"></div>
+          </fieldset>
+
+          <%= submit_tag "Salvar", class: 'btn btn-success' %>
+        <% end %>
+      </div>
+    </div>
+  </div>
+</div>

data/config/initializers/assets.rb

@@ -0,0 +1 @@
+Rails.application.config.assets.precompile += %w( visual_condition_builder.js visual_condition_builder.css  )

data/config/initializers/visual_condition_builder.rb

@@ -0,0 +1,7 @@
+class Railtie < ::Rails::Railtie
+  initializer 'activeservice.autoload', :before => :set_autoload_paths do |app|
+    app.config.autoload_paths << "#{Rails.application.config.root}/app/condition_dictionaries"
+  end
+end
+
+

data/config/routes.rb

@@ -0,0 +1,19 @@
+Rails.application.routes.draw do
+
+
+  namespace :visual_condition_builder do
+
+    get 'widgets/load/:widget_name/:widget_action', to: 'widgets#load', as: 'load'
+    get 'widgets/user(/:id)', to: 'widgets#user', as: 'user'
+    get 'widgets', to: 'widgets#index', as: ''
+    put 'widgets/save', to: 'widgets#save', as: 'save'
+
+
+  end
+
+
+
+
+
+
+end

data/lib/generators/templates/create_taxweb_widgets_users.rb

@@ -0,0 +1,18 @@
+class CreateVisualConditionBuilderUsers < ActiveRecord::Migration
+
+  def up
+    unless table_exists?(:visual_condition_builder_users)
+      create_table :visual_condition_builder_users do |t|
+        t.references :user, index: true, foreign_key: false
+        t.string :widget
+        t.string :action
+        t.index [:widget, :action]
+      end
+    end
+  end
+
+  def down
+    drop_table :visual_condition_builder_users if table_exists? :visual_condition_builder_users
+  end
+
+end

data/lib/generators/templates/generic_widget.erb

@@ -0,0 +1,12 @@
+class <%= @widget_name %>Widget < ApplicationWidget
+
+  name! "<%= @widget_name %>"
+  description! "O Widget <%= @widget_name %> tem como função..."
+  #refresh_interval 60000 #60 segundos para refresh automático
+
+  description! :exemplo, 'Essa ação é um exemplo'
+  def exemplo
+    @data = Date.today
+  end
+
+end

data/lib/generators/templates/generic_widget.html.erb

@@ -0,0 +1,2 @@
+<h1>Exemplo de Widget<h1>
+Hoje é <%= data %>

data/lib/generators/visual_condition_builder/install_generator.rb

@@ -0,0 +1,26 @@
+require 'rails/generators/base'
+require 'rails/generators/migration'
+
+module VisualConditionBuilder
+  class InstallGenerator < Rails::Generators::Base
+    source_root File.expand_path("../../templates", __FILE__)
+    include Rails::Generators::Migration
+
+    class_option :orm
+    desc 'Instalando Taxweb Widgets'
+
+    desc 'Criando Migrations'
+    def self.next_migration_number(path)
+      unless @prev_migration_nr
+        @prev_migration_nr = Time.now.utc.strftime("%Y%m%d%H%M%S").to_i
+      else
+        @prev_migration_nr += 1
+      end
+      @prev_migration_nr.to_s
+    end
+
+    def create_migration_file
+      migration_template 'create_visual_condition_builder_users.rb', 'db/migrate/create_visual_condition_builder_users.rb'
+    end
+  end
+end

data/lib/generators/visual_condition_builder/view_generator.rb

@@ -0,0 +1,11 @@
+require 'rails/generators/base'
+
+module VisualConditionBuilder
+  class ViewGenerator < Rails::Generators::Base
+    source_root File.expand_path("../../../../app/views/visual_condition_builder", __FILE__)
+
+    def copy_views
+      directory 'widgets', 'app/views/visual_condition_builder/widgets'
+    end
+  end
+end

data/lib/generators/visual_condition_builder/widget_generator.rb

@@ -0,0 +1,25 @@
+require 'rails/generators/base'
+
+module VisualConditionBuilder
+  class WidgetGenerator < Rails::Generators::NamedBase
+    source_root File.expand_path("../../templates", __FILE__)
+
+    def generate_widget
+      @widget_name = file_name.classify
+      view_dir = "app/views/widgets/#{widget_name_file}"
+
+      template "generic_widget.erb", File.join('app/widgets', "#{widget_name_file}_widget.rb")
+
+      if self.behavior == :revoke && Dir.exists?(view_dir)
+        require 'fileutils'
+        FileUtils.rm_rf(view_dir)
+      elsif self.behavior == :invoke
+        copy_file "generic_widget.html.erb", File.join(view_dir, 'exemplo.html.erb')
+      end
+    end
+
+    def widget_name_file
+      file_name.underscore
+    end
+  end
+end

data/lib/visual_condition_builder/converter.rb

@@ -0,0 +1,22 @@
+module VisualConditionBuilder
+  class Converter
+    def self.to_ransack(params)
+      ransack_q = {}
+      conditions = params.is_a?(Array) ? params : JSON.parse(params ||= '[]')
+      conditions.map do |p|
+        #TODO: Verificar se o código deve ser inserido com inteligência para juntar os campos de mesmo operador
+        if ransack_q["#{p[0]}_#{p[1]}"].present?
+            old_value = ransack_q["#{p[0]}_#{p[1]}"]
+            ransack_q.delete("#{p[0]}_#{p[1]}")
+            ransack_q["#{p[0]}_in"] = []
+            ransack_q["#{p[0]}_in"] << old_value
+            ransack_q["#{p[0]}_in"] << p[2]
+        else
+          ransack_q["#{p[0]}_#{p[1]}"] = p[2]
+        end
+        # ransack_q["#{p[0]}_#{p[1]}"] = p[2]
+      end
+      ransack_q
+    end
+  end
+end

data/lib/visual_condition_builder/dictionary.rb

@@ -0,0 +1,166 @@
+module VisualConditionBuilder
+  class Dictionary
+    class_attribute :dictionaries
+
+    class << self
+      def method_missing(m, *args, &block)
+        if m =~ /_url|_path/
+          Rails.application.routes.url_helpers.send(m, args)
+        end
+      end
+
+      def dictionary(name=:default, &block)
+        (self.dictionaries ||= {})[name] ||= []
+        @dictionary_name = name
+        block.call if block_given?
+        self.dictionaries[name]
+      end
+
+      def fields(dictionary_name=:default)
+        dictionary ||= {}
+        self.dictionaries[dictionary_name].group_by{|h| h[:group]}.each do |group, attrs|
+          dictionary[group] ||= {} if group.present?
+          attrs.each do |attr|
+            if group.present?
+              dictionary[group][attr[:field]] = attr.slice(:label, :type)
+            else
+              dictionary[attr[:field]] = attr.slice(:label, :type)
+            end
+          end
+        end
+        dictionary
+      end
+
+      def param(attr, *args)
+        #DEFAULT VALUES
+        args = array_hashes_to_hash(args)
+        args[:type] ||= 'STRING'
+        args[:operators] = operators_by_type(args[:type]) unless args[:operators].present?
+        args[:operators] = normalize_operators(args[:operators])
+        args[:values] ||= []
+        args[:group] ||= ''
+        if args[:group].present? && args[:group].is_a?(Symbol)
+          args[:label] ||= I18n.t(attr.to_sym, default: attr.to_s.humanize, scope: [:condition_dictionaries, args[:group]])
+          args[:field] ||= "#{args[:group]}_#{attr}"
+          args[:group] = {args[:group] => I18n.t(args[:group], default: args[:group].to_s, scope: [:condition_builder, :dictionaries])}
+        else
+          args[:label] ||= I18n.t(attr.to_sym, default: attr.to_s.humanize, scope: [:condition_dictionaries, dictionary_name])
+          args[:field] ||= attr
+        end
+        if args[:values].present? && args[:values].is_a?(Proc)
+          args[:values] = args[:values].call
+        end
+        self.dictionaries[@dictionary_name] << args
+      end
+
+      def operators_by_type(type)
+        type = type.present? ? type.to_s.downcase.to_sym : 'string'
+        operators = case type
+                      when :date, :datetime
+                        [:eq, :between, :today, :yesterday, :this_week, :last_week, :present, :blank]
+                      when :time
+                        [:eq, :between, :present, :blank]
+                      when :decimal, :integer
+                        [:eq, :between]
+                      when :string
+                        [:cont, :eq, :start, :end, :present, :blank]
+                      else
+                        [:eq]
+                    end
+        operators.map{|op| operator_default(op) }
+      end
+
+      def normalize_operators(operators)
+        operators.map do |operator|
+          operator = operator_default(operator) unless operator.is_a?(Hash)
+          operator[:no_value] ||= false
+          operator[:multiple] ||= false
+          operator[:label] ||= operator_translate(operator[:operator])
+          operator
+        end
+      end
+
+      def operators_list(op=nil)
+        operators = {
+            between: {multiple: 2},
+            today: {no_value: true},
+            yesterday: {no_value: true},
+            this_week: {no_value: true},
+            last_wee: {no_value: true},
+
+            eq: {multiple: false},
+            not_eq: {multiple: false},
+
+            matches: {multiple: false},
+            does_not_match: {multiple: false},
+
+            lt: {multiple: false},
+            gt: {multiple: false},
+
+            lteq: {multiple: false},
+            gteq: {multiple: false},
+
+            in: {multiple: true},
+            not_in: {multiple: true},
+
+            cont: {multiple: false},
+            not_cont: {multiple: false},
+
+            cont_any: {multiple: true},
+            not_cont_any: {multiple: true},
+
+            cont_all: {multiple: true},
+            not_cont_all: {multiple: true},
+
+            start: {multiple: false},
+            not_start: {multiple: false},
+
+            end: {multiple: false},
+            not_end: {multiple: false},
+
+            true: {no_value: true, multiple: false},
+            not_true: {no_value: true, multiple: false},
+
+            false: {no_value: true, multiple: false},
+            not_false: {no_value: true, multiple: false},
+
+            present: {no_value: true, multiple: false},
+            blank: {no_value: true, multiple: false},
+
+            null: {no_value: true, multiple: false},
+            not_null: {no_value: true, multiple: false},
+        }
+        if op.present?
+          (operators[operator_name(op)] || {})
+        else
+          operators
+        end
+      end
+
+      def operator_default(op)
+        op_default = operators_list(op)
+        operator = {operator: operator_name(op)}
+        operator.deep_merge!(op_default) if op_default.present?
+        operator
+      end
+
+      def operator_translate(op)
+        I18n.t(op, default: op.to_s.humanize, scope: [:condition_builder, :operators])
+      end
+
+      def dictionary_name
+        self.to_s.sub('Dictionary', '').underscore.to_sym
+      end
+
+      def array_hashes_to_hash(array=nil)
+        array ||= []
+        array.reduce Hash.new, :merge
+      end
+
+      def operator_name(op)
+        op.to_s.downcase.to_sym
+      end
+    end
+
+  end
+end