symphonia 2.1.7

data/lib/symphonia/model_attributes.rb

@@ -0,0 +1,102 @@
+require 'active_support/concern'
+<<EXAMPLE
+# user.rb
+class User
+ include Symphonia::ModelAttributes
+
+  register_query do
+    add_attribute :login, :link
+    add_attribute :name, sort: %i[first_name last_name]
+    add_attribute :first_name
+    add_attribute :last_name
+    add_attribute :mail, :mail
+    add_attribute :status, :enum
+    add_attribute :role, :reference
+    add_attribute :admin, :boolean
+    add_attribute :login_count
+    add_attribute :last_login_ip
+    add_attribute :last_login_at
+
+    add_attribute :author, :reference, sort: "users.last_name" 
+
+    # @param [ActiveSupport::View] view
+    # @param [Symphonia::ModelAttributes::Attribute] attribute
+    # @param [ApplicationRecord] entity
+    add_attribute :custom do |view, attribute, entity|
+      view.link_to(attribute.value(entity), entity.custom)
+    end
+  end
+end
+# users/show.html.erb
+@user.format_value :login, self
+@user.format_value :name, self
+@user.format_value :role, self
+
+EXAMPLE
+require_dependency 'symphonia/model_attributes/attribute'
+module Symphonia
+  module ModelAttributes
+
+    extend ActiveSupport::Concern
+
+    included do
+
+      mattr_accessor :registered_attributes do
+        {}
+      end
+      mattr_accessor :query
+
+      def format_value(name, view = nil)
+        value = send(name)
+        return value if view.nil?
+
+        f = get_attribute(name)
+        if f.nil?
+          Rails.logger.debug "Attribute '#{name}' not found in #{self.class.name}"
+          value
+        else
+          f.format(view, self)
+        end
+
+      end
+
+      def get_attribute(name)
+        self.class.registered_attributes[name]
+      end
+    end
+
+    class_methods do
+
+      def register_query(klass = nil, &block)
+        # klass ||= "Symphonia::Queries::#{self.name.demodulize}".constantize
+        return true unless query.nil?
+
+        klass ||= Class.new(Symphonia::Query)
+        klass.model = self
+        self.query = klass
+
+        yield klass
+
+        self.query = klass
+      end
+
+      def add_attribute(name, *args, &block)
+        options = args.extract_options!
+        formatter = args.shift
+        c = if formatter
+              [formatter, 'attribute'].join('_').classify
+            else
+              (columns_hash[name.to_s].try(:type).to_s + 'Attribute').classify
+            end
+        _c = ('Symphonia::ModelAttributes::' + c).safe_constantize || Symphonia::ModelAttributes::Attribute
+        attr = _c.new(name, self, options, block_given? ? block : formatter)
+        if options.has_key?(:sort)
+          attr.sort = options.delete(:sort)
+        end
+        attr.filter = options[:filter] || columns_hash[name.to_s].try(:type)
+        registered_attributes[name.to_sym] = attr
+      end
+    end
+  end
+
+end

data/lib/symphonia/model_filters/base.rb

@@ -0,0 +1,82 @@
+module Symphonia
+  module ModelFilters
+    class Base
+      attr_reader :name, :type, :caption, :options, :query, :value, :operator
+
+      # @param [Symphonia::ModelAttributes::Attribute] attribute
+      # @param [Symphonia::Query] query
+      # @param [Hash] options
+      def initialize(attribute, query, options = {})
+        if attribute.is_a? String
+          ActiveSupport::Deprecation.warn("name as argument is no longer supported - use Attribute")
+          @name = attribute
+        else
+          @name = attribute.name
+          @attribute = attribute
+        end
+        @options = options
+        @query = query
+        @operator = 'eq'
+      end
+
+      def caption
+        @caption = @options[:caption]
+        @caption ||= query.model.human_attribute_name(name)
+      end
+
+      def form_field(_c)
+        raise NotImplementError
+      end
+
+      def inspect
+        "#<#{self.class.name} name='#{name}' caption='#{caption}' options=#{@options.inspect}>"
+      end
+
+      def active?
+        !!query.active_filters[name]
+      end
+
+      def value=(q)
+        if (m = q.downcase.match(/^([!~><]+)(.*)/))
+          @value = m[2]
+          self.operator = m[1]
+        else
+          @operator ||= 'eq'
+          @value = q
+        end
+
+        @value
+      end
+
+      def operator=(o)
+        @operator = case o
+                    when '!'
+                      'not_eq'
+                    when '~'
+                      @value = "%#{@value}%"
+                      'matches'
+                    when '!~'
+                      @value = "%#{@value}%"
+                      'not_matches'
+                    when '>'
+                      'lt'
+                    when '<'
+                      'gt'
+                    else
+                      'eq'
+                    end
+      end
+
+      def apply(_scope)
+        Rails.logger.debug("Apply filter #{name} '#{operator}' #{value}")
+      end
+
+      private
+
+      def form_field_name
+        name
+      end
+
+    end
+  end
+end

