anoubis 1.0.7 → 1.0.8

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

@@ -1,531 +0,0 @@
- module Anoubis
-   module Core
-     module Data
-      ##
-      # Module gets system data for {DataController}
-      module Get
-        ##
-        # Get frame buttons data based on passed arguments.
-        # @param [Hash] args additional parameters are used for define frame buttons.
-        # @option args [String] :tab tab is used for generation buttons
-        # @return [Hash] returns resulting button hash
-        def get_frame_buttons(args = {})
-          buttons = self.frame_buttons(args)
-          buttons.each do |key, button|
-            buttons[key] = self.get_frame_button key, button
-          end
-          buttons
-        end
-
-        ##
-        # Get frame button
-        # @param [String] key button identificator
-        # @param [Hash] button initial button options
-        # @option button [String] :type ('default') type of the button ('primary', 'danger', 'default')
-        # @option button [String] :mode ('single') button action object ('single', 'multiple')
-        # @option button [String] :title title of the frame. If title isn't defined then system is trying to take
-        #   value from yml translation file at path <i>[<b><language>.<controller with dot>.frame.buttons.<key>.title</b>]</i> (eg.
-        #   *en.anubis.tenants.frame.buttons.new.title* for english language 'anubis/tenants' controller 'new' button).
-        #   If path absents then value isn't set.
-        # @option button [String] :hint hint of the frame. If hint isn't defined then system is trying to take
-        #   value from yml translation file at path <i>[<b><language>.<controller with dot>.frame.buttons.<key>.hint</b>]</i> (eg.
-        #   *en.anubis.tenants.frame.buttons.new.hint* for english language 'anubis/tenants' controller 'new' button).
-        #   If path absents then value isn't set.
-        # @return [Hash] resulting button options
-        def get_frame_button(key, button)
-          button[:key] = key.to_s
-          button[:type] = 'default' unless button.has_key? :type
-          button[:mode] = 'single' unless button.has_key? :mode
-          button[:decoration] = 'none' unless button.has_key? :decoration
-          text = I18n.t('.buttons.'+button[:key]+'.title', default: '')
-          button[:title] = text if text != ''
-          text = I18n.t('.buttons.'+button[:key]+'.hint', default: '')
-          button[:hint] = text if text != ''
-          button
-        end
-
-        ##
-        # Get tab parameters
-        # @param [String] tab identifier
-        # @param [Hash] options initial tab options
-        # @option options [String] :title title of the frame. If title isn't defined then value is taken from yml
-        #   translation file at path <i>[<b><language>.<controller with dot>.frame.tabs.<tab>.title</b>]</i> (eg.
-        #   *en.anubis.tenants.frame.tabs.all.title* for english language 'anubis/tenants' controller 'all' tab).
-        #   If path absents then value is set into humanized form of tab identifier (eg. 'All' for 'all' tab).
-        # @option options [String] :hint hint of the frame. If hint isn't defined then system is trying to take
-        #   value from yml translation file at path <i>[<b><language>.<controller with dot>.frame.tabs.<tab>.hint</b>]</i> (eg.
-        #   *en.anubis.tenants.frame.tabs.all.hint* for english language 'anubis/tenants' controller 'all' tab).
-        #   If path absents then value isn't set.
-        def get_tab(tab, options = {})
-          options[:tab] = tab.to_s
-          options[:title] = I18n.t('.tabs.'+options[:tab]+'.title', default: options[:tab].humanize) if !options.key? :title
-          if !options.has_key? :hint
-            hint = I18n.t('.tabs.'+options[:tab]+'.hint', default: '')
-            options[:hint] = hint if hint != ''
-          end
-
-          if options.key? :export
-            options[:export] = true if options[:export].class != FalseClass
-          else
-            options[:export] = self.is_export({ tab: tab.to_s })
-          end
-
-          if options.key? :filter
-            options[:filter] = true if options[:filter].class != FalseClass
-          else
-            options[:filter] = self.is_filter({ tab: tab.to_s })
-          end
-          options[:buttons] = self.get_frame_buttons({ tab: options[:tab] })
-          #options[:where] = self.where if !options.key? :where
-          options
-        end
-
-        ##
-        # Get model that is used for controller action
-        def get_model
-          return self.etc.data.model if self.etc.data.model
-          if defined? self.model
-            self.etc.data.model = self.model
-            self.etc.data.eager_load = self.eager_load
-          end
-          return self.etc.data.model
-        end
-
-        ##
-        # Get default eager load definition for controller action
-        def get_eager_load
-          return self.etc.data.eager_load if self.etc.data.model
-          self.get_model
-          return self.etc.data.eager_load
-        end
-
-        ##
-        # Get where for controller action fro defined tab
-        def get_tab_where
-          return self.etc.tab.where if self.etc.tab.where
-          []
-        end
-
-        ##
-        # Get where for controller action
-        def get_where
-          self.where
-        end
-
-        def get_tenant_where(model)
-          return { tenant_id: self.current_user.tenant_id } if model.new.respond_to? :tenant_id
-          return {}
-        end
-
-        def get_filter_where
-          #puts 'get_filter_where!'
-          #puts self.etc.data.filter.to_h
-          return if self.etc.data.filter
-          filter = {}
-          if params.key? :filter
-            begin
-              filter = JSON.parse(params[:filter]).with_indifferent_access.to_h
-            rescue
-              filter = {}
-            end
-          end
-          self.setup_fields
-          #puts 'get_filter_where'
-          #puts self.etc.data.fields
-          self.etc.data.filter = Anoubis::Etc::Filter.new({ data: filter, fields: self.etc.data.fields })
-
-          #puts self.etc.data.filter.to_h
-        end
-
-        def get_filter_where_hash
-          self.get_filter_where
-          return self.etc.data.filter.hash
-        end
-
-        def get_filter_where_array
-          self.get_filter_where
-          return self.etc.data.filter.array
-        end
-
-        ##
-        # @!group Block of table data getters
-
-        ##
-        # Get total number of rows in defined model. Also sets additional system properties {Etc::Data#limit self.etc.data.limit},
-        # {Etc::Data#offset self.etc.data.offset} and {Etc::Data#count self.etc.data.count}
-        # @return [Integer] the total number of rows.
-        def get_table_data_count
-          self.load_table_data_count
-          self.etc.data.limit = params[:limit] if params.has_key? :limit
-          self.etc.data.offset = params[:offset] if params.has_key? :offset
-          if self.etc.data.offset >= self.etc.data.count
-            if self.etc.data.count > 0
-              self.etc.data.offset = ((self.etc.data.count-1) / self.etc.data.limit).truncate * self.etc.data.limit
-            else
-              self.etc.data.offset = 0
-            end
-          end
-          self.etc.data.count
-        end
-
-        ##
-        # Returns fields for table output.
-        # @return [Hash] calculated hash for fields properties for current action
-        def get_fields_properties(fields = nil)
-          fields = fields_order if !fields
-          result = []
-          fields.each do |value|
-            if self.etc.data.fields
-              if self.etc.data.fields.key? value.to_sym
-                result.push self.etc.data.fields[value.to_sym].properties(self.etc.data.model, self.etc.action) if self.etc.data.fields[value.to_sym].visible
-              end
-            end
-          end
-          result
-        end
-
-        ##
-        # Returns fields for filter form.
-        # @return [Hash] calculated hash for fields properties for current action
-        def get_filter_properties
-          fields = filter_order
-          self.get_fields_properties fields
-        end
-
-        ##
-        # Load data into the system variable {Etc::Data#data self.etc.data.data} and return fields defined in controller.
-        def get_table_data
-          self.load_table_data self.etc.data.limit, self.etc.data.offset
-          data = []
-          if self.etc.data.data
-            self.etc.data.data.each do |row|
-              data.push get_data_row row
-            end
-          end
-          data
-        end
-
-        ##
-        # Get data fields defined in custom controller for single row
-        # @param row [ActiveRecord] single row of model data
-        # @return [Hash] calculated hash of model row
-        def get_data_row(row)
-          fields = self.get_fields
-
-          new_row = {}
-
-          case self.etc.action
-          when 'show'
-            new_row = { id: row.id, sys_title: row.sys_title }
-          when 'index', 'export'
-            new_row = { id: row.id, sys_title: row.sys_title, actions: self.get_table_actions(row) }
-          when 'new', 'create'
-            new_row = {}
-          when 'edit', 'update'
-            new_row = { id: row.id, sys_title: row.sys_title }
-          end
-
-          fields.each_key do |key|
-            begin
-              value = eval 'row.' + fields[key].field
-              error = false
-            rescue
-              new_row[key] = fields[key].error_text
-              error = true
-              if fields[key].type == 'key'
-                error = false
-              end
-            end
-
-            new_row = new_row.merge(self.convert_db_to_view_value(key, value)) if !error
-          end
-
-          return new_row
-        end
-
-        ##
-        # Returns current table actions for selected row
-        # @param row [ActiveRecord] single row of model data
-        # @return [Hash] resulting has of buttons
-        def get_table_actions(row)
-          self.etc.data.actions = self.table_actions if !self.etc.data.actions
-          result = {}
-          self.etc.data.actions.each do |value|
-            if self.get_table_action value, row
-              result[value.to_sym] = I18n.t(params[:controller].sub('/', '.')+'.table.actions.'+value, title: row.sys_title, default: I18n.t('actions.'+value, title: row.sys_title))
-            end
-          end
-          result
-        end
-
-        ##
-        # Returns posibility of using action for table data
-        # @param action [String] desired action
-        # @param row [ActiveRecord] single active record row
-        # @return [Boolean] is action present or not
-        def get_table_action(action, row)
-          result = false
-          if self.respond_to?(('table_action_'+action).to_sym)
-            result = send 'table_action_'+action, row
-          else
-            result = true
-          end
-          result
-        end
-        # @!endgroup
-
-        ##
-        # @!group Block of {Anoubis::Data::Actions#edit edit} and {Anoubis::Data::Actions#update update} getters
-
-        ##
-        # Get model that is used for {Anoubis::Data::Actions#edit edit} or {Anoubis::Data::Actions#update update} actions.
-        def get_edit_model
-          return self.etc.data.model if self.etc.data.model
-          self.etc.data.model = self.edit_model
-          self.etc.data.eager_load = self.edit_eager_load
-          return self.etc.data.model
-        end
-
-        ##
-        # Get default eager load definition for {Anoubis::Data::Actions#edit edit} or
-        # {Anoubis::Data::Actions#update update} actions.
-        def get_edit_eager_load
-          return self.etc.data.eager_load if self.etc.data.model
-          self.get_edit_model
-          return self.etc.data.eager_load
-        end
-
-        ##
-        # Return current table fields hash for {Anoubis::Data::Actions#edit edit} or
-        # {Anoubis::Data::Actions#update update} actions.
-        # @return [Hash] current defined table fields
-        def get_edit_fields
-          self.setup_edit_fields
-          self.etc.data.fields
-        end
-
-        ##
-        # Get table data for single row for {Anoubis::Data::Actions#edit edit} or {Anoubis::Data::Actions#update update}
-        # actions.
-        # @param row [ActiveRecord] single row of model data
-        # @return [Hash] calculated hash of model row
-        def get_edit_data_row(row)
-          self.setup_edit_fields
-          new_row = { id: row.id, sys_title: row.sys_title }
-          self.etc.data.fields.each do |key, field|
-            if row.respond_to? field.field
-              value = row.send field.field
-              error = false
-            else
-              new_row[key] = field.error_text
-              error = true
-            end
-            new_row = new_row.merge(self.convert_db_to_edit_value(key, value)) if !error
-          end
-          return new_row
-        end
-
-        # @!endgroup
-
-        ##
-        # @!group Block of {Anoubis::Data::Actions#new new} or {Anoubis::Data::Actions#create create} getters
-
-        ##
-        # Return current table fields hash for {Anoubis::Data::Actions#new new} or {Anoubis::Data::Actions#create create}
-        # actions
-        # @return [Hash] current defined table fields
-        def get_new_fields
-          self.setup_new_fields
-          self.etc.data.fields
-        end
-
-        ##
-        # Get table data for single row for {Anoubis::Data::Actions#new new} or {Anoubis::Data::Actions#create create}
-        # actions.
-        # @param row [ActiveRecord] single row of model data
-        # @return [Hash] calculated hash of model row
-        def get_new_data_row1(row)
-          self.setup_new_fields
-          new_row = {}
-          self.etc.data.fields.each do |key, field|
-            if row.respond_to? field.field
-              value = row.send field.field
-              error = false
-            else
-              new_row[key] = field.error_text
-              error = true
-            end
-            new_row = new_row.merge(self.convert_db_to_new_value(key, value)) if !error
-          end
-          return new_row
-        end
-
-        # @!endgroup
-
-        ##
-        # Get defined fields options
-        # @param time [Number] last execution time of action
-        # @return [Hash] hash of fields options
-        def get_data_options(time)
-          time = time.to_s.to_i
-          self.setup_fields
-          result = {}
-          self.etc.data.fields.each do |key, field|
-            if field.options
-              if field.options.list
-                if time == 0
-                  result[key] = field.options.list if field.options.show != 'never'
-                else
-                  if field.model
-                    if field.options.show == 'always'
-                      result[key] = field.options.list
-                    else
-                      if field.options.show == 'update' && field.model.updated_at > time
-                        result[key] = field.options.list
-                      end
-                    end
-                  else
-                    result[key] = field.options.list if field.options.show == 'update' || field.options.show == 'always'
-                  end
-                end
-              end
-            end
-          end
-          result
-        end
-
-        ##
-        # Returns order for current tab
-        # @return [Hash, String] order fore current tab
-        def get_order
-          return {id: :desc} if self.etc.tab.sort == nil
-
-          result = {}
-
-          field = self.etc.data.fields[self.etc.tab.sort.to_sym].order
-          if field.field.class == Symbol
-            result[field.field] = self.etc.tab.order
-          else
-            if field.field.class == String
-              if field.field.index(',')
-                result = field.field.gsub(',', ' ' + self.etc.tab.order.to_s.upcase + ',') + ' ' + self.etc.tab.order.to_s.upcase
-              else
-                result = field.field + ' ' + self.etc.tab.order.to_s.upcase
-              end
-            else
-              if field.field.class == Array
-                field.field.each do |item|
-                  if item.class == Symbol
-                    result[item] = self.etc.tab.order
-                  end
-                end
-              end
-            end
-          end
-          result
-        end
-
-        ##
-        # Return current fields hash for defined action.
-        # @return [Hash] current defined table fields
-        def get_fields
-          self.setup_fields
-          self.etc.data.fields
-        end
-
-        ##
-        # Returns permitted parameters. Parameters is got from standard parameters output and checks according
-        # by described {Anoubis::Etc::Data#fields self.etc.data.fields}.
-        # @return [Hash<Symbol, string>] permitted paramters' collection
-        def get_permited_params
-          permit = []
-          allowed = self.fields_order
-          self.etc.data.fields.each_key do | key |
-            single = true
-            if self.etc.data.fields[key].type == 'listbox'
-              single = false if self.etc.data.fields[key].format == 'multiple'
-            end
-            if single
-              permit.push key
-            else
-              data = {}
-              data[key] = []
-              permit.push data
-            end
-          end
-          params[:data].permit(permit).to_h.symbolize_keys
-        end
-
-        ##
-        # Returns formatted field hash for field type 'string'
-        # @param [Hash] options initial filed options
-        # @option options [String] :min defines minimum string length <i>(default: 0)</i>
-        # @option options [String] :max defines maximum string length <i>(default: 0)</i>
-        # @return [Hash] resulting hash for field type 'string'
-        def get_formatted_string_field(options)
-          field = {}
-          return field
-        end
-
-        ##
-        # Get autocomplete data for field
-        # @param field [Anoubis::Etc::Field] - field for loading data
-        # @param value [String] - search value for load data
-        # @return [Hash] resulting hash for selected data
-        def get_autocomplete_data(field, value)
-          value = value.to_s
-          if value.index(' ')
-            words = value.split(' ')
-
-            max_count = 0;
-            words.each do |word|
-              max_count = word.length if word.length > max_count
-              if field.autocomplete[:where].count == 0
-                field.autocomplete[:where].push field.table_field+' LIKE ?'
-              else
-                field.autocomplete[:where][0] += ' AND '+field.table_field+' LIKE ?'
-              end
-              field.autocomplete[:where].push("%#{word}%")
-            end
-            if max_count < field.autocomplete[:count]
-              field.autocomplete[:where] = []
-            end
-          else
-            if value.length >= field.autocomplete[:count]
-              field.autocomplete[:where] = [field.table_field+' LIKE ?', '%'+value+'%']
-            end
-          end
-          if field.autocomplete[:where].count > 0
-            self.load_autocomplete_data field
-          end
-          if self.etc.data.data
-            self.etc.data.data.each do |item|
-              if item.respond_to? field.model.title
-                self.output.values.push(
-                  #id: item.id,
-                  value: item.send(field.model.title)
-                )
-              else
-                self.output.values.push(
-                  #id: item.id,
-                  value: item.id
-                )
-              end
-            end
-          end
-          return self.output.values
-        end
-
-        ##
-        # Returns current parent data. If data not loaded then load it.
-        # @return [ActiveRecord] resulting parent data
-        def get_parent_data
-          if !self.etc.data.parent
-            self.load_parent_data
-          end
-          self.etc.data.parent
-        end
-      end
-    end
-  end
-end

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

