symphonia 2.1.7

data/lib/symphonia/query.rb

@@ -0,0 +1,275 @@
+module Symphonia
+  class SymphoniaQueryNotRegistered < StandardError
+  end
+  class FilterNotFound < StandardError
+  end
+
+  class Query
+    attr_reader :set_filter, :controller
+    attr_writer :entity_scope, :filters
+    attr_accessor :disable_search, :active_filters, :options, :default_filters
+    attr_accessor :operators
+
+    class_attribute :model
+
+    # @param [nil, String] sort
+    # @param [Hash] filters
+    # @param [nil, Array] columns
+    def initialize(c = nil, sort: "", filters: {}, columns: nil, **options)
+      if c
+        ActiveSupport::Deprecation.warn("initialize allow only hash. #{c} - update your controller:")
+        #
+        # model.query.new sort: "default sort", filters: {default: filter}, columns: [columns, names]
+        # @query.from_params params
+        #
+      end
+      if options[:default_order]
+        ActiveSupport::Deprecation.warn("default_order is deprecated, use just `sort`")
+      end
+      @active_filters = {}
+      @default_sort = sort
+      @default_filters = filters
+      @default_column_names = columns
+      @options = options
+    end
+
+    def from_params(params)
+      @sort_col = params[:sort]
+      @sort_dir = params[:direction]
+      self.entity_scope = entity.like(@q) if (@q = params[:q].presence)
+      if (@set_filter = params[:set_filter].to_boolean)
+        setup_filters(params)
+      end
+      setup_columns(params)
+    end
+
+    protected
+
+    def setup_filters(params)
+      available_filters.each do |filter|
+        if (q = params[filter.name])
+          if q.blank?
+            active_filters.delete(filter.name)
+          else
+            operators.delete(filter.name)
+            active_filters[filter.name] = q.try(:downcase) || q
+            if (o = params[:o])
+              operators[filter.name] = o[filter.name]
+            end
+          end
+        end
+      end
+    end
+
+    def setup_columns(params)
+      if (c = params[:column_names]).present?
+        self.column_names = c
+      end
+    end
+
+    public
+
+    def sort_column
+      c, d = @default_sort.split(':')
+      c ||= available_columns[:name]&.name
+      @sort_table ||= SortableTable::SortTable.new(available_columns.collect { |_n, c| c.sort_definition }.compact,
+                                                   default_column: c&.to_sym,
+                                                   default_direction: d&.to_sym)
+      @sort_column ||= @sort_table.sort_column(@sort_col, @sort_dir)
+    rescue StandardError
+      raise "Incorrect default column: '#{options[:default_sort]}'"
+    end
+
+    def search?
+      disable_search.nil? && model.respond_to?(:like)
+    end
+
+    def activate_filter(name, value)
+      @active_filters[name] ||= value.downcase
+    end
+
+    alias add_filter activate_filter
+
+    def entity
+      model
+    end
+
+    def column_names=(names)
+      @column_names = (names.is_a?(Array) ? names : names.to_s.split('|')).map(&:to_sym)
+    end
+
+    def column_names
+      @column_names ||= default_column_names
+    end
+
+    def columns(all = false)
+      return available_columns.values if all || Array(column_names).blank?
+
+      @columns ||= column_names.map { |c| available_columns[c] }.compact
+    end
+
+    def render_filters
+      (available_filters | filters).each do |filter|
+        yield filter
+      end
+    end
+
+    def entity_scope
+      @entity_scope || model
+    end
+
+    def filters
+      setup_filters(default_filters) unless @set_filter
+      @filters ||= available_filters.select do |filter|
+        if (q = active_filters[filter.name])
+          operators && (filter.operator = operators[filter.name])
+          filter.value = q
+        end
+      end
+      @filters
+    end
+
+    def scope
+      opts = columns.each_with_object(includes: [], preload: [], joins: []) do |var, mem|
+        mem[:includes].concat var.includes
+        mem[:preload].concat var.preload
+        mem[:joins].concat var.joins
+      end
+      x = entity_scope.includes(opts[:includes].uniq).preload(opts[:preload].uniq).joins(opts[:joins].uniq)
+      filters.each do |filter|
+        x = filter.apply(x)
+      end
+      x
+    end
+
+    def entities
+      return @entities unless @entities.nil?
+
+      order = sort_column.order
+      @entities = scope.order(order.is_a?(String) && Arel.sql(order) || order)
+    end
+
+    def entity_count
+      entities.reorder(nil).count
+    end
+
+    def summarize_columns
+      columns.select(&:summarize?)
+    end
+
+    def to_partial_path
+      'symphonia/common/query'
+    end
+
+    def to_params(force = false)
+      if @q
+        { q: @q }
+      elsif @set_filter || force
+        filters.each_with_object(set_filter: 1) { |var, mem| f, v = var; mem[f.send(:form_field_name).to_sym] = v; }
+      else
+        {}
+      end
+    end
+
+    def inspect
+      "#<#{self.class.name} set_filter=#{@set_filter} >"
+    end
+
+
+    def available_filters
+      self.active_filters ||= {}
+      self.operators ||= {}
+
+      if @available_filters.nil?
+        @available_filters = []
+        register_filters
+      end
+      @available_filters
+    end
+
+    private
+
+    # @param [Symbol] filter_type
+    # @param [Symphonia::ModelAttributes::Attribute] attribute
+    # @param [Hash] options
+    def register_filter(filter_type, attribute, options = {})
+      @available_filters ||= []
+      klass = "Symphonia::ModelFilters::#{filter_type.to_s.classify}Filter".safe_constantize
+      return if klass.nil?
+
+      filter = klass.new(attribute, self, options)
+      yield filter if block_given?
+      @available_filters << filter
+    end
+
+    # def default_filter
+    #   {}
+    # end
+
+    def register_filters
+      model.registered_attributes.each do |_name, attribute|
+        register_filter(attribute.filter, attribute) if attribute.filter
+      end
+    end
+
+    def available_columns
+      if @available_columns.nil?
+        @available_columns = {}
+        register_columns
+      else
+        @available_columns
+      end
+      @available_columns
+    end
+
+    def default_column_names
+      if @default_column_names.nil?
+        @default_column_names = []
+        available_columns.each { |k, v| v.default? && @default_column_names << k }
+      end
+      @default_column_names
+    end
+
+    def add_column(_type, name, options = {})
+      @available_columns[name] = "Symphonia::QueryColumns::#{_type.to_s.classify}Column".constantize.new(name, self, options)
+    end
+
+    # aliases
+
+    def add_generic_column(name, options = {})
+      add_column(:generic, name, options)
+    end
+
+    def add_text_column(name, options = {})
+      add_column(:text, name, options)
+    end
+
+    def add_price_column(name, options = {})
+      add_column(:price, name, options)
+    end
+
+    def add_date_column(name, options = {})
+      add_column(:date, name, options)
+    end
+
+    def add_boolean_column(name, options = {})
+      add_column(:boolean, name, options)
+    end
+    #
+    def add_attribute_column(attribute, options = {})
+      @available_columns[attribute.name] = ::Symphonia::QueryColumns::AttributeColumn.new(attribute, self, options)
+    end
+
+    protected
+
+    def session_key(name)
+      [self.class.name.hash, name].join('-')
+    end
+
+    def register_columns
+      model.registered_attributes.values.each do |attribute|
+        add_attribute_column(attribute)
+      end
+    end
+  end
+end

