anoubis 1.0.0

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

@@ -0,0 +1,251 @@
+module Anubis
+  module Etc
+    ##
+    # Definitions of filter options for data.
+    class Filter
+      # @!attribute [rw]
+      # Defines row filter data
+      # @return [Hash,nil] row filter data.
+      class_attribute :data, default: nil
+
+      # @!attribute [rw]
+      # Defines ActiveRecord hash representation of where.
+      # @return [FieldOrder] hash representation of where
+      class_attribute :hash, default: {}
+
+      # @!attribute [rw]
+      # Defines ActiveRecord array representation of where.
+      # @return [FieldOrder] array representation of where
+      class_attribute :array, default: []
+
+      # @!attribute [rw]
+      # Defines reference for fields
+      # @return [Hash<Anubis::Etc::Field>] hash of fields
+      class_attribute :fields, default: nil
+
+      ##
+      # Sets default parameters for filter
+      def initialize(options = {})
+        self.fields = if options.key? :fields then options[:fields] else {} end
+        self.hash = {}
+        self.array = []
+        if options.key? :data then self.init_data(options[:data]) else self.data end
+      end
+
+      ##
+      # Generates hash representation of all class parameters,
+      # @return [Hash] hash representation of all data
+      def to_h
+        result = {
+            data: self.data,
+            hash: self.hash,
+            array: self.array,
+            fields: {}
+        }
+        self.fields.each_key do |key|
+          result[:fields][key] = self.fields[key].to_h
+        end
+        result
+      end
+
+      ##
+      # Initializes all where parameters according by data and fields.
+      # @param data [Hash] Collection of filter parameters in format <i>field: value</i>
+      def init_data(data = nil)
+        self.data = if data then data else {} end
+
+        if self.fields
+          self.fields.each do |key, field|
+            if self.data.key? key.to_s
+              proc = format('init_data_%s', field.type)
+              result = self.send proc, key, self.data[key.to_s]
+            end
+          end
+        end
+      end
+
+      ##
+      # Initializes where parameters for filed with type string.
+      # @param key [Symbol] Filed identifier
+      # @param value [String] Filter parameters
+      def init_data_string(key, value)
+        words = value.split(' ')
+
+        words.each do |word|
+          self.attach_to_array self.fields[key].table_field.to_s+' LIKE ?'
+          self.array.push("%#{word}%")
+        end
+      end
+
+      ##
+      # Initializes where parameters for filed with type text.
+      # @param key [Symbol] Filed identifier
+      # @param value [String] Filter parameters
+      def init_data_text(key, value)
+        words = value.split(' ')
+
+        words.each do |word|
+          self.attach_to_array self.fields[key].table_field.to_s+' LIKE ?'
+          self.array.push("%#{word}%")
+        end
+      end
+
+      ##
+      # Initializes where parameters for filed with type number.
+      # @param key [Symbol] Filed identifier
+      # @param value [String] Filter parameters
+      def init_data_number(key, value)
+        if value.index ','
+          if self.fields[key].table_field.to_s.include? '.'
+            self.attach_to_array self.fields[key].table_field.to_s + ' IN (?)'
+            self.array.push(value.split ',')
+          else
+            self.hash[key] = value.split ','
+          end
+          return
+        end
+
+        if value.index '>'
+          if value.to_s.include? '.'
+            result_value = value.to_s[1..100].to_f
+          else
+            result_value = value.to_s[1..100].to_i
+          end
+          if self.fields[key].table_field.to_s.include? '.'
+            self.attach_to_array self.fields[key].table_field.to_s + ' > ?'
+
+            self.array.push(result_value)
+          else
+            self.hash[key] = [result_value..Float::INFINITY]
+          end
+          return
+        end
+
+        if value.index '<'
+          if value.to_s.include? '.'
+            result_value = value.to_s[1..100].to_f
+          else
+            result_value = value.to_s[1..100].to_i
+          end
+          if self.fields[key].table_field.to_s.include? '.'
+            self.attach_to_array self.fields[key].table_field.to_s + ' < ?'
+            self.array.push(result_value)
+          else
+            self.hash[key] = [-Float::INFINITY..result_value]
+          end
+          return
+        end
+
+        if value.index '-'
+          data = value.split '-'
+          if data[0].include? '.'
+            min_value = data[0].to_f
+          else
+            min_value = data[0].to_i
+          end
+          if data[1].include? '.'
+            max_value = data[1].to_f
+          else
+            max_value = data[1].to_i
+          end
+          min_value, max_value = max_value, min_value if min_value > max_value
+          if self.fields[key].table_field.to_s.include? '.'
+            self.attach_to_array self.fields[key].table_field.to_s + ' > ? AND ' + self.fields[key].table_field.to_s + ' < ?'
+            self.array.push(min_value)
+            self.array.push(max_value)
+          else
+            self.hash[key] = [min_value..max_value]
+          end
+          return
+        end
+
+        if self.fields[key].table_field.to_s.include? '.'
+          self.attach_to_array self.fields[key].table_field.to_s + ' = ?'
+          self.array.push(value)
+        else
+          self.hash[key] = value
+        end
+      end
+
+      ##
+      # Initializes where parameters for filed with type listbox.
+      # @param key [Symbol] Filed identifier
+      # @param value [String] Filter parameters
+      def init_data_listbox(key, value)
+        values = []
+        if value.class == Array
+          value.each do |data|
+            if self.fields[key].options.enum
+              values.push self.fields[key].options.enum[data]
+            else
+              values.push data
+            end
+          end
+        end
+        if values.count > 0
+          if self.fields[key].table_field.to_s.include? '.'
+            self.attach_to_array self.fields[key].table_field.to_s + ' IN (?)'
+            self.array.push(values)
+          else
+            self.hash[self.fields[key].table_field] = values
+          end
+        end
+      end
+
+      ##
+      # Initializes where parameters for filed with type key.
+      # @param key [Symbol] Filed identifier
+      # @param value [String] Filter parameters
+      def init_data_key(key, value)
+        words = value.split(' ')
+
+        words.each do |word|
+          self.attach_to_array self.fields[key].table_field.to_s + ' LIKE ?'
+          self.array.push("%#{word}%")
+        end
+      end
+
+      ##
+      # Attach parameters to where
+      # @param str [String] attached parameters
+      def attach_to_array(str)
+        if self.array.count == 0
+          self.array.push(str)
+        else
+          self.array[0] += ' AND ' + str
+        end
+      end
+
+      ##
+      # Initializes where parameters for filed with type 'datetime'.
+      # @param key [Symbol] Filed identifier
+      # @param value [String] Filter parameters
+      def init_data_datetime(key, value)
+        if value.class == Array
+          if value.count == 2
+            begin
+              from = Time.parse value[0]
+              to = Time.parse value[1]
+            rescue
+              from = nil
+              to = nil
+            end
+            if from && to
+              self.hash[key] = [ from..to ]
+            end
+          end
+        end
+        #words = value.split(' ')
+
+#        words.each do |word|
+#          if self.array.count == 0
+#            self.array.push(self.fields[key].table_field.to_s + ' LIKE ?')
+#          else
+#            self.array[0] += ' AND '+self.fields[key].table_field.to_s+' LIKE ?'
+#          end
+#          self.array.push("%#{word}%")
+#        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,101 @@
+module Anubis
+  module Etc
+    ##
+    # Class stores main menu parameters and variables
+    class Menu
+      # @!attribute [rw] title
+      #   @return [String] returns title of current menu element
+      class_attribute :title, default: ''
+
+      # @!attribute [rw] page_title
+      #   @return [String] returns page title of current menu element
+      class_attribute :page_title, default: ''
+
+      # @!attribute [rw] short_title
+      #   @return [String] returns short title of current menu element
+      class_attribute :short_title, default: ''
+
+      # @!attribute [rw] mode
+      #   @return [String] returns mode of current menu element
+      class_attribute :mode, default: ''
+
+      # @!attribute [rw] parent_mode
+      #   @return [String] returns mode of parent menu for current menu element
+      class_attribute :parent_mode, default: ''
+
+      # @!attribute [rw] menu_id
+      #   @return [Integer] returns id of current menu element
+      class_attribute :menu_id, default: nil
+
+      # @!attribute [rw] parent_menu_id
+      #   @return [Integer] returns id of parent menu for current menu element
+      class_attribute :parent_menu_id, default: nil
+
+      # @!attribute [rw] action
+      #   @return [String] returns action of current menu element
+      class_attribute :action, default: ''
+
+      # @!attribute [rw] tab
+      #   @return [Integer] returns level of current menu element
+      class_attribute :tab, default: 0
+
+      # @!attribute [rw] position
+      #   @return [Integer] returns position in level of current menu element
+      class_attribute :position, default: 0
+
+      # @!attribute [rw] state
+      #   @return [String] returns state of current menu element ('visible', 'hidden')
+      class_attribute :state, default: 'visible'
+
+      # @!attribute [rw] access
+      #   @return [String] returns access state of current menu element ('read', 'write')
+      class_attribute :access, default: 'read'
+
+      ##
+      # Sets default parameters for menu element
+      # @param [Hash] options initial menu paramters
+      # @option options [String] :title menu title
+      # @option options [String] :page_title page title
+      # @option options [String] :short_title short page title
+      # @option options [String] :mode menu mode
+      # @option options [String] :parent_mode parent menu mode
+      # @option options [Integer] :menu_id id of menu (if <b>id</b> isn't defined)
+      # @option options [Integer] :id id of menu (if <b>menu_id</b> isn't defined)
+      # @option options [Integer] :parent_menu_id id of parent menu
+      # @option options [String] :action menu action
+      # @option options [Integer] :tab menu tab index
+      # @option options [Integer] :position position in current level
+      # @option options [String] :state state of the menu ('visible', 'hidden')
+      # @option options [String] :access access state of the menu ('read', 'write')
+      def initialize(options = {})
+        if options.class == Hash
+          self.title = options[:title] if options.has_key? :title
+          self.page_title = options[:page_title] if options.has_key? :page_title
+          self.short_title = options[:short_title] if options.has_key? :short_title
+          self.mode = options[:mode] if options.has_key? :mode
+          self.parent_mode = options[:parent_mode] if options.has_key? :parent_mode
+          self.menu_id = options[:menu_id] if options.has_key? :menu_id
+          self.menu_id = options[:id] if options.has_key? :id
+          self.parent_menu_id = options[:parent_menu_id] if options.has_key? :parent_menu_id
+          self.action = options[:action] if options.has_key? :action
+          self.tab = options[:tab] if options.has_key? :tab
+          self.position = options[:position] if options.has_key? :position
+          self.state = options[:state] if options.has_key? :state
+          self.access = options[:access] if options.has_key? :access
+        end
+        if options.class == Anubis::Sso::Client::Menu
+          self.title = options.title
+          self.page_title = options.page_title
+          self.short_title = options.short_title
+          self.mode = options.mode
+          self.menu_id = options.id
+          self.parent_menu_id = options.menu_id
+          self.action = options.action
+          self.tab = options.tab
+          self.position = options.position
+          self.state = options.state
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,67 @@
+module Anubis
+  module Etc
+    ##
+    # Definitions of model options. Class is used for define attached model.
+    class Model
+      # @!attribute [rw]
+      # Defines model class. This field is required.
+      # @return [ActiveRecord] model's class.
+      class_attribute :model, default: nil
+
+      # @!attribute [rw]
+      # Field name is used for defines title when data selected from model.
+      # @return [Symbol] field's name
+      class_attribute :title, default: :title
+
+      # @!attribute [rw]
+      # Field name is used for defines order field when data selected from model. By default uses field daefined as
+      # (#title)
+      # @return [Boolean] field's name
+      class_attribute :order, default: :title
+
+      # @!attribute [rw]
+      # Where parameters are used when data selected from model.
+      # @return [Hash] hash of where's parameters
+      class_attribute :where, default: {}
+
+      # @!attribute [rw]
+      # Special select parameters.
+      # @return [String] string of special select or nil
+      class_attribute :select, default: nil
+
+      # @!attribute [rw]
+      # Timestamp of last changes in the model.
+      # @return [Number] timestamp of last changes in model.
+      class_attribute :updated_at, default: {}
+
+      ##
+      # Sets default parameters for field
+      # @param [Hash] options initial model options
+      # @option options [ActiveRecord] :model model class
+      # @option options [Symbol] :title field name is used for receive options titles
+      # @option options [Symbol] :order field name is used for order options
+      # @option options [Hash] :where where parameters for select data from model
+      def initialize(options = {})
+        self.model = options[:model]
+        self.title = if options.key? :title then options[:title] else :title end
+        self.order = if options.key? :order then options[:order] else self.title end
+        self.where = if options.key? :where then options[:where] else {} end
+        self.select = if options.key? :select then options[:select] else nil end
+        self.updated_at = 0
+      end
+
+      ##
+      # Generates hash representation of all class parameters,
+      # @return [Hash] hash representation of all data
+      def to_h
+        {
+            model: self.model,
+            title: self.title,
+            order: self.order,
+            where: self.where,
+            updated_at: self.updated_at
+        }
+      end
+    end
+  end
+end

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