@@ -1,89 +0,0 @@
-module Anoubis
-  module Core
-    module Data
-      ##
-      # Module loads data from external sources for {DataController}
-      module Load
-        ##
-        # Loads current menu data. Procedure loads menu data from MySQL database or from Redis cache and places it in
-        # self.etc.menu {Anoubis::Etc#menu}
-        def load_menu_data
-
-        end
-
-        ##
-        # Load total number of rows of defined model in {Etc::Data#count}.
-        def load_table_data_count
-          #self.get_table_model.eager_load(self.get_table_eager_load).where(self.get_current_tab_where).where(self.get_table_where).where(self.etc.filter[:h]).where(self.etc.filter[:a]).count
-          self.etc.data.count = self.get_model.eager_load(self.get_eager_load).where(self.get_tenant_where(self.get_model)).where(self.get_where).where(self.get_tab_where).where(self.get_filter_where_hash).where(self.get_filter_where_array).count
-        end
-
-        ##
-        # Load model data into {Etc::Data#data}
-        # @param limit [Integer] Specifies the maximum number of rows to return.
-        # @param offset [Integer] Specifies the offset of the first row to return.
-        def load_table_data(limit = 10, offset = 0)
-          #self.etc.data.data = self.get_table_model.eager_load(self.get_table_eager_load).where(self.get_current_tab_where).where(self.get_table_where).where(self.etc.filter[:h]).where(self.etc.filter[:a]).order(self.get_current_order).limit(limit).offset(offset)
-          if self.select
-            self.etc.data.data = self.get_model.select(self.select).eager_load(self.get_eager_load).where(self.get_tenant_where(self.get_model)).where(self.get_where).where(self.get_tab_where).where(self.get_filter_where_hash).where(self.get_filter_where_array).order(self.get_order).limit(limit).offset(offset)
-          else
-            self.etc.data.data = self.get_model.eager_load(self.get_eager_load).where(self.get_tenant_where(self.get_model)).where(self.get_where).where(self.get_tab_where).where(self.get_filter_where_hash).where(self.get_filter_where_array).order(self.get_order).limit(limit).offset(offset)
-          end
-        end
-
-        ##
-        # Load single row of data into {Etc::Data#data}
-        # @param id [Integer] Data's identifier.
-        # @return [ActiveRecord|nil] Returns table data or nil if data absent
-        def load_data_by_id(id)
-          begin
-            self.etc.data.data = self.get_model.eager_load(self.get_eager_load).where(self.get_tenant_where(self.get_model)).where(self.get_where).where(self.get_tab_where).find(id)
-          rescue => error
-            puts error
-            self.etc.data.data = nil
-          end
-        end
-
-        ##
-        # Load single row of data into {Etc::Data#data}
-        # @param field [String] Field's identifier.
-        # @param value [String] Field's value.
-        # @return [ActiveRecord|nil] Returns table data or nil if data absent
-        def load_data_by_title(field, value)
-          where = {}
-          where[field.to_s.to_sym] = value
-          begin
-            self.etc.data.data = self.get_model.eager_load(self.get_eager_load).where(self.get_tenant_where(self.get_model)).where(self.get_where).where(self.get_tab_where).where(where).first
-          rescue => error
-            puts error
-            self.etc.data.data = nil
-          end
-        end
-
-        ##
-        # Load predefined model data into {Etc::Data#data}
-        # @return [ActiveRecord] Returns predefined data
-        def load_new_data(action = 'new')
-          self.etc.data.data = self.get_model.eager_load(self.get_eager_load).new
-        end
-
-        ##
-        # Load data for autocomplete action from database
-        # @param field [Anoubis::Etc::Field] - field for loading data
-        def load_autocomplete_data(field)
-          self.etc.data.data = field.model.model.where(field.model.where).where(field.autocomplete[:where]).where(get_tenant_where(field.model.model)).order(field.model.order).limit(field.autocomplete[:limit])
-        end
-
-        ##
-        # Loads parent data from database
-        def load_parent_data
-          begin
-            self.etc.data.parent = self.parent_model.where(self.get_tenant_where(self.parent_model)).find(self.parent_id)
-          rescue
-            self.etc.data.parent = nil
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,49 +0,0 @@
-module Anoubis
-  module Core
-    module Data
-      ##
-      # Module sets system data for {DataController}
-      module Set
-        ##
-        # Sets parent model according by type. Resulting data placed in {Etc::Data#parent self.etc.data.parent}
-        # @param action [String] type of used action in controller.
-        #   - 'index' - for index action
-        #   - 'new' - for new action
-        #   - 'create' - for create action
-        #   - 'edit' - for edit action
-        #   - 'update' - for update action
-        #   - 'destroy' - for defstroy action
-        def set_parent_model(action = '')
-          self.etc.data = Anoubis::Etc::Data.new if !self.etc.data
-          self.etc.action = action if action != ''
-          self.set_current_tab
-        end
-
-        ##
-        # Gets tab for current controller and place it into {Etc::Base#tab self.etc.tab} system variable.
-        # If params[:tab] absent or incorrect then {Etc::Base#tab self.etc.tab} is set as first value of {Data::Defaults#tabs} hash.
-        def set_current_tab
-          if !self.etc.tab
-            tabs = self.tabs
-            if params.key? :tab
-              if params[:tab].to_s != ''
-                if tabs.key? params[:tab].to_s.to_sym
-                  self.etc.tab = Etc::TabItem.new(self.get_tab(params[:tab].to_s, tabs[params[:tab].to_s.to_sym]))
-                end
-              end
-            end
-            self.etc.tab = Etc::TabItem.new(self.get_tab(tabs.keys[0].to_s, tabs.values[0])) if !self.etc.tab
-          end
-        end
-
-        ##
-        # Defines new action and clears defined for old action variables
-        # @param action [String] type of used action in controller.
-        def set_new_action(action)
-          self.etc.action = action
-          self.etc.data.model = nil
-        end
-      end
-    end
-  end
-end