anoubis 1.0.0

data/app/controllers/anoubis/etc/field.rb

@@ -0,0 +1,468 @@
+module Anubis
+  module Etc
+    ##
+    # Definitions of field options for table column or new (edit) form field.
+    class Field
+      # @!attribute [rw]
+      # Defines field title.
+      # @return [String] field's title
+      class_attribute :title, default: nil
+
+      # @!attribute [rw]
+      # Defines field type
+      #
+      # Possible values of field's type are 'string', 'integer', 'float', 'listbox', 'checkbox', 'longlistbox'
+      # and 'datetime'
+      # @return [String] field's type.
+      class_attribute :type, default: ''
+
+      # Defines date format for field type 'datetime'
+      # Possible values of field's format are 'date', 'full', 'datetime', 'month', 'year'.
+      # @return [String] field's type.
+      class_attribute :format, default: ''
+
+      # Defines precision for field type 'number'
+      # Possible values of this field is integer numbers between 0 and 6. If precision is 0 then number is integer.
+      # @return [String] field's type.
+      class_attribute :precision, default: 0
+
+      # @!attribute [rw]
+      # Defines field order options.
+      # @return [FieldOrder] field's order options
+      class_attribute :order, default: nil
+
+      # @!attribute [rw]
+      # Defines field's visibility for table representation data
+      # @return [Boolean] field's visibility
+      class_attribute :visible, default: true
+
+      # @!attribute [rw]
+      # Field's identifier
+      # @return [String] field's identifier
+      class_attribute :key, default: nil
+
+      # @!attribute [rw] field
+      # Field's name is used for access field value in model
+      # @return [String] field's name
+      class_attribute :field, default: nil
+
+      # @!attribute [rw] table_field
+      # Field's name is used for operation with table data (like 'where', 'order' and etc.)
+      # @return [String] field's name in the table
+      class_attribute :table_field, default: nil
+
+      # @!attribute [rw] error_text
+      # Text is shown when system can't access to data with presented {#field} name
+      # @return [String] field's error_text
+      class_attribute :error_text, default: ''
+
+      # @!attribute [rw]
+      # Describes additional field's options for type 'checkbox', 'listbox'.
+      # @return [FieldOptions] field's options.
+      class_attribute :options, default: nil
+
+      # @!attribute [rw]
+      # Describes if this field could return data for {Anubis::Data::Actions#autocomplete autocomplete} action.
+      # @return [Boolean] possibility for return data on autocomplete action.
+      #
+      # <b>Options:</b>
+      # - <b>:limit</b> (Integer) -- maximum number of elements <i>(defaults to: 10)</i>
+      # - <b>:count</b> (Integer) -- Minimum symbols count for output <i>(defaults to: 3)</i>
+      # @return [Hash] autocomplete definitions for field
+      class_attribute :autocomplete, default: false
+
+      # @!attribute [rw]
+      # Defines model's description for complex field
+      #
+      # <b>Options:</b>
+      # - <b>:model</b> (ActiveRecord) -- model class
+      # - <b>:title</b> (Symbol) -- field name is used for receive options titles <i>(defaults to: :title)</i>
+      # - <b>:order</b> (Symbol) -- field name is used for order options <i>(defaults to: :title option)</i>
+      # - <b>:where</b> (Hash) -- where parameters for select data from model <i>(defaults to: {})</i>
+      # @return [Model] model's description for complex field
+      class_attribute :model, default: nil
+
+      # @!attribute [rw] editable
+      # Defines if key of this field can be edited
+      # @return [String] returns path for edit field options
+      class_attribute :editable, default: nil
+
+      ##
+      # Sets default parameters for field
+      # @param key [Symbol] field's identifier
+      # @param model [ActiveRecord] field's model
+      # @param options [Hash] field's initial options
+      def initialize(key, model, options = {})
+        #puts key
+        #puts options
+        self.field = nil
+        self.key = key.to_s
+        self.format = ''
+        self.precision = 0
+        self.title = options[:title] if options.key? :title
+        self.type = if options.key? :type then options[:type] else 'string' end
+        self.visible = if options.key? :visible then options[:visible] else true end
+        self.options = if options.key? :options then FieldOptions.new(options[:options]) else nil end
+        if options.key? :order
+          if options[:order].class == Hash
+            options[:order][:field] = Kernel.format('%s.%s', model.table_name, self.key.to_s) if !options[:order].key? :field
+          end
+          self.order = if options.key? :order then FieldOrder.new(options[:order]) else nil end
+        end
+        self.model = if options.key? :model then Model.new(options[:model]) else nil end
+        self.editable = if options.key? :editable then options[:editable] else nil end
+        self.autocomplete = if options.key? :autocomplete then options[:autocomplete] else nil end
+        self.error_text = if options.key? :error_text then options[:error_text] else I18n.t('errors.field_error') end
+
+        self.send Kernel.format('initialize_%s', self.type), options
+
+        if !options.key? :table_field
+          if !options.key? :field
+            if self.order
+              options[:table_field] = self.order.field if self.order.field
+            end
+          end
+        end
+
+        if !self.field
+          self.field = if options.key? :field then options[:field] else self.key end
+        end
+
+        self.table_field = if options.key?(:table_field) then options[:table_field] else Kernel.format('%s.%s', model.table_name, self.field) end
+
+        if self.autocomplete
+          self.autocomplete[:limit] = 10 if !autocomplete.key? :limit
+          self.autocomplete[:count] = 3 if !autocomplete.key? :count
+          self.autocomplete[:where] = []
+        end
+        #puts self.to_h
+      end
+
+      ##
+      # Initialize additional parameters for {Anubis::Etc::Field#type 'string' field type} for controller actions.
+      # @param options [Hash] field's initial options
+      def initialize_string (options)
+
+      end
+
+      ##
+      # Initialize additional parameters for {Anubis::Etc::Field#type 'boolean' field type} for controller actions.
+      # @param options [Hash] field's initial options
+      def initialize_boolean (options)
+
+      end
+
+      ##
+      # Initialize additional parameters for {Anubis::Etc::Field#type 'number' field type} for controller actions.
+      # @param options [Hash] field's initial options
+      def initialize_number (options)
+        if options.key? :error_text
+          self.error_text = options[:error_text]
+        else
+          self.error_text = ''
+        end
+        self.precision = options[:precision].to_s.to_i if options.key? :precision
+        self.precision = 0 if self.precision < 0
+        self.precision = 16 if self.precision > 16
+      end
+
+      ##
+      # Initialize additional parameters for {Anubis::Etc::Field#type 'text' field type} for controller actions.
+      # @param options [Hash] field's initial options
+      def initialize_text (options)
+
+      end
+
+      ##
+      # Initialize additional parameters for {Anubis::Etc::Field#type 'html' field type} for controller actions.
+      # @param options [Hash] field's initial options
+      def initialize_html (options)
+
+      end
+
+      ##
+      # Initialize additional parameters for {Anubis::Etc::Field#type 'datetime' field type} for controller actions.
+      # @param options [Hash] field's initial options
+      def initialize_datetime (options)
+        options[:format] = 'datetime' if !options.key? :format
+        options[:format] = 'datetime' if !%w[date datetime full year month].include? options[:format]
+        self.format = options[:format]
+      end
+
+      ##
+      # Setups additional parameters for {Anubis::Etc::Field#type 'listbox' field type} for controller actions.
+      # @param options [Hash] field's initial options
+      def initialize_listbox (options)
+        self.options = FieldOptions.new if !self.options
+        if !self.options.list
+          if self.model
+            if !(%w[update create].include?(options[:action]))
+              self.options.show = 'update'
+              if self.options.line
+                self.options.list = self.options.line
+              else
+                self.options.list = {}
+              end
+              self.model.model.select(self.model.select).where(self.model.where).order(self.model.order).each do |dat|
+                self.options.list[dat.id.to_s.to_sym] = dat.send(self.model.title)
+                if dat.respond_to? :updated_at
+                  if self.model.updated_at < dat.updated_at.to_time.utc.to_i
+                    self.model.updated_at = dat.updated_at.to_time.utc.to_i
+                  end
+                end
+              end
+            end
+          end
+        end
+        options[:format] = 'single' unless options.key? :format
+        options[:format] = 'single' unless %w[single multiple].include? options[:format]
+        self.format = options[:format]
+      end
+
+      ##
+      # Initialize additional parameters for {Anubis::Etc::Field#type 'key' field type} for controller actions.
+      # @param options [Hash] field's initial options
+      def initialize_key (options)
+        if self.model
+          self.error_text = '' if options[:action] == 'new'
+          self.field = Kernel.format('%s.%s', self.key, self.model.title) if !options.key? :field
+          self.table_field = Kernel.format('%s.%s', self.model.model.table_name, self.model.title) if !self.table_field
+          self.autocomplete = {} if !options.key? :autocomplete
+        end
+      end
+
+      ##
+      # Return field properties for frontend application
+      # @param model [ActiveRecord] field's model
+      # @param action [Srting] current field action
+      # @return [Hash] field's properties for defined action
+      def properties (model, action)
+        if %w[new edit].include? action
+          return self.properties_forms model, action
+        end
+        self.properties_index model, action
+      end
+
+      ##
+      # Return field properties for frontend application for action 'index'
+      # @param model [ActiveRecord] field's model
+      # @param action [Srting] current field action
+      # @return [Hash] field's properties for defined action
+      def properties_index (model, action)
+        result = {
+            id: self.key,
+            type: self.type,
+            sortable: self.order != nil
+        }
+
+        if self.title
+          result[:title] = self.title
+        else
+          result[:title] = model.human_attribute_name(self.key)
+        end
+
+        result[:editable] = self.editable if self.editable != nil
+        result[:editable] = false if self.type == 'key'
+        result[:format] = self.format if self.type == 'datetime'
+        result[:precision] = self.precision if self.type == 'number'
+        result[:options] = self.hash_to_json(self.options.list) if self.options
+        result
+      end
+
+      ##
+      # Return field properties for frontend application for actions 'edit', 'new'
+      # @param model [ActiveRecord] field's model
+      # @param action [Srting] current field action
+      # @return [Hash] field's properties for defined action
+      def properties_forms (model, action)
+        mod = model.new
+        result = {
+            id: self.key,
+            title: model.human_attribute_name(self.key),
+            type: self.type
+        }
+        result.merge!(self.send(Kernel.format('properties_forms_%s', self.type), model, action, mod))
+        result
+      end
+
+      ##
+      # Return field properties for frontend application for actions 'edit', 'new' and type 'string'
+      # @param model [ActiveRecord] field's model
+      # @param action [Srting] current field action
+      # @param mod [ActiveRecord] initialized new model element
+      # @return [Hash] field's properties for defined action
+      def properties_forms_string (model, action, mod)
+        result = {}
+        errors = {}
+        res = model.validators_on(self.key.to_sym).detect { |v| v.is_a?(ActiveModel::Validations::LengthValidator) }
+        if res
+          if res.options.key? :minimum
+            result[:min] = res.options[:minimum]
+            errors[:min] = model.human_attribute_name(self.key) + ' ' + mod.errors.generate_message(self.key.to_sym, :too_short, { count: result[:min] })
+          end
+          if res.options.key? :maximum
+            result[:max] = res.options[:maximum]
+            errors[:max] = model.human_attribute_name(self.key) + ' ' + mod.errors.generate_message(self.key.to_sym, :too_long, { count: result[:max] })
+          end
+        end
+        res = model.validators_on(self.key.to_sym).detect { |v| v.is_a?(ActiveModel::Validations::PresenceValidator) }
+        if res
+          result[:required] = true
+          errors[:required] = model.human_attribute_name(self.key) + ' ' + mod.errors.generate_message(self.key.to_sym, :blank)
+        end
+        result[:errors] = errors if errors.length > 0
+        result
+      end
+
+      ##
+      # Return field properties for frontend application for actions 'edit', 'new' and type 'number'
+      # @param model [ActiveRecord] field's model
+      # @param action [Srting] current field action
+      # @param mod [ActiveRecord] initialized new model element
+      # @return [Hash] field's properties for defined action
+      def properties_forms_number (model, action, mod)
+        result = {}
+        errors = {}
+        res = model.validators_on(self.key.to_sym).detect { |v| v.is_a?(ActiveModel::Validations::NumericalityValidator) }
+        if res
+          if res.options.key? :greater_than_or_equal_to
+            result[:min] = res.options[:greater_than_or_equal_to]
+            errors[:min] = model.human_attribute_name(self.key) + ' ' + mod.errors.generate_message(self.key.to_sym, :greater_than_or_equal_to, { count: result[:min] })
+          end
+          if res.options.key? :maximum
+            result[:max] = res.options[:maximum]
+            errors[:max] = model.human_attribute_name(self.key) + ' ' + mod.errors.generate_message(self.key.to_sym, :too_long, { count: result[:max] })
+          end
+        end
+        res = model.validators_on(self.key.to_sym).detect { |v| v.is_a?(ActiveModel::Validations::PresenceValidator) }
+        if res
+          result[:required] = true
+          errors[:required] = model.human_attribute_name(self.key) + ' ' + mod.errors.generate_message(self.key.to_sym, :blank)
+        end
+        result[:errors] = errors if errors.length > 0
+        result
+      end
+
+      ##
+      # Return field properties for frontend application for actions 'edit', 'new' and type 'text'.
+      # @param model [ActiveRecord] field's model
+      # @param action [Srting] current field action
+      # @param mod [ActiveRecord] initialized new model element
+      # @return [Hash] field's properties for defined action
+      def properties_forms_text (model, action, mod)
+        self.properties_forms_string model, action, mod
+      end
+
+      ##
+      # Return field properties for frontend application for actions 'edit', 'new' and type 'html'.
+      # @param model [ActiveRecord] field's model
+      # @param action [Srting] current field action
+      # @param mod [ActiveRecord] initialized new model element
+      # @return [Hash] field's properties for defined action
+      def properties_forms_html (model, action, mod)
+        self.properties_forms_text model, action, mod
+      end
+
+      ##
+      # Return field properties for frontend application for actions 'edit', 'new' and type 'listbox'
+      # @param model [ActiveRecord] field's model
+      # @param action [Srting] current field action
+      # @param mod [ActiveRecord] initialized new model element
+      # @return [Hash] field's properties for defined action
+      def properties_forms_listbox (model, action, mod)
+        result = {}
+        result[:format] = self.format if self.format == 'multiple'
+        result[:options] = self.hash_to_json(self.options.list) if self.options
+        result
+      end
+
+      ##
+      # Return field properties for frontend application for actions 'edit', 'new' and type 'key'
+      # @param model [ActiveRecord] field's model
+      # @param action [Srting] current field action
+      # @param mod [ActiveRecord] initialized new model element
+      # @return [Hash] field's properties for defined action
+      def properties_forms_key (model, action, mod)
+        result = {
+            type: 'string',
+            autocomplete: true,
+            editable: self.editable
+        }
+        errors = {}
+        result[:field] = self.model.title if self.editable
+        res = model.validators_on(self.key.to_sym).detect { |v| v.is_a?(ActiveModel::Validations::PresenceValidator) }
+        if res
+          result[:required] = true
+          errors[:required] = model.human_attribute_name(self.key) + ' ' + mod.errors.generate_message(self.key.to_sym, :blank)
+        end
+        result[:errors] = errors if errors.length > 0
+        result
+      end
+
+      ##
+      # Return field properties for frontend application for actions 'edit', 'new' and type 'datetime'
+      # @param model [ActiveRecord] field's model
+      # @param action [Srting] current field action
+      # @param mod [ActiveRecord] initialized new model element
+      # @return [Hash] field's properties for defined action
+      def properties_forms_datetime (model, action, mod)
+        result = {}
+        errors = {}
+        res = model.validators_on(self.key.to_sym).detect { |v| v.is_a?(ActiveModel::Validations::PresenceValidator) }
+        if res
+          result[:required] = true
+          errors[:required] = model.human_attribute_name(self.key) + ' ' + mod.errors.generate_message(self.key.to_sym, :blank)
+        end
+        result[:format] = self.format
+        result[:errors] = errors if errors.length > 0
+        result
+      end
+
+      ##
+      # Generates hash representation of all class parameters,
+      # @return [Hash] hash representation of all data
+      def to_h
+        result = {
+            key: self.key,
+            type: self.type,
+            visible: self.visible,
+            field: self.field,
+            table_field: self.table_field,
+            error_text: self.error_text,
+            autocomplete: self.autocomplete
+        }
+        result[:format] = self.format if self.type == 'datetime'
+        if self.editable
+          result[:editable] = self.editable
+          result[:field] = self.model.title if self.model
+        else
+          result[:editable] = self.editable if self.editable != nil
+        end
+        if self.model
+          result[:model] = self.model.to_h
+        end
+        if self.options
+          result[:options] = self.options.to_h
+        end
+        if self.order
+          result[:order] = self.order.to_h
+        end
+        result
+      end
+
+      ##
+      # Convert hash to array json output
+      # @param hash [Hash] hash representation
+      # @return [Array] array representation
+      def hash_to_json(hash)
+        result = []
+        hash.each_key do |key|
+          result.push({ key: key.to_s, value: hash[key] })
+        end
+        result
+      end
+
+      public :format
+    end
+  end
+end