data/lib/symphonia/query_columns/attribute_column.rb

@@ -0,0 +1,43 @@
+module Symphonia
+  module QueryColumns
+    class AttributeColumn < GenericColumn
+
+      attr_reader :attribute
+      attr_accessor :no_header, :sort_options
+      attr_writer :header, :sort
+
+      delegate :default?, :title, to: :attribute
+
+      def initialize(attribute, query, options={})
+        @attribute = attribute
+        @name = attribute.name
+        @query = query
+        @model = query.model
+        @options = options
+
+        @includes = options.delete(:includes) || reference? && [@name] || []
+        @preload = options.delete(:preload) || reference? && [@name] || []
+        @joins = Array(options.delete(:joins)) || []
+        @sort_definition = attribute.sort_column
+        @sort = attribute.sort?
+      end
+
+      def reference?
+        @attribute.is_a?(Symphonia::ModelAttributes::ReferenceAttribute)
+      end
+
+      # def header(table_header_tag)
+      #   if @header === false
+      #     table_header_tag.th(@name, '', sort: false)
+      #   else
+      #     table_header_tag.th(@name, title, {sort: @sort.nil?, sort_options: (sort_options || {}).merge({column: sort_column_name})})
+      #   end
+      # end
+
+      def format_value(view, entity)
+        @attribute.format(view, entity)
+      end
+
+    end
+  end
+end

