anoubis 1.0.0

data/app/controllers/anoubis/core/data/callbacks.rb

@@ -0,0 +1,68 @@
+module Anubis
+  module Core
+    module Data
+      ##
+      # Module presents all callbacks called in actions.
+      module Callbacks
+        ##
+        # Fires after data was received from server and placed in {Anubis::Output::Data#data self.output.data} array.
+        # It's rewrote for change data before output.
+        def after_get_table_data
+
+        end
+
+        ##
+        # Fires before data will be verified and converted.
+        # @param data [Hash] Data for update
+        # @return [Hash] Processed data. If returned nil then update is terminated.
+        def before_update_data(data)
+          data
+        end
+
+        ##
+        # Fires after data was was updated on the server and placed in {Anubis::Output::Data#data self.output.data} array.
+        # It's rewrote for change data before output.
+        def after_update_data
+
+        end
+
+        ##
+        # Fires after data was was created in {Anubis::Output::Data#data self.output.data} array and before it saved to server.
+        # It's rewrote for change data before output.
+        # @param data [Hash] Data for create
+        # @return [Hash] Processed data. If returned nil then update is terminated.
+        def before_create_data(data)
+          data
+        end
+
+        ##
+        # Fires after data was was created on the server and placed in {Anubis::Output::Data#data self.output.data} array.
+        # It's rewrote for change data before output.
+        def after_create_data
+
+        end
+
+        ##
+        # Fires right before output data to screen
+        def before_output
+
+        end
+
+        ##
+        # Fires when data output to json value
+        def around_output(data)
+          data
+        end
+
+        ##
+        # Fires when data is destroyed
+        def destroy_data
+          if !self.etc.data.data.destroy
+            self.output.errors.concat self.etc.data.data.errors.full_messages
+            self.output.result = -4
+          end
+        end
+      end
+    end
+  end
+end

data/app/controllers/anoubis/core/data/convert.rb

