anoubis 1.0.0

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

@@ -0,0 +1,104 @@
+module Anubis
+  ##
+  # Module consists all procedures and functons of {DataController}
+  module Core
+    module Data
+      ##
+      # Module setups system parameters for {DataController}
+      module Setup
+        ##
+        # Setups frame data information. It loads menu data, sets titles and tabs of the frame.
+        def setup_frame
+          self.load_menu_data
+          if self.etc.menu
+            self.get_parent_data
+            if self.etc.data.parent
+              self.output.title = self.etc.menu.page_title.sub '%{title}', self.etc.data.parent.sys_title.to_s
+            else
+              self.output.title = self.etc.menu.page_title
+            end
+            self.output.short = self.etc.menu.short_title
+            self.output.mode = self.etc.menu.mode
+            self.output.access = self.etc.menu.access
+          end
+          tabs = self.tabs
+          tabs.each do |key, item|
+            item = self.get_tab key, item
+            self.output.addTab(item)
+          end
+        end
+
+        ##
+        # Setups order for current tab. Parameters is set into {Anubis::Etc::TabItem#sort self.etc.tab.sort} and
+        # {Anubis::Etc::TabItem#order self.etc.tab.order} attributes.
+        def setup_order
+          sort = nil
+          first = nil
+          self.etc.data.fields.each do |key, field|
+            if field.order
+              first = key if !first
+              first = key if field.order.default
+              if params.key? :sort
+                sort = key if params[:sort] == key.to_s
+              end
+            end
+          end
+          sort = first if !sort
+          if sort
+            self.etc.tab.sort = sort.to_s
+            self.etc.tab.order = self.etc.data.fields[sort].order.order
+            if params.key? :order
+              self.etc.tab.order = :desc if params[:order] == 'desc'
+              self.etc.tab.order = :asc if params[:order] == 'asc'
+            end
+          end
+        end
+
+        ##
+        # @!group Block of fields setup functions
+
+        ##
+        # Setups defined fields and places it into attribute {Anubis::Etc::Data#fields self.etc.data.fields}
+        def setup_fields
+          if !self.etc.data.fields
+            self.etc.data.fields = {}
+
+            fields = self.fields
+
+            fields.each_key do |key|
+              if fields[key].key? :edit
+                if self.menu_access fields[key][:edit], false
+                  fields[key][:editable] = fields[key][:edit]
+                end
+              end
+              self.etc.data.fields[key] = Anubis::Etc::Field.new(key, self.get_model, fields[key].merge(action: self.etc.action))
+            end
+            self.setup_order if %w[index export].include? self.etc.action
+          end
+        end
+
+        ##
+        # Setups additional parameters for table field with type 'datetime'
+        # Resulting data placed in {Etc::Data#fields self.etc.data.fields} (Hash)
+        # @param key [Symbol] key of table field.
+        def setup_fields_datetime (key)
+          self.etc.data.fields[key][:format] = 'full' if !self.etc.data.fields[key].has_key? :format
+          self.etc.data.fields[key][:format] = 'full' if !['full', 'month', 'date', 'datetime'].include? self.etc.data.fields[key][:format]
+        end
+
+
+
+        ##
+        # Setups additional parameters for table field with type 'float'
+        # Resulting data placed in {Etc::Data#fields self.etc.data.fields} (Hash)
+        # @param key [Symbol] key of table field.
+        def setup_fields_float (key)
+          self.etc.data.fields[key][:precision] = 2 if !self.etc.data.fields[key][:precision]
+          self.etc.data.fields[key][:point] = ',' if !self.etc.data.fields[key][:point]
+          self.etc.data.fields[key][:separator] = '' if !self.etc.data.fields[key][:separator]
+        end
+        # @!endgroup
+      end
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+require_dependency "anubis/core/application_controller"
+require_dependency "anubis/core/data/actions"
+require_dependency "anubis/core/data/load"
+require_dependency "anubis/core/data/get"
+require_dependency "anubis/core/data/set"
+require_dependency "anubis/core/data/setup"
+require_dependency "anubis/core/data/defaults"
+require_dependency "anubis/core/data/convert"
+require_dependency "anubis/core/data/callbacks"
+
+module Anubis
+  ##
+  # Module presents all core functions for Anubis Library
+  module Core
+    ##
+    # Controller consists all procedures and function for presents and modify models data.
+    class DataController < Anubis::Core::ApplicationController
+      include Anubis::Core::Data::Actions
+      include Anubis::Core::Data::Load
+      include Anubis::Core::Data::Get
+      include Anubis::Core::Data::Set
+      include Anubis::Core::Data::Setup
+      include Anubis::Core::Data::Defaults
+      include Anubis::Core::Data::Convert
+      include Anubis::Core::Data::Callbacks
+    end
+  end
+end