data/lib/symphonia/query_columns/generic_column.rb

@@ -0,0 +1,165 @@
+module Symphonia
+  module QueryColumns
+    class GenericColumn
+
+      attr_reader :name, :query, :model, :includes, :preload, :joins
+      attr_writer :sort_column_name, :sort_definition
+      attr_accessor :sort, :header, :default
+
+      def initialize(name, klass = nil, options={})
+        ::ActiveSupport::Deprecation.warn 'Maybe this class is over...'
+        @name = name
+        if klass.is_a? Symphonia::Query
+          @query = klass
+          @model = @query.model
+        elsif klass < ActiveRecord::Base
+          @model = klass
+        else # default fallback
+          @model = ActiveRecord::Base
+        end
+        @options = options
+
+        # @sort_options = @options.delete(:sort_options) || {}
+        self.header = @options.delete(:header).nil?
+        self.sort = @options.delete(:sort).nil?
+
+        @includes = Array(options.delete(:includes)) || []
+        @preload = Array(options.delete(:preload)) || []
+        @joins = Array(options.delete(:joins)) || []
+      end
+
+      def summarize?
+        false
+      end
+
+      def header?
+        !(@header === false)
+      end
+
+      def sort?
+        !(@sort === false)
+      end
+
+      def default?
+        !!@default
+      end
+
+      def header(view)
+        ::ActiveSupport::Deprecation.warn 'Header method is deprecated -> use app/helpers/symphonia/renderer_helper.rb:59'
+        if @no_header || @header === false
+          title
+        else
+          view.symphonia_query_sort_tag(self)
+        end
+      end
+
+      def sort_definition
+        return nil unless sort?
+        @sort_definition ||= SortableTable::SortColumnCustomDefinition.new(@name, {asc: "#{sort_column_name} asc", desc: "#{sort_column_name} desc"})
+      end
+
+      def title
+        ::ActiveSupport::Deprecation.warn 'method is deprecated'
+        @model.human_attribute_name(@name, @options[:i18n] || {})
+      end
+
+      def sort_options
+        @sort_options
+      end
+
+      def value(entity)
+        entity.send(name)
+      end
+
+      def format_value(view, entity)
+        if @options[:formatter].is_a?(Proc)
+          @options[:formatter].call(view, entity).to_s
+        else
+          case @options[:with_link]
+          when :entity, true
+            view.link_to(value(entity).to_s, entity)
+          when :value
+            view.link_to(value(entity).to_s, value(entity))
+          else
+            value(entity).to_s
+          end
+        end
+      end
+
+      def sum_value(view)
+        format_value(view, OpenStruct.new(name => sum))
+      end
+
+      def sum
+        return nil unless summarize?
+        @sum ||= query.entities.sum(name)
+      end
+
+      def css_classes
+        @name.to_s
+      end
+
+      def inspect
+        "#<#{self.class.name} name='#{name}' options=#{@options.inspect}>"
+      end
+
+      private
+
+      def t(*args)
+        I18n.translate(*args)
+      end
+
+      def l(*args)
+        I18n.localize(*args)
+      end
+
+      def sort_column_name
+        @sort_column_name.presence || [@model.table_name, @name].join('.')
+      end
+    end
+
+    class TextColumn < GenericColumn
+
+      def format_value(view, entity)
+        view.format_text(super(view, entity))
+      end
+
+    end
+
+    class NumberColumn < GenericColumn
+
+      def summarize?
+        true
+      end
+
+    end
+
+    class PriceColumn < NumberColumn
+
+      def format_value(view, entity)
+        view.format_price(super(view, entity))
+      end
+
+    end
+
+    class DateColumn < GenericColumn
+
+      def format_value(view, entity)
+        value(entity) && l(value(entity), format: @options[:format])
+      end
+
+    end
+
+    class BooleanColumn < GenericColumn
+
+      def format_value(view, entity)
+        if value(entity)
+          view.fa_icon('true', title: t(:true))
+        end
+      end
+
+    end
+
+  end
+
+end