@@ -0,0 +1,407 @@
+module Anubis
+  module Core
+    module Data
+      ##
+      # Data conversion moule between database and human representation
+      module Convert
+        ##
+        # Format a number with grouped thousands
+        # @param number [Float] The number being formatted.
+        # @param precision [Integer] Sets the number of decimal points.
+        # @param point [Char] Sets the separator for the decimal point.
+        # @param separator [Char] Sets the thousands separator.
+        # @return [String] A formatted version of number.
+        def number_format(number, precision = 2, point = ',', separator = '')
+          val = sprintf('%.'+precision.to_s+'f', number.round(precision)).to_s
+          if separator != '' && number >= 1000
+            whole_part, decimal_part = val.split('.')
+            val = [whole_part.gsub(/(\d)(?=\d{3}+$)/, '\1'+separator), decimal_part].compact.join(point)
+          else
+            val = val.gsub('.', point)
+          end
+          val
+        end
+
+
+        ##
+        # @!group Block of conversion database value into human view format
+
+        ##
+        # Convert value from database to view format according by defining field type and {Anubis::Etc::Base#action action}
+        # @param key [Symbol] field's identifier in {Anubis::Etc::Data#fields self.etc.data.fields} structure
+        # @param value [String] value from database
+        def convert_db_to_view_value(key, value)
+          field = self.etc.data.fields[key]
+          return { key => value } if !field.type
+          proc = format('convert_db_to_view_value_%s', field.type)
+          result = self.send proc, key, value
+          result
+        end
+
+        ##
+        # Convert value from database to view format for 'string' type
+        # @param key [Symbol] field's identifier in {Anubis::Etc::Data#fields self.etc.data.fields} structure
+        # @param value [String] value from database
+        def convert_db_to_view_value_string(key, value)
+          return { key => '' } if !value
+          return { key => value }
+        end
+
+        ##
+        # Convert value from database to view format for 'boolean' type
+        # @param key [Symbol] field's identifier in {Anubis::Etc::Data#fields self.etc.data.fields} structure
+        # @param value [Boolean] value from database
+        def convert_db_to_view_value_boolean(key, value)
+          return { key => '' } if !value
+          return { key => value }
+        end
+
+        ##
+        # Convert value from database to view format for 'integer' type
+        # @param key [Symbol] field's identifier in {Anubis::Etc::Data#fields self.etc.data.fields} structure
+        # @param value [String] value from database
+        def convert_db_to_view_value_number(key, value)
+          return { key => self.etc.data.fields[key].error_text } if !value
+          return { key => value.to_s.to_i } if self.etc.data.fields[key].precision == 0
+          return { key => format('%.' + self.etc.data.fields[key].precision.to_s + 'f', value) }
+        end
+
+        ##
+        # Convert value from database to view format for 'text' type
+        # @param key [Symbol] field's identifier in {Anubis::Etc::Data#fields self.etc.data.fields} structure
+        # @param value [String] value from database
+        def convert_db_to_view_value_text(key, value)
+          return { key => '' } if !value
+          return { key => value }
+        end
+
+        ##
+        # Convert value from database to view format for 'html' type
+        # @param key [Symbol] field's identifier in {Anubis::Etc::Data#fields self.etc.data.fields} structure
+        # @param value [String] value from database
+        def convert_db_to_view_value_html(key, value)
+          return { key => '' } if !value
+          return { key => value }
+        end
+
+        ##
+        # Convert value from database to table format for 'listbox' type
+        # @param key [Symbol] field's identifier in {Anubis::Etc::Data#fields self.etc.data.fields} structure
+        # @param value [String] value from database
+        def convert_db_to_view_value_listbox(key, value)
+          field = self.etc.data.fields[key]
+          new_value = ''
+          if field.options
+            if field.format == 'single'
+              new_value = field.options.list[value.to_s.to_sym] if field.options.list
+            else
+              new_value = []
+              if value
+                if field.options.list
+                  value.each do |key|
+                    new_value.push field.options.list[key.to_s.to_sym]
+                  end
+                end
+              end
+            end
+          end
+          case self.etc.action
+          when 'index', 'show', 'export'
+            if field.format == 'single'
+              return { key => new_value, format('%s_raw', key).to_sym => value }
+            else
+              return { key => new_value.join(', '), format('%s_raw', key).to_sym => new_value }
+            end
+          when 'new', 'edit'
+            if field.format == 'single'
+              return { key => value.to_s, format('%s_view', key).to_sym => new_value }
+            else
+              return { key => value, format('%s_view', key).to_sym => new_value.join(', ') }
+            end
+          else
+            if field.format == 'single'
+              return { key => value.to_s, format('%s_view', key).to_sym => new_value }
+            else
+              return { key => value, format('%s_view', key).to_sym => new_value.join(', ') }
+            end
+          end
+        end
+
+        ##
+        # Convert value from database to view format for 'key' type
+        # @param key [Symbol] field's identifier in {Anubis::Etc::Data#fields self.etc.data.fields} structure
+        # @param value [String] value from database
+        def convert_db_to_view_value_key(key, value)
+          return { key => '' } if !value
+          return { key => value }
+        end
+
+        ##
+        # Convert value from database to table view for datetime type
+        def convert_db_to_view_value_datetime(key, value)
+          field = self.etc.data.fields[key]
+          #puts key
+          #puts value.class
+          if (value.class == Date) || (value.class == ActiveSupport::TimeWithZone)
+            begin
+              new_value = case field.format
+                          when 'month' then I18n.t('anubis.months.main')[value.month-1]+' '+value.year.to_s
+                          when 'date' then value.day.to_s+' '+ I18n.t('anubis.months.second')[value.month-1]+' '+value.year.to_s
+                          when 'datetime' then value.day.to_s+' '+ I18n.t('anubis.months.second')[value.month-1]+' '+value.year.to_s+', '+value.hour.to_s+':'+('%02d' % value.min)
+                          else value.day.to_s+' '+ I18n.t('anubis.months.second')[value.month-1]+' '+value.year.to_s+', '+value.hour.to_s+':'+('%02d' % value.min)+':'+('%02d' % value.sec)
+                          end
+              if %w[month date].include? field.format
+                raw_value = value.year.to_s + '-' + ('%02d' % value.month) + '-' + ('%02d' % value.day)
+              else
+                #raw_value = value.year.to_s + '-' + ('%02d' % value.month) + '-' + ('%02d' % value.day) + ' ' + ('%02d' % value.hour) + ':' + ('%02d' % value.min)
+                raw_value = value.iso8601(2)[0..18]
+              end
+            rescue StandardError => e
+              #puts e
+              new_value = field.error_text
+            end
+          else
+            new_value = '';
+          end
+
+          case self.etc.action
+          when 'new', 'edit'
+            return { key => raw_value, format('%s_view', key).to_sym => new_value }
+          end
+          return { key => new_value, format('%s_raw', key).to_sym => value }
+        end
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+        ##
+        # Convert value from database to table view for text type
+        def convert_db_to_table_value_text1(key, field, value)
+          return { key => '', ('raw_'+key.to_s).to_sym => '' } if !value
+          new_value = ERB::Util.html_escape(value).to_s.gsub(/(?:\n\r?|\r\n?)/, '<br/>')
+          return { key => new_value, ('raw_'+key.to_s).to_sym => value }
+        end
+
+
+
+
+
+        ##
+        # Convert value from database to table view for string type
+        def convert_db_to_table_value_integer1(key, field, value)
+          return { key => '' } if !value
+          return { key => value }
+        end
+
+
+
+
+        ##
+        # Convert value from database to table view for longlistbox type
+        def convert_db_to_table_value_longlistbox1(key, field, value)
+          return { key => '' } if !value
+          return { key => value }
+        end
+
+        ##
+        # Convert value from database to table view for datetime type
+        def convert_db_to_table_value_datetime1(key, field, value)
+          begin
+            value = case field[:format]
+                    when 'month' then I18n.t('months.main')[value.month-1]+' '+value.year.to_s
+                    when 'date' then value.day.to_s+' '+ I18n.t('months.second')[value.month-1]+' '+value.year.to_s
+                    when 'datetime' then value.day.to_s+' '+ I18n.t('months.second')[value.month-1]+' '+value.year.to_s+', '+value.hour.to_s+':'+('%02d' % value.min)
+                    else value.day.to_s+' '+ I18n.t('months.second')[value.month-1]+' '+value.year.to_s+', '+value.hour.to_s+':'+('%02d' % value.min)+':'+('%02d' % value.sec)
+                    end
+          rescue
+            value = I18n.t('incorrect_field_format')
+          end
+          return { key => value }
+        end
+
+        ##
+        # Convert value from database to table view for float type
+        # @param key [Symbol] key of table field
+        # @param field [Tims::Etc::Table#fields] set of options of field by <b>key</b>
+        # @param value [Float] value from database before processing
+        # @return [Hash] return resulting value at format <b>{ key: processed_value, 'raw_'+key: value }</b>
+        def convert_db_to_table_value_float1(key, field, value)
+          return { key => number_format(value, field[:precision], field[:point], field[:separator]), ('raw_'+key.to_s).to_sym => value}
+        end
+
+        ##
+        # Convert value from database to edit form for datetime type
+        # @param key [Symbol] field's identifier
+        # @param field [Hash] field's options
+        # @param value [Any] value from database before processing
+        # @return [Hash] resulting value in format <b>{ key: processed_value }</b>
+        def convert_db_to_table_value_datetime(key, field, value)
+          begin
+            value = case field[:format]
+                    when 'month' then I18n.t('months.main')[value.month-1]+' '+value.year.to_s
+                    when 'date' then value.day.to_s+' '+ I18n.t('months.second')[value.month-1]+' '+value.year.to_s
+                    when 'datetime' then value.day.to_s+' '+ I18n.t('months.second')[value.month-1]+' '+value.year.to_s+', '+value.hour.to_s+':'+('%02d' % value.min)
+                    else value.day.to_s+' '+ I18n.t('months.second')[value.month-1]+' '+value.year.to_s+', '+value.hour.to_s+':'+('%02d' % value.min)+':'+('%02d' % value.sec)
+                    end
+          rescue
+            value = I18n.t('incorrect_field_format')
+          end
+          return { key => value }
+        end
+
+        ##
+        # Convert value from database to edit form for float type
+        # @param key [Symbol] field's identifier
+        # @param field [Anubis::Etc::Data#fields] field's options
+        # @param value [Float] value from database before processing
+        # @return [Hash] return resulting value at format <b>{ key+'_view': processed_value, key: value }</b>
+        def convert_db_to_table_value_float(key, field, value)
+          return { (key.to_s+'_view').to_sym => number_format(value, field[:precision], field[:point], field[:separator]), key => value}
+        end
+        # @!endgroup
+
+
+        ##
+        # @!group Block of conversion human view values to database format
+
+        ##
+        # Converts inputted value to database format.
+        # Field type is got from {Anubis::Etc::Data#fields self.etc.data.fields} according by key.
+        # Resulting data is placed into {Anubis::Etc::Data#data self.etc.data.data} attribute according by key.
+        # Errors are placed in {Anubis::Output::Update#errors self.output.errors} array according by key.
+        # @param key [Symbol] field's identifier in {Anubis::Etc::Data#fields self.etc.data.fields} structure
+        # @param value [String] value from user input
+        def convert_view_to_db_value(key, value)
+          field = self.etc.data.fields[key]
+          return { key => value } unless field
+          return { key => value } unless field.type
+          proc = format('convert_view_to_db_value_%s', field.type)
+          self.send proc, key, value
+        end
+
+        ##
+        # Converts inputted value to database format for {Anubis::Etc::Field#type 'string' field type}.
+        # @param key [Symbol] field's identifier in {Anubis::Etc::Data#fields self.etc.data.fields} structure
+        # @param value [String] inputted value
+        def convert_view_to_db_value_string(key, value)
+          proc = format('self.etc.data.data.%s = value', key)
+          #self.etc.data.data[key] = value
+          eval proc
+        end
+
+        ##
+        # Converts inputted value to database format for {Anubis::Etc::Field#type 'boolean' field type}.
+        # @param key [Symbol] field's identifier in {Anubis::Etc::Data#fields self.etc.data.fields} structure
+        # @param value [Boolean] inputted value
+        def convert_view_to_db_value_boolean(key, value)
+          proc = format('self.etc.data.data.%s = value', key)
+          #self.etc.data.data[key] = value
+          eval proc
+        end
+
+        ##
+        # Converts inputted value to database format for {Anubis::Etc::Field#type 'number' field type}.
+        # @param key [Symbol] field's identifier in {Anubis::Etc::Data#fields self.etc.data.fields} structure
+        # @param value [String] inputted value
+        def convert_view_to_db_value_number(key, value)
+          field = self.etc.data.fields[key]
+          if field.precision == 0
+            value = value.to_s.to_i
+          else
+            value = value.to_s.to_f
+          end
+          proc = format('self.etc.data.data.%s = value', key)
+          #self.etc.data.data[key] = value
+          eval proc
+        end
+
+        ##
+        # Converts inputted value to database format for {Anubis::Etc::Field#type 'text' field type}.
+        # @param key [Symbol] field's identifier in {Anubis::Etc::Data#fields self.etc.data.fields} structure
+        # @param value [String] inputted value
+        def convert_view_to_db_value_text(key, value)
+          proc = format('self.etc.data.data.%s = value', key)
+          #self.etc.data.data[key] = value
+          eval proc
+        end
+
+        ##
+        # Converts inputted value to database format for {Anubis::Etc::Field#type 'html' field type}.
+        # @param key [Symbol] field's identifier in {Anubis::Etc::Data#fields self.etc.data.fields} structure
+        # @param value [String] inputted value
+        def convert_view_to_db_value_html(key, value)
+          proc = format('self.etc.data.data.%s = value', key)
+          #self.etc.data.data[key] = value
+          eval proc
+        end
+
+        ##
+        # Converts inputted value to database format for {Anubis::Etc::Field#type 'listbox' field type}
+        # for {Anubis::Data::Actions#create 'create'} action
+        # @param key [Symbol] field's identifier in {Anubis::Etc::Data#fields self.etc.data.fields} structure
+        # @param value [String] inputted value
+        def convert_view_to_db_value_listbox(key, value)
+          field = self.etc.data.fields[key]
+          begin
+            proc = format('self.etc.data.data.%s = value', field.field)
+            #self.etc.data.data[field.field] = value
+            eval proc
+          rescue
+            self.etc.data.data[field.field] = nil
+          end
+        end
+
+        ##
+        # Converts inputted value to database format for {Anubis::Etc::Field#type 'key' field type}
+        # for {Anubis::Data::Actions#create 'create'} action
+        # @param key [Symbol] field's identifier in {Anubis::Etc::Data#fields self.etc.data.fields} structure
+        # @param value [String] inputted value
+        def convert_view_to_db_value_key(key, value)
+          field = self.etc.data.fields[key]
+          where = {}
+          where[field.model.title.to_s.to_sym] = value
+          value = field.model.model.where(where).first
+          proc = format('self.etc.data.data.%s = value', field.key)
+          eval(proc)
+          #begin
+          #          self.etc.data.data[key] = value
+          #        rescue
+          #          self.etc.data.data[key] = nil
+          #        end
+        end
+
+        ##
+        # Converts inputted value to database format for {Anubis::Etc::Field#type 'datetime' field type}.
+        # @param key [Symbol] field's identifier in {Anubis::Etc::Data#fields self.etc.data.fields} structure
+        # @param value [String] inputted value
+        def convert_view_to_db_value_datetime(key, value)
+          zone = ActiveSupport::TimeZone[self.current_user.timezone]
+          offset = if zone.utc_offset/3600 < 0 then (zone.utc_offset/3600).to_s else '+'+(zone.utc_offset/3600).to_s end
+          #puts 'convert_view_to_db_value_datetime'
+          #puts value
+          value = Time.zone.parse value
+          #puts value
+          #puts zone
+          #puts offset
+          #puts value.utc_offset if value
+          proc = format('self.etc.data.data.%s = value', key)
+          #self.etc.data.data[key] = value
+          eval proc
+        end
+        # @!endgroup
+      end
+    end
+  end
+end