@@ -0,0 +1,91 @@
+module Anubis
+  module Etc
+    ##
+    # Definitions of tab options.
+    class TabItem
+      # @!attribute [rw]
+      # Returns tab identifier
+      # @return [String] tab's identifier.
+      class_attribute :tab, default: nil
+
+      # @!attribute [rw]
+      # Returns tab title
+      # @return [String] tab's title.
+      class_attribute :title, default: ''
+
+      # @!attribute [rw]
+      # Returns tab hint
+      # @return [String] tab's hint.
+      class_attribute :hint, default: ''
+
+      # @!attribute [rw]
+      # Returns tab where for selection from model.
+      # @return [Hash|Array] tab's where
+      class_attribute :where, default: []
+
+      # @!attribute [rw]
+      # Returns possibility for export data for this tab <i>(default: true)</i>
+      # @return [Boolean] tab's export possibility
+      class_attribute :export, default: true
+
+      # @!attribute [rw]
+      # Returns possibility for filter data for this tab <i>(default: true)</i>
+      # @return [Boolean] tab's filter possibility
+      class_attribute :filter, default: true
+
+      # @!attribute [rw]
+      # Returns possibility for filter data for this tab <i>(default: true)</i>
+      # @return [Hash] tab's filter possibility
+      class_attribute :buttons, default: {}
+
+      # @!attribute [rw]
+      # Returns order field for this tab <i>(default: nil)</i>
+      # @return [String] tab's order field
+      class_attribute :sort, default: nil
+
+      # @!attribute [rw]
+      # Returns order type for this tab ('asc' or 'desc') <i>(default: nil)</i>
+      # @return [String] tab's order type
+      class_attribute :order, default: nil
+
+      ##
+      # Sets default parameters for tab
+      # @param options [String] initial tab options
+      # @option options [String] :tab tab identifier
+      def initialize(options = {})
+        self.tab = if options.key?(:tab) then options[:tab] else nil end
+        self.sort = if options.key?(:sort) then options[:sort] else nil end
+        self.order = ''
+        if options.key? :order
+          self.order = options[:order] if %w[asc desc].include?(options[:order])
+        end
+        self.title = if options.key?(:title) then options[:title] else self.tab.humanize end
+        self.hint = if options.key?(:hint) then options[:hint] else '' end
+        self.where = if options.key?(:where) then options[:where] else [] end
+        self.export = if options.key?(:export) then options[:export] else true end
+        self.filter = if options.key?(:filter) then options[:filter] else true end
+        self.buttons = if options.key?(:buttons) then options[:buttons] else true end
+      end
+
+      ##
+      # Generates hash representation of all class parameters,
+      # @return [Hash] hash representation of all parameters
+      def to_h
+        result = {
+            tab: self.tab,
+            title: self.title,
+            hint: self.hint,
+            where: self.where,
+            export: self.export,
+            filter: self.filter,
+            buttons: self.buttons
+        }
+        if self.sort
+          result[:sort] = self.sort
+          result[:order] = self.order if self.order != ''
+        end
+        result
+      end
+    end
+  end
+end

