anoubis 1.0.0

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

@@ -0,0 +1,531 @@
+ module Anubis
+   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 = Anubis::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 {Anubis::Data::Actions#edit edit} and {Anubis::Data::Actions#update update} getters
+
+        ##
+        # Get model that is used for {Anubis::Data::Actions#edit edit} or {Anubis::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 {Anubis::Data::Actions#edit edit} or
+        # {Anubis::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 {Anubis::Data::Actions#edit edit} or
+        # {Anubis::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 {Anubis::Data::Actions#edit edit} or {Anubis::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 {Anubis::Data::Actions#new new} or {Anubis::Data::Actions#create create} getters
+
+        ##
+        # Return current table fields hash for {Anubis::Data::Actions#new new} or {Anubis::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 {Anubis::Data::Actions#new new} or {Anubis::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 {Anubis::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 [Anubis::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

@@ -0,0 +1,89 @@
+module Anubis
+  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 {Anubis::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 [Anubis::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

@@ -0,0 +1,49 @@
+module Anubis
+  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 = Anubis::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