data/app/controllers/anoubis/etc/field_options.rb

@@ -0,0 +1,83 @@
+module Anubis
+  module Etc
+    ##
+    # Definitions of fields options list for 'checkbox' and 'listbox' type.
+    class FieldOptions
+      # @!attribute [rw]
+      # Describes when options shown in output for 'edit' and 'new' actions. Possible values of fields are:
+      # - 'init' -- Options shown only when time set to 0 in action
+      # - 'never' -- Options newer shown
+      # - 'always' -- Options always shown
+      # - 'update' -- Options shown when time less then updated_at time of options model
+      # @return [String] options' show type.
+      class_attribute :show, default: 'init'
+
+      # @!attribute [rw]
+      # Options list.
+      # @return [Hash<Symbol, Sring>] options list
+      class_attribute :list, default: nil
+
+      # @!attribute [rw]
+      # Enum list from ActiveRecord. Is defined for correct filtering.
+      # @return [Hash<Symbol, Sring>] enum options list
+      class_attribute :enum, default: nil
+
+      # @!attribute [rw]
+      # Defines selected line. Default nil
+      # @return [Hash] presence of select line
+      class_attribute :line, default: nil
+
+      # @!attribute [rw]
+      # Defines model's description for complex field
+      #
+      # <b>Options:</b>
+      # - <b>:model</b> (ActiveRecord) -- model class
+      # - <b>:title</b> (Symbol) -- field name is used for receive options titles <i>(defaults to: :title)</i>
+      # - <b>:order</b> (Symbol) -- field name is used for order options <i>(defaults to: :title option)</i>
+      # - <b>:select</b> (Symbol) -- special select statement <i>(defaults to: nil)</i>
+      # - <b>:where</b> (Hash) -- where parameters for select data from model <i>(defaults to: {})</i>
+      # @return [Model] model's description for complex field
+      class_attribute :model, default: nil
+
+      ##
+      # Sets default parameters for field options
+      # @param [Hash] options initial model options
+      # @option options [String] :show describes options shoe type
+      # @option options [Hash<Symbol, String>] :list options list
+      def initialize(options = {})
+        if options.key? :show
+          self.show = options[:show] if %w[init never always update].include? options[:show]
+        end
+        self.show = 'init' if !self.show || self.show == 'init'
+        self.line = if options.key? :line then options[:line] else nil end
+        self.list = if options.key? :list then options[:list] else nil end
+        self.enum = if options.key? :enum then options[:enum] else nil end
+        self.model = if options.key? :model then Model.new(options[:model]) else nil end
+        self.generate_list if !self.list && self.model
+      end
+
+      ##
+      # Generate options list based on model
+      def generate_list
+        self.list = {}
+        self.model.model.where(self.model.where).order(self.model.order).each do |data|
+          proc = format('%s', self.model.title)
+          self.list[data.id.to_s.to_sym] = data.send proc
+        end
+      end
+
+      ##
+      # Generates hash representation of all class parameters,
+      # @return [Hash] hash representation of all data
+      def to_h
+        {
+            show: self.show,
+            enum: self.enum,
+            list: self.list
+        }
+      end
+
+      public :select
+    end
+  end
+end