data/app/controllers/anoubis/etc.rb

@@ -0,0 +1,8 @@
+module Anubis
+  ##
+  # Module stores systems variables and functions. Module consists of {Base}, {Data}, {Field}, {FieldOptions},
+  # {Menu}, {Model} and {TabItem} classes.
+  module Etc
+
+  end
+end

data/app/controllers/anoubis/export.rb

@@ -0,0 +1,47 @@
+module Anubis
+  class Export
+    class_attribute :data
+    class_attribute :title
+    class_attribute :format
+    class_attribute :fields
+
+    def initialize(options = {})
+      self.data = []
+      self.title = []
+      options[:format] = 'xls' if !options.key? :format
+      self.format = options[:format]
+      self.fields = if options.key?(:fields) then options[:fields] else nil end
+      if self.fields
+        self.fields.each do |field|
+          self.title.push field[:title]
+        end
+      end
+    end
+
+    def add (data)
+      data.each do |dat|
+        new_data = []
+        self.fields.each do |field|
+          if dat.key? field[:id].to_sym
+            new_data.push dat[field[:id].to_sym]
+          else
+            new_data.push ''
+          end
+        end
+        #new_data = dat.except :actions, :sys_title
+        self.data.push(new_data)
+      end
+    end
+
+    def to_h
+      {
+          data: self.data,
+          title: self.title,
+          fields: self.fields,
+          format: self.format
+      }
+    end
+
+    public :format
+  end
+end