data/lib/symphonia/query_columns.rb

@@ -0,0 +1,8 @@
+require_dependency('symphonia/query_columns/generic_column')
+require_dependency('symphonia/query_columns/attribute_column')
+
+module Symphonia
+  module QueryColumns
+
+  end
+end

data/lib/symphonia/spec_helper.rb

@@ -0,0 +1,4 @@
+require File.expand_path('../../../spec/spec_helper', __FILE__)
+Dir.glob(File.expand_path('../../../spec/{factories,support}/*.rb', __FILE__)).each do |file|
+  require file
+end

data/lib/symphonia/user_management.rb

@@ -0,0 +1,58 @@
+module Symphonia
+  module UserManagement
+
+    extend ActiveSupport::Concern
+
+    included do
+
+      enum status: { active: 1, pending: 5, archived: 9 }
+
+      scope :sorted, -> { order(:first_name, :last_name) }
+
+      # validates :mail, uniqueness: true, format: { with: Authlogic::Regex::EMAIL_NONASCII }
+      # validates :password, presence: true, if: ->(u){ u.new_record? }
+
+      validates :login, :mail, :first_name, :last_name, presence: true
+
+      def self.current=(entity)
+        Rails.logger.info("* #{entity.class.name}: #{entity.login} id: #{entity.id}")
+        Thread.current[:"current_#{name.underscore}"] = entity
+      end
+
+      def self.current
+        Thread.current[:"current_#{name.underscore}"] ||= "#{self}::Anonymous".constantize.new
+      end
+
+      def name
+        "#{first_name} #{last_name}"
+      end
+
+      def status_new?
+        pending?
+      end
+
+      def lock?
+        !active?
+      end
+
+      alias_method :archive?, :lock?
+
+      def archive!
+        archived!
+      end
+
+      def unarchive!
+        active!
+      end
+
+      alias_method :activate!, :unarchive!
+
+      def css_classes
+        css = ''
+        css << ' -active' if self.active?
+        css << ' lock' if self.lock?
+        css
+      end
+    end
+  end
+end

data/lib/symphonia/version.rb

@@ -0,0 +1,4 @@
+module Symphonia
+  VERSION = '2.1.7'
+  VERSION_NAME = '2019.03.31'
+end

data/lib/symphonia.rb

@@ -0,0 +1,20 @@
+# Dir[File.dirname(__FILE__) + '/symphonia/*.rb'].each {|file| require file }
+module Symphonia
+  include ::ActiveSupport::Configurable
+
+  autoload :BaseController, 'symphonia/base_controller'
+  autoload :ControllerExtensions, 'symphonia/controller_extensions'
+  autoload :FormBuilder, 'symphonia/form_builder'
+  autoload :BootstrapLinkRender, 'symphonia/bootstrap_link_render'
+  autoload :Query, 'symphonia/query'
+  autoload :ModelAttributes, 'symphonia/model_attributes'
+  autoload :ModelFilters, 'symphonia/model_filters'
+  autoload :Attachable, 'symphonia/attachable'
+  autoload :QueryColumns, 'symphonia/query_columns'
+
+  module ActionCable
+    autoload :Connection, 'symphonia/action_cable/connection'
+  end
+end
+
+require 'symphonia/engine'