data/app/controllers/anoubis/core/index/actions.rb

@@ -0,0 +1,53 @@
+require_dependency "anubis/output/login"
+
+module Anubis
+  module Core
+    ##
+    # Module contains all procedures and function for {IndexController}. Consists of {Actions} and {Callbacks} module.
+    module Index
+      ##
+      # Module contains all basic actions for {IndexController}.
+      module Actions
+        ##
+        # <i>Logout</i> action of index controller. Procedure logouts user out of the system and deletes active sessions.
+        # Authorization bearer is required. Procedure no need additional parameters.
+        #
+        # <b>API request:</b>
+        #   POST /api/<version>/logout
+        # <b>Request Header:</b>
+        #   {
+        #     "Authorization": "Bearer <Session token>"
+        #   }
+        # <b>Request example:</b>
+        #   curl --header "Content-Type: application/json" -header 'Authorization: Bearer <session-token>' http://<server>:<port>/api/<api-version>/logout
+        #
+        # <b>Results:</b><br>
+        #
+        # Resulting data returns in JSON format.
+        #
+        # <b>Examples:</b>
+        #
+        # <b>Success:</b> HTTP response code 200
+        #   {
+        #     "result": 0,
+        #     "message": "Successful"
+        #   }
+        #
+        # <b>Error:</b> HTTP response code 422
+        #   {
+        #     "result": -1,
+        #     "message": "Session expired"
+        #   }
+        def logout
+          self.output = Anubis::Output::Basic.new
+          self.redis.del(self.redis_prefix + 'ses_'+self.token)
+          respond_to do |format|
+            format.json { render json: self.output.to_h }
+          end
+        end
+
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+module Anubis
+  module Core
+    ##
+    # Module contains all procedures and function for {IndexController}. Consists of {Actions} and {Callbacks} module.
+    module Index
+      ##
+      # Module contains all callbacks {IndexController}.
+      module Callbacks
+        ##
+        # Calls before menu output data.
+        def before_menu_output
+
+        end
+
+        ##
+        # Calls when menu data is being output
+        def around_menu_output(data)
+          data
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,36 @@
+require_dependency "anubis/core/application_controller"
+require_dependency "anubis/core/index/actions"
+require_dependency "anubis/core/index/callbacks"
+
+module Anubis
+  module Core
+    ##
+    # Controller processes main system functions. Authenticates user, checks user access, outputs main menu and etc.
+    class IndexController < Anubis::Core::ApplicationController
+      include Anubis::Core::Index::Actions
+      include Anubis::Core::Index::Callbacks
+
+      ##
+      # Check if authentication required
+      def authenticate?
+        if controller_name == 'index'
+          if action_name == 'login'
+            return false
+          end
+        end
+        return true
+      end
+
+      ##
+      # Check if authentication required
+      def check_menu_access?
+        if controller_name == 'index'
+          if action_name == 'login' || action_name == 'menu' || action_name == 'logout'
+            return false
+          end
+        end
+        return true
+      end
+    end
+  end
+end

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