data/lib/symphonia/model_filters/boolean_filter.rb

@@ -0,0 +1,26 @@
+module Symphonia
+  module ModelFilters
+    class BooleanFilter < Base
+
+      def operator=(o)
+        if o == '!'
+          @operator = 'not_eq'
+        else
+          @operator = 'eq'
+        end
+      end
+
+      def apply(scope)
+        super
+        t = scope.arel_table
+        scope.where(t[name].send(operator, true))
+      end
+
+      def form_field(_c)
+        _c.text_field_tag(form_field_name, @query.active_filters[name], class: 'form-control')
+      end
+    end
+
+  end
+
+end

data/lib/symphonia/model_filters/date_filter.rb

@@ -0,0 +1,81 @@
+module Symphonia
+  module ModelFilters
+    class DateFilter < Base
+      attr_accessor :available_values
+
+      def initialize(name, query, options={})
+        super
+        @operator = 'in'
+      end
+
+      def value=(q)
+        v = available_values.values.reduce(:merge)[q.to_sym]
+        @operator = 'between' unless q == 'today'
+        @value = if q == 'custom'
+                   data = self.query.controller.params.require(:date_from_custom).permit(:from, :to)
+                   v.call(data)
+                 else
+                   v.call
+                 end
+      end
+
+      # def operator=(o)
+      #   if o == '!'
+      #     @operator = 'not_in'
+      #   end
+      # end
+
+      def apply(scope)
+        super
+        t = scope.arel_table
+        scope.where(t[name].send(operator, value))
+      end
+
+      def available_values
+        {
+          past: {
+            last_month: -> {d = Date.today.last_month.beginning_of_month; d..d.end_of_month},
+            last_year: -> {d = Date.today.last_year.beginning_of_year; d..d.end_of_year}
+          },
+          present: {
+            today: -> {Date.today},
+            this_month: -> {Date.today.beginning_of_month..Date.today.end_of_month},
+            this_year: -> {Date.today.beginning_of_year..Date.today.end_of_year},
+            custom: ->(data) {data[:from].to_date..data[:to].to_date}
+          },
+          future: {
+            next_month: -> {d = Date.today.next_month.beginning_of_month; d..d.end_of_month},
+            next_year: -> {d = Date.today.next_year.beginning_of_year; d..d.end_of_year}
+          }
+        }
+      end
+
+      def form_field(_c)
+        groups = available_values.inject({}) do |mem, (time, values)|
+          mem[_c.t("time.#{time}")] = values.collect do |(k, _val)|
+            [_c.t("query_options.filter_date.values.#{k}"), k]
+          end
+          mem
+        end
+        selected = Array(@query.active_filters[name])
+        _c.content_tag(:div, class: 'row') do
+          _c.select_tag("#{form_field_name}", _c.grouped_options_for_select(groups, selected), {
+            class: 'form-control',
+            include_blank: true,
+            onchange: 'symphoniaFiltersForm.dateFilterCallback(this)'
+          }) + _c.content_tag(:div, class: 'filter-custom-date clearfix input-daterange input-group inline', style: 'display: none') do
+            _c.date_field_tag("#{form_field_name}_custom[to]", '', {
+              placeholder: _c.t('query_options.filter_date.to'),
+              class: 'form-control datepicker pull-right'
+            }) +
+              # _c.content_tag(:span, _c.t('query_options.filter_date.to'), class: 'input-group-addon')+
+              _c.date_field_tag("#{form_field_name}_custom[from]", '', {
+                placeholder: _c.t('query_options.filter_date.from'),
+                class: 'form-control datepicker'
+              })
+          end
+        end
+      end
+    end
+  end
+end

data/lib/symphonia/model_filters/integer_filter.rb

@@ -0,0 +1,18 @@
+module Symphonia
+  module ModelFilters
+    class IntegerFilter < Base
+
+      def apply(scope)
+        super
+        t = scope.arel_table
+        scope.where(t[name].send(operator, value.to_f))
+      end
+
+      def form_field(_c)
+        _c.number_field_tag(form_field_name, @query.active_filters[name], class: 'form-control')
+      end
+    end
+
+  end
+
+end

data/lib/symphonia/model_filters/select_filter.rb