data/spec/controllers/account_controller_spec.rb

@@ -0,0 +1,90 @@
+module Symphonia
+  RSpec.describe AccountsController do
+
+    include ActiveJob::TestHelper
+
+    routes { Symphonia::Engine.routes }
+
+    let(:regular_user) { FactoryBot.create(:user) }
+
+    context 'logged', logged: true do
+      context '#update' do
+
+        it 'valid' do
+          put :update, params: { user: { login: Faker::Internet.user_name } }
+          expect(response).to redirect_to account_path
+        end
+
+        it 'invalid' do
+          put :update, params: { user: { login: '' } }
+          expect(response).to have_http_status :success
+        end
+
+      end
+
+    end
+
+    context '#resend_activation' do
+
+      let(:email) { Faker::Internet.email }
+      subject { get :resend_activation, params: { mail: email } }
+
+      it 'non exist user' do
+        is_expected.to redirect_to :root
+        expect(flash[:error]).not_to be :blank
+      end
+
+      it 'active user' do
+        _user = FactoryBot.create(:user, email: email, status: 'active')
+        is_expected.to redirect_to :root
+        expect(flash[:error]).not_to be :blank
+      end
+
+      it 'pending user' do
+        user = FactoryBot.create(:user, email: email, status: 'pending')
+        token = user.perishable_token.dup
+
+        expect { get :resend_activation, params: { mail: email } }.to have_enqueued_job.on_queue('mailers')
+        expect(response).to have_http_status :redirect
+
+        expect(user.reload.perishable_token).not_to eq token
+        expect(flash[:error]).to be_nil
+        expect(flash[:notice]).not_to be :blank
+      end
+    end
+
+    context '#activation' do
+      let(:token) { SecureRandom.hex(3) }
+      subject { get :activation, params: { activation_code: token } }
+
+      it 'valid token' do
+        user = FactoryBot.create(:user, status: 'pending')
+        user.update_columns(perishable_token: token)
+        is_expected.to redirect_to :login
+        expect(user.reload.status).to eq 'active'
+      end
+
+      it 'invalid token' do
+        is_expected.to redirect_to :root
+        expect(flash[:error]).not_to be :blank
+      end
+    end
+
+    context '#lost_password' do
+
+      it 'with mail' do
+        user = FactoryBot.create(:user, status: 'active')
+
+        expect { post :lost_password, params: { mail: user.email } }.to have_enqueued_job.on_queue('mailers')
+        expect(flash[:error]).to be_nil
+      end
+
+      it 'with inactive user' do
+        user = FactoryBot.create(:user, status: 'pending')
+        expect { post :lost_password, params: { mail: user.email } }.not_to have_enqueued_job.on_queue('mailers')
+        expect(flash[:error]).not_to be :blank
+      end
+    end
+
+  end
+end

data/spec/controllers/admin_controller_spec.rb

@@ -0,0 +1,35 @@
+module Symphonia
+  RSpec.describe AdminController do
+    routes { Symphonia::Engine.routes }
+
+    context 'no user' do
+
+      it '#index' do
+        get :index
+        expect(response).to redirect_to login_path
+      end
+
+      it '#test_mail' do
+        get :test_mail
+        expect(response).to redirect_to login_path
+      end
+
+    end
+
+    context 'logged in', logged: true do
+      include ActiveJob::TestHelper
+
+      it '#index' do
+        get :index
+        expect(response).to have_http_status :success
+      end
+
+      it '#test_mail' do
+        Rails.application.config.action_mailer.delivery_method = :test
+        expect { get :test_mail }.to have_enqueued_job.on_queue('mailers')
+        expect(response).to have_http_status :redirect
+      end
+
+    end
+  end
+end