data/app/controllers/anoubis/etc/field_order.rb

@@ -0,0 +1,51 @@
+module Anubis
+  module Etc
+    ##
+    # Definitions of fields order.
+    class FieldOrder
+      # @!attribute [rw]
+      # Returns order field (or array of fields)
+      # @return [String, Array, Symbol] field or field list.
+      class_attribute :field, default: nil
+
+      # @!attribute [rw]
+      # Field default order.
+      # @return [Symbol] default order
+      class_attribute :order, default: :asc
+
+      # @!attribute [rw]
+      # Defines if this field order by default.
+      # @return [Boolean] Defines if this field order by default
+      class_attribute :default, default: false
+
+      ##
+      # Sets default parameters for field order
+      # @param [Hash] options initial model options
+      # @option options [String, Array, Symbol] :field describes field or fields name for order
+      # @option options [Symbol] :order default order type (:asc or :desc)
+      # @option options [Boolean] :default if this field default in order list
+      def initialize(options = {})
+        self.default = false
+        if options.key? :default
+          self.default = true if options[:default].class == TrueClass
+        end
+        self.order = :asc
+        if options.key? :order
+          self.order = :desc if options[:order] == :desc || options[:order].to_s.downcase == 'desc'
+        end
+        self.field = if options.key? :field then options[:field] else nil end
+      end
+
+      ##
+      # Generates hash representation of all class parameters,
+      # @return [Hash] hash representation of all data
+      def to_h
+        {
+            field: self.field,
+            order: self.order,
+            default: self.default
+        }
+      end
+    end
+  end
+end