data/app/controllers/anoubis/core/data/defaults.rb

@@ -0,0 +1,217 @@
+module Anubis
+  module Core
+    module Data
+      ##
+      # Module sets default parameters for {DataController}.
+      module Defaults
+        ##
+        # Sets hash of defined tabs. Every tab consists of next attributes:
+        #
+        # *Attributes:*
+        # - *:title* (String) --- title of the tab
+        # - *:where* (Hash | Array) --- hash or array of where parameters for ActiveRecord request. If doesn't present
+        #   then there are no additional where statements for current tab
+        #
+        # @return [Hash] returns hash of assigned tabs.
+        #
+        # @example Sets custom tabs
+        #   def tabs
+        #     {
+        #         :all => {
+        #             title: 'All IDs'
+        #         },
+        #         :id_1 => {
+        #             title: 'Only ID 1',
+        #             where: { id: 1 }
+        #         },
+        #         :other_id => {
+        #             title: 'Other IDs',
+        #             where: ['id > ?', 1]
+        #         }
+        #     }
+        #   end
+        def tabs
+          {
+            :default => {
+              title: I18n.t('anubis.default_tab'),
+              tips: I18n.t('anubis.default_tab_hint')
+            }
+          }
+        end
+
+        ##
+        # Sets frame buttons for every using tab.
+        # Key of the button is an action for frontend application. Every button consists of next attributes:
+        #
+        # *Attributes:*
+        # - *:type* (String) <i>(defaults to: 'default')</i> --- type of the button ('primary', 'danger', 'default')
+        # - *:mode* (String) <i>(defaults to: 'single')</i> --- button action object ('single', 'multiple')
+        #
+        # By default system defines two buttons: 'New' (for create new element in table) and 'Delete' (for
+        # delete multiple element)
+        #
+        # @param [Hash] args additional parameters are used for define frame buttons.
+        # @option args [String] :tab current tab is used for generation
+        #
+        # @return [Hash] returns hash of assigned buttons.
+        #
+        # @example Sets no buttons
+        #   def frame_buttons(args = {})
+        #     {
+        #     }
+        #   end
+        #
+        # @example Sets only 'New' button
+        #   def frame_buttons(args = {})
+        #     {
+        #         new: { type: 'primary' }
+        #     }
+        #   end
+        def frame_buttons(args = {})
+          {
+            new: { type: 'primary' },
+            delete: { mode: 'multiple', type: 'danger' }
+          }
+        end
+
+        ##
+        # Returns model that is used for controller actions. By default it's not defined.
+        # This is primary model and it must be defined in customer conroller. Different models may be defined according
+        # by {Anubis::Etc::Base#action self.etc.action} attribute.
+        # @return [Anubis::ApplicationRecord, nil, any] returns model
+        def model
+          nil
+        end
+
+        ##
+        # Returns defined select fields. If returns nil, then return default select fields
+        def select
+          nil
+        end
+
+        ##
+        # Returns eager load parameters that are used for controller actions. By default it's set to \[\].
+        # This procedure could be redefined in cusomer controller. Different eager loads may be defined according
+        # by {Anubis::Etc::Base#action self.etc.action} attribute.
+        def eager_load
+          []
+        end
+
+        ##
+        # Returns fields that is used for controller actions in defined {#model}. By default it's defined for id field.
+        # This is primary definition and it must be defined in customer conroller. Different fields may be defined according
+        # by {Anubis::Etc::Base#action self.etc.action} attribute.
+        # @return [Hash] returns defined fields for current model
+        def fields
+          {
+            id: { type: 'number', precision: 0 }
+          }
+        end
+
+        ##
+        # Get array of field's identifiers in desired order. By default it's current defined order of all fields.
+        def fields_order
+          result = []
+          self.etc.data.fields.each_key do |key|
+            result.push key.to_s
+          end
+          result
+        end
+
+        ##
+        # Get array of field's identifiers in desired order for filter form. By default it's current defined order of all fields.
+        def filter_order
+          self.fields_order
+        end
+
+        ##
+        # Returns parent model that is used for controller actions. By default it's defined as <i>nil</i>.
+        # This procedure could be redefined in customer controller. Different models may be defined according
+        # by {Anubis::Etc::Base#action self.etc.action} attribute.
+        # @return [Anubis::ApplicationRecord, nil] returns model
+        def parent_model
+          nil
+        end
+
+        ##
+        # Returns eager load parameters for parent model  that are used for controller actions. By default it's set to \[\].
+        # This procedure could be redefined in customer controller. Different eager loads may be defined according
+        # by {Anubis::Etc::Base#action self.etc.action} attribute.
+        def parent_eager_load
+          []
+        end
+
+        ##
+        # Returns parent model id. By default it's set to 0.
+        # This procedure could be rewrote in customer controller.
+        def parent_id
+          return 0
+        end
+
+        ##
+        # @!group Block of default controller table actions
+
+        ##
+        # Sets default table actions for every row
+        # @return [Array] return string array of action identifiers
+        def table_actions
+          %w[edit delete]
+        end
+
+        ##
+        # Returns possibility of 'edit' action for current row
+        # @param row [ActiveRecord] single model's data row
+        def table_action_edit(row)
+          row.can_edit({ controller: params[:controller], tab: self.etc.tab })
+        end
+
+        ##
+        # Returns possibility of 'delete' action for current row
+        # @param row [ActiveRecord] single model's data row
+        def table_action_delete(row)
+          row.can_delete({ controller: params[:controller], tab: self.etc.tab })
+        end
+
+        ##
+        # Returns default where condition
+        # @return [Hash, Array] default where condition
+        def where
+          []
+        end
+
+        #@!endgroup
+
+        ##
+        # Returns export format for current action. Procedure is rewrote for change default export format.
+        def export_format
+          'xls'
+        end
+
+        ##
+        # Returns filter possibility for defined options. It's rewrote for custom controllers.
+        # @param [Hash] args additional parameters.
+        # @option args [String] :tab current tab is used for generation
+        # @return [Boolean] Possibility of filter table data. Default: true
+        def is_filter(args = {})
+          true
+        end
+
+        ##
+        # Returns export possibility for defined options. It's rewrote for custom controllers.
+        # @param [Hash] args additional parameters.
+        # @option args [String] :tab current tab is used for generation
+        # @return [Boolean] Possibility of export table data. Default: true
+        def is_export(args = {})
+          true
+        end
+
+        ##
+        # Returns field name for manual table order or nil if table can't be sorted manually.
+        # @return [String] Field name for manual table order
+        def is_sortable
+          nil
+        end
+      end
+    end
+  end
+end