anoubis 1.0.1 → 1.0.10

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

@@ -0,0 +1,529 @@
+ module Anoubis
+   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

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

@@ -0,0 +1,87 @@
+module Anoubis
+  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

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

@@ -0,0 +1,47 @@
+module Anoubis
+  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