@@ -0,0 +1,48 @@
+module Symphonia
+  module ModelFilters
+    class SelectFilter < StringFilter
+      attr_accessor :available_values
+
+      def initialize(name, query, options = {})
+        super
+        @operator = 'in'
+      end
+
+      def available_values
+        return @available_values.call(_c, self) if @available_values.is_a? Proc
+
+        @available_values || case @attribute
+                             when Symphonia::ModelAttributes::EnumAttribute
+                               @query.model.send(@attribute.name.to_s.pluralize).keys
+                             end
+      end
+
+      def value=(q)
+        @value = Array(q)
+      end
+
+      def operator=(o)
+        if o == '!'
+          @operator = 'not_in'
+        end
+      end
+
+      def apply(scope)
+        super
+        t = scope.arel_table
+        scope.where(t[name].send(operator, value))
+      end
+
+      def form_field(_c)
+        selected = Array(@query.active_filters[name])
+        _c.content_tag(:div, class: 'input-group') do
+          _c.content_tag(:div, class: 'input-group-prepend') do
+            _c.content_tag(:span, _c.check_box_tag("o[#{form_field_name}]", '!', operator == 'not_in', title: 'Not In'), class: "input-group-text")
+          end +
+            _c.select_tag("#{form_field_name}[]", _c.options_for_select(available_values, selected), class: 'form-control', include_blank: true, multiple: selected.size > 1) +
+            _c.content_tag(:div, _c.link_to(_c.fa_icon('plus-square-o'), 'javascript:void(0)', onclick: "toggleMultiSelect($(this).closest('.input-group').find('select'))", title: I18n.t(:title_toggle_multiselect), class: "input-group-text"), class: 'input-group-append')
+        end
+      end
+    end
+  end
+end

data/lib/symphonia/model_filters/string_filter.rb

@@ -0,0 +1,18 @@
+module Symphonia
+  module ModelFilters
+    class StringFilter < Base
+
+      def apply(scope)
+        super
+        t = scope.arel_table
+        scope.where(t[name].lower.send(operator, Array(value).map(&:downcase)))
+      end
+
+      def form_field(_c)
+        _c.text_field_tag(form_field_name, @query.active_filters[name], class: 'form-control')
+      end
+    end
+
+  end
+
+end

data/lib/symphonia/model_filters.rb

@@ -0,0 +1,10 @@
+require_dependency 'symphonia/model_filters/base'
+require_dependency 'symphonia/model_filters/string_filter'
+require_dependency 'symphonia/model_filters/date_filter'
+require_dependency 'symphonia/model_filters/boolean_filter'
+require_dependency 'symphonia/model_filters/integer_filter'
+require_dependency 'symphonia/model_filters/select_filter'
+module Symphonia
+  module ModelFilters
+  end
+end

data/lib/symphonia/object.rb

@@ -0,0 +1,31 @@
+class Object
+  # def to_boolean
+  #   return true if self.is_a?(TrueClass)
+
+  #   respond_to?(:downcase) && ['true', 1, '1', 'yes', 't', 'y'].include?(self.downcase)
+  # end
+end
+
+class String
+  def to_boolean
+    ['true', 1, '1', 'yes', 't', 'y'].include?(self.downcase)
+  end
+end
+
+class NilClass
+  def to_boolean
+    false
+  end
+end
+
+class FalseClass
+  def to_boolean
+    false
+  end
+end
+
+class TrueClass
+  def to_boolean
+    true
+  end
+end

data/lib/symphonia/permissions.rb

@@ -0,0 +1,93 @@
+require 'rails'
+module Symphonia
+  module Permissions
+    @@mapper = []
+    @@used_names = []
+    mattr_accessor :mapper, :used_names
+    class PermissionMissingError < RuntimeError; end
+    class << self
+
+      def map(&block)
+        if block_given?
+          yield self
+        end
+      end
+
+      def register(name, options={})
+        return if @@used_names.include?(name)
+
+        p = Permission.new(name, options)
+        @@used_names << p.name.to_s
+        mapper << p
+
+        p
+      end
+
+      def update(name)
+        self.get(name) || raise(PermissionMissingError)
+      end
+
+      # Returns the permission of given name or nil if it wasn't found
+      # Argument should be a symbol
+      def get(name)
+        mapper.detect{|i| i.name == name}
+      end
+
+      def all
+        mapper
+      end
+
+      def find_all(permission_names=[])
+        ps = used_names & Array(permission_names).compact
+        ps.collect{|m| get(m.to_sym)}
+      end
+
+    end
+
+    class Permission
+      attr_reader :name
+      # actions => [:controller_name => [:action, :action, :action]]
+      def initialize(name, options={})
+        @name = name
+        @perms = Hash.new { |hash, key| hash[key] = Array.new }
+      end
+      alias_method :id, :name
+
+      def to_s
+        @name.to_s
+      end
+
+      def allowed?(controller, action)
+        Array(@perms[controller.to_sym]).include?(action.to_sym)
+      end
+
+      def add(controller, actions=[])
+        @perms[controller] += actions
+      end
+
+      def remove_actions(controller, actions=[])
+        @perms[controller] -= actions
+      end
+
+      def remove_controller(controller)
+        @perms.delete(controller)
+      end
+
+      def controllers
+        @controllers ||= @perms.keys
+      end
+
+      def allow_action?(controller, action)
+        controller = controller.to_sym
+        action = action.to_sym
+
+        if self.controllers.include?(controller)
+          return @perms[controller].include?(action)
+        else
+          return false
+        end
+      end
+    end
+  end
+
+end