@@ -0,0 +1,52 @@
+module Anubis
+  module Etc
+    ##
+    # Basic system variables class
+    class Base
+      # @!attribute [rw]
+      # @return [Data, nil] current loaded data or nil if data not loaded.
+      # @note In this attribute placed data when loaded from the model by actions 'table', 'edit', 'update', 'create' etc.
+      class_attribute :data
+
+      # @!attribute [rw]
+      # @return [Menu, nil] menu information for current controller
+      # Returns menu information for current controller. By default sets to <i>nil</i>.
+      class_attribute :menu, default: nil
+
+      # @!attribute [rw]
+      # @return [TabItem, nil] tab information for current controller
+      # Returns tab information for current controller. By default sets to <i>nil</i>.
+      class_attribute :tab, default: nil
+
+      # @!attribute [rw]
+      # @return [String] current controller action.
+      # Returns current controller action. By default sets to controller action or ''.
+      class_attribute :action, default: ''
+
+      # @!attribute [rw]
+      # @return [Number] time of request.
+      # Returns time that was requested from client. By default sets to <i>0</i>.
+      class_attribute :time, default: 0
+
+      ##
+      # Sets default system parameters
+      # @param [Hash] options initial class options
+      # @option options [ActionController::Parameters] :params initial controller parameters
+      def initialize(options = {})
+        self.data = nil
+        self.menu = nil
+        self.tab = nil
+        self.action = ''
+
+        if options.key? :params
+          self.action = options[:params][:action] if options[:params].key? :action
+          if options[:params].key? :time
+            self.time = options[:params][:time].to_s.to_i
+          else
+            self.time = 0
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,89 @@
+module Anubis
+  module Etc
+    ##
+    # Class stores data information for current controller
+    class Data
+      # @!attribute [rw] data
+      #   @return [ActiveRecord, nil] current loaded data from the defined model or nil if data not loaded.
+      #   @note Data is placed in this attribute when loaded from the model by actions 'index', 'edit', 'update', 'create' etc.
+      class_attribute :data
+
+      # @!attribute [rw] fields
+      #   @return [Hash<Symbol, Field>, nil] current defined hash of model represented fields or nil if fields aren't defined
+      #   @note Field's options are placed in this attribute for actions 'index', 'edit', 'update', 'create' etc.
+      class_attribute :fields, default: nil
+
+      # @!attribute [rw] actions
+      #   @return [Array, nil] current defined string array of table actions.
+      class_attribute :actions, default: nil
+
+      #@!attribute [rw] parent
+      #   @return [ActiveRecord] <i>(defaults to: nil)</i> Specify the parent ActiveRecord for controller (if exists)
+      class_attribute :parent, default: nil
+
+      #@!attribute [rw] model
+      #   @return [ActiveRecord] <i>(defaults to: nil)</i> Specify the current ActiveRecord for controller (if exists)
+      class_attribute :model, default: nil
+
+      #@!attribute [rw] eager_load
+      #   @return [Array] <i>(defaults to: [])</i> Specify the current eager loaded models
+      class_attribute :eager_load, default: []
+
+      #@!attribute [rw] limit
+      #   @return [Integer] <i>(defaults to: 10)</i> Specify the total number of returned rows
+      class_attribute :limit, default: 10
+
+      #@!attribute [rw] offset
+      #   @return [Integer] <i>(defaults to: 0)</i> Specify the default offset for rows were returned
+      class_attribute :offset, default: 0
+
+      #@!attribute [rw] count
+      #   @return [Integer] <i>(defaults to: 0)</i> Specify the count of rows for defined data model
+      class_attribute :count, default: 0
+
+      #@!attribute [rw]
+      class_attribute :filter, default: nil
+
+      ##
+      # Sets default basic system parameters
+      def initialize(options = {})
+        self.data = nil
+        self.fields = nil
+        self.actions = nil
+        self.parent = nil
+        self.model = nil
+        self.count = 0
+        self.eager_load = []
+        self.limit = 10
+        self.offset = 0
+        self.filter = nil
+      end
+
+      def limit=(value)
+        value = value.to_s.to_i
+        value = 10 if value < 1
+        @limit = value
+      end
+
+      def offset=(value)
+        value = value.to_s.to_i
+        value = 0 if value < 0
+        value = 0 if value > self.count
+        @offset = value
+      end
+
+      def to_h
+        {
+            fields: self.fields,
+            model: self.model,
+            eager_load: self.eager_load,
+            count: self.count,
+            limit: self.limit,
+            offset: self.offset,
+            actions: self.actions,
+            parent: self.parent
+        }
+      end
+    end
+  end
+end