data/app/controllers/anoubis/output/autocomplete.rb

@@ -0,0 +1,30 @@
+module Anubis
+  module Output
+    ##
+    # Output subclass that represents data for edit(new) action
+    class Autocomplete < Basic
+      # @!attribute [rw]
+      # @return [Hash] the hash of defined fields.
+      class_attribute :values, default: {}
+
+      ##
+      # Initializes menu output data. Generates default values.
+      def initialize
+        super
+        self.values = []
+      end
+
+      ##
+      # Generates hash representation of output class
+      # @return [Hash] hash representation of all data
+      def to_h
+        result = super.to_h
+        return result if self.result != 0
+        result.merge!({
+                          values: self.values,
+                      })
+        result
+      end
+    end
+  end
+end

data/app/controllers/anoubis/output/basic.rb

@@ -0,0 +1,86 @@
+module Anubis
+  ##
+  # Module contains all procedures and function for output data. Module consists from {Basic}, {Frame}, {Login} and
+  # {Menu} classes.
+  module Output
+    ##
+    # Output subclass that represents parametrs for basic requests
+    class Basic
+      # @!attribute [rw] title
+      #   @return [string] the page title of current loaded frame.
+      class_attribute :title
+
+      # @!attribute [rw]
+      # @return [Hash<string>] hash of messages
+      class_attribute :messages
+
+      # @!attribute [rw]
+      # @return [Number] controller action output result code.
+      # @note Zero value means successful. Negative value means error.
+      class_attribute :result, default: 0
+
+      # @!attribute [rw]
+      # @return [String] current returned tab
+      class_attribute :tab, default: ''
+
+      ##
+      # Output class initialization. Sets default class parameters.
+      def initialize
+        self.title = nil
+        self.result = 0
+        self.tab = ''
+        self.messages = {
+            '0': I18n.t('success'),
+            '-1': I18n.t('errors.access_not_allowed'),
+            '-2': I18n.t('errors.incorrect_parameters')
+        }
+      end
+
+      ##
+      # Generates hash representation of output class
+      # @return [Hash] hash representation of all class data
+      def to_h
+        result = {
+            result: self.result,
+            timestamp: Time.now.to_i,
+            message: message
+        }
+        result[:title] = self.title if self.title
+        result[:tab] = self.tab if self.tab != ''
+        result
+      end
+
+      ##
+      # Generates output message based on result variable.
+      # @return [String] output message
+      def message
+        return messages[result.to_s.to_sym] if messages.key? result.to_s.to_sym
+        I18n.t('errors.internal_error')
+      end
+
+      ##
+      # Convert hash to array json output
+      # @param hash [Hash] hash representation
+      # @return [Array] array representation
+      def hash_to_json(hash)
+        result = []
+        hash.each_key do |key|
+          result.push({ key: key.to_s, value: hash[key] })
+        end
+        result
+      end
+
+      ##
+      # Convert options hash to array json output
+      # @param options [Hash<Hash>] options with hash representation
+      # @return [Hash<Array>] options with array representation
+      def options_to_json(options)
+        result = {}
+        options.each_key do |key|
+          result[key] = self.hash_to_json(options[key])
+        end
+        result
+      end
+    end
+  end
+end