anoubis 1.0.0

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

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

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

@@ -0,0 +1,191 @@
+module Anubis
+  module Tenant
+    module Index
+      ##
+      # Module contains all basic actions for {IndexController}.
+      module Actions
+        include Anubis::Core::Index::Actions
+
+        ##
+        # <i>Login</i> action of index controller. Procedure checks user credential. If credentials are correct than user enters
+        # into the system and procedure returns session token. If credentials are incorrect then procedure returns error.
+        #
+        # <b>API request:</b>
+        #   POST /api/<version>/login
+        # <b>Request body:</b>
+        #   {
+        #     "login": "login",
+        #     "password": "password",
+        #     "locale": "Country code"
+        #   }
+        # <b>Parameters:</b>
+        # - <b>login</b> (String) -- the login of the user
+        # - <b>password</b> (String) -- the password of the user
+        # - <b>locale</b> (String) -- the output language locale <i>(optional value)</i>
+        #
+        # <b>Request example:</b>
+        #   curl --header "Content-Type: application/json" --request POST --data '{"login":"<login>","password":"<password>"}' http://<server>:<port>/api/<api-version>/login
+        #
+        # <b>Results:</b><br>
+        #
+        # Resulting data is placed in self.output({Anubis::OutputLogin}) class and returns in JSON format.
+        #
+        # <b>Examples:</b>
+        #
+        # <b>Success:</b> HTTP response code 200
+        #   {
+        #     "result": 0,
+        #     "message": "Successful",
+        #     "name": "Name",
+        #     "surname": "Surname",
+        #     "token": "Session token",
+        #     "email": "e-mail"
+        #   }
+        #
+        # <b>Error:</b> HTTP response code 422
+        #   {
+        #     "result": -1,
+        #     "message": "Incorrect user login or password"
+        #   }
+        def login
+          self.output = Anubis::Output::Login.new
+          if params.has_key?(:login) && params.has_key?(:password)
+            user = Anubis::Tenant::User.where(login: params[:login].downcase, status: 0).first
+
+            if !user
+              tenant = Anubis::Tenant::Tenant.where(state: Anubis::Tenant::Tenant.states[:default]).first
+              user = Anubis::Tenant::User.where(login: (params[:login]+'.'+tenant.ident).downcase, status: 0).first
+            end
+
+            if !user
+              tenant = Anubis::Tenant::Tenant.find(1)
+              user = Anubis::Tenant::User.where(login: (params[:login]+'.'+tenant.ident).downcase, status: 0).first
+            end
+
+            if user && user.authenticate(params[:password])
+              if !user.auth_key
+                self.redis_save_user(user)
+                self.output.token = new_session_id
+                self.output.name = user.name
+                self.output.surname = user.surname
+                self.output.email = user.email
+                self.output.locale = user.locale
+                self.redis.set(self.redis_prefix + 'session:' + self.output.token, { uuid: user.uuid, login: Time.now, time: Time.now, ttl: Time.now + user.timeout}.to_json)
+              else
+                self.output.result = -2
+              end
+            else
+              self.output.result = -2
+            end
+          else
+            self.output.result = -1
+          end
+          respond_to do |format|
+            if self.output.result == 0
+              format.json { render json: self.output.to_h }
+            else
+              format.json { render json: self.output.to_h, status: :unprocessable_entity }
+            end
+          end
+        end
+
+        ##
+        # <i>Menu</i> action of index controller. Procedure outputs menu for current user in JSON format.
+        # Authorization bearer is required.
+        #
+        # <b>API request:</b>
+        #   GET /api/<version>/menu
+        # <b>Request Header:</b>
+        #   {
+        #     "Authorization": "Bearer <Session token>"
+        #   }
+        #
+        # <b>Parameters:</b>
+        # - <b>locale</b> (String) -- the output language locale <i>(optional value)</i>
+        #
+        # <b>Request example:</b>
+        #   curl --header "Content-Type: application/json" -header 'Authorization: Bearer <session-token>' http://<server>:<port>/api/<api-version>/menu?locale=en
+        #
+        # <b>Results:</b><br>
+        #
+        # Resulting data is placed in self.output({Anubis::Output::Menu}) variable and returns in JSON format.
+        #
+        # <b>Examples:</b>
+        #
+        # <b>Success:</b> HTTP response code 200
+        #   {
+        #     "result": 0,
+        #     "message": "Successful",
+        #     "menu": {
+        #       [{
+        #         "mode": "admin/anubis",
+        #         "title": "Administration",
+        #         "page_title": "System administration",
+        #         "short_title": "",
+        #         "position": 0,
+        #         "tab": 0,
+        #         "action": "menu",
+        #         "access": "read",
+        #         "state": "visible",
+        #         "parent": ""
+        #       }]
+        #     }
+        #   }
+        #
+        # <b>Error:</b> HTTP response code 422
+        #   {
+        #     "result": -1,
+        #     "message": "Session expired"
+        #   }
+        def menu
+          self.output = Anubis::Output::Menu.new
+          access = Anubis::Tenant::GroupMenu.accesses[:read].to_s+','+Anubis::Tenant::GroupMenu.accesses[:write].to_s
+          locale = Anubis::Tenant::MenuLocale.locales[self.locale.to_s.to_sym]
+          query = <<-SQL
+          SELECT `t`.* FROM
+            (
+              SELECT `t2`.`id`, `t2`.`mode`, `t2`.`action`, `t2`.`title`, `t2`.`page_title`, `t2`.`short_title`, 
+                `t2`.`position`, `t2`.`tab`, `t2`.`menu_id`, `t2`.`state`, MAX(`t2`.`access`) AS `access`,
+                `t2`.`user_id`, `t2`.`parent_mode`
+              FROM (
+                SELECT `menus`.`id`, `menus`.`mode`, `menus`.`action`, `menu_locales`.`title`, `menu_locales`.`page_title`,
+                  `menu_locales`.`short_title`, `menus`.`position`, `menus`.`tab`, `menus`.`menu_id`, `menus`.`state`,
+                  `group_menus`.`access`, `user_groups`.`user_id`, `parent_menu`.`mode` AS `parent_mode`
+                FROM (`menus`, `group_menus`, `groups`, `user_groups`)
+                  LEFT JOIN `menu_locales` ON `menu_locales`.`menu_id` = `menus`.`id` AND `menu_locales`.`locale` = #{locale}
+                  LEFT JOIN `menus` AS `parent_menu` ON `menus`.`menu_id` = `parent_menu`.`id`
+                WHERE `menus`.`id` = `group_menus`.`menu_id` AND `menus`.`status` = 0 AND `group_menus`.`group_id` = `groups`.`id` AND
+                  `groups`.`id` = `user_groups`.`group_id` AND `user_groups`.`user_id` = #{self.current_user.id}
+                ) AS `t2`
+               GROUP BY `t2`.`id`, `t2`.`mode`, `t2`.`action`, `t2`.`title`, `t2`.`page_title`, `t2`.`short_title`,
+                  `t2`.`position`, `t2`.`tab`, `t2`.`menu_id`, `t2`.`state`, `t2`.`user_id`, `t2`.`parent_mode`) AS `t`
+               WHERE `t`.access IN (#{access}
+            )
+          ORDER BY `t`.`menu_id`, `t`.`position`
+          SQL
+          Anubis::Tenant::GroupMenu.find_by_sql(query).each do |data|
+            self.output.addElement({
+                                     mode: data.mode,
+                                     title: data.title,
+                                     page_title: data.page_title,
+                                     short_title: data.short_title,
+                                     position: data.position,
+                                     tab: data.tab,
+                                     action: data.action,
+                                     access: data.access,
+                                     state: Anubis::Tenant::Menu.states.invert[data.state],
+                                     parent: data.parent_mode
+                                   })
+            #self.output[:data].push menu_id[data.id.to_s.to_sym]
+          end
+
+          self.before_menu_output
+
+          respond_to do |format|
+            format.json { render json: around_menu_output(self.output.to_h) }
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,11 @@
+module Anubis
+  module Tenant
+    module Index
+      ##
+      # Module contains all callbacks {IndexController}.
+      module Callbacks
+        include Anubis::Core::Index::Callbacks
+      end
+    end
+  end
+end

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

@@ -0,0 +1,38 @@
+require_dependency "anubis/tenant/application_controller"
+require_dependency "anubis/tenant/index/actions"
+require_dependency "anubis/tenant/index/callbacks"
+
+module Anubis
+  ##
+  # Module presents all tenant functions for Anubis Library
+  module Tenant
+    ##
+    # Controller processes main system functions. Authenticates user, checks user access, outputs main menu and etc.
+    class IndexController < Anubis::Tenant::ApplicationController
+      include Anubis::Tenant::Index::Actions
+      include Anubis::Tenant::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/tenants_controller.rb

@@ -0,0 +1,7 @@
+module Anubis
+  ##
+  # Controller that shows and proccesses {Tenant} data
+  class TenantsController < DataController
+
+  end
+end

data/app/controllers/anoubis/users_controller.rb

@@ -0,0 +1,7 @@
+require_dependency "anoubis/application_controller"
+
+module Anubis
+  class UsersController < DataController
+
+  end
+end

data/app/jobs/anoubis/application_job.rb

@@ -0,0 +1,6 @@
+module Anoubis
+  ##
+  # Default jobs of Anoubis library
+  class ApplicationJob < ActiveJob::Base
+  end
+end

data/app/mailers/anoubis/application_mailer.rb

@@ -0,0 +1,8 @@
+module Anoubis
+  ##
+  # Default mailer for Anoubis library
+  class ApplicationMailer < ActionMailer::Base
+    default from: 'from@example.com'
+    layout 'mailer'
+  end
+end

data/app/models/anoubis/application_record.rb

@@ -0,0 +1,45 @@
+## Main application model record class inherited from {https://api.rubyonrails.org/classes/ActiveRecord/Base.html ActiveRecord::Base}
+class Anoubis::ApplicationRecord < ActiveRecord::Base
+  self.abstract_class = true
+
+  ## Redis database variable
+  attr_accessor :redis
+
+  ##
+  # Returns {https://github.com/redis/redis-rb Redis database} class
+  # @return [Class] {https://github.com/redis/redis-rb Redis} class reference
+  def redis
+    @redis ||= Redis.new
+  end
+
+  ##
+  # Returns {https://github.com/redis/redis-rb Redis database} class
+  # @return [Class] {https://github.com/redis/redis-rb Redis} class reference
+  def self.redis
+    Redis.new
+  end
+
+  ##
+  # Returns {https://github.com/redis/redis-rb Redis} prefix for storing cache data. Prefix can be set in Rails.configuration.anoubis_redis_prefix configuration parameter.
+  # @return [String] {https://github.com/redis/redis-rb Redis} prefix
+  def redis_prefix
+    begin
+      value = Rails.configuration.redis_prefix
+    rescue
+      return ''
+    end
+    return value + ':'
+  end
+
+  ##
+  # Returns {https://github.com/redis/redis-rb Redis} prefix for storing cache data. Prefix can be set in Rails.configuration.anoubis_redis_prefix configuration parameter.
+  # @return [String] {https://github.com/redis/redis-rb Redis} prefix
+  def self.redis_prefix
+    begin
+      value = Rails.configuration.redis_prefix
+    rescue
+      return ''
+    end
+    return value + ':'
+  end
+end

data/app/models/anoubis/core/application_record.rb

@@ -0,0 +1,250 @@
+##
+# Default ApplicationRecord for Anubis::Core library.
+class Anubis::Core::ApplicationRecord < ActiveRecord::Base
+  self.abstract_class = true
+
+  # @!attribute created_at
+  #   @return [DateTime] the date and time when item had been created
+
+  # @!attribute updated_at
+  #   @return [DateTime] the date and time when item had been updated
+
+  # @!attribute redis
+  #   @return [Object] pointer to Redis database
+  class_attribute :redis
+
+  # @!attribute [rw] current_user
+  #   @return [String] definition of current user for this record
+  attr_accessor :current_user
+
+  # @!attribute [rw] need_refresh
+  #   @return [Boolean] defines when table representation data should be updated even after simple update
+  class_attribute :need_refresh, default: false
+
+  # @!attribute [r] sys_title
+  attr_reader :sys_title
+
+  # @!attribute [r] can_new
+  attr_reader :can_new
+
+  # @!attribute [r] can_edit
+  attr_reader :can_edit
+
+  # @!attribute [r] can_delete
+  attr_reader :can_delete
+
+  after_initialize :after_initialize_core_anubis_model
+  before_validation :before_validation_core_anubis_model
+
+  public
+
+  ##
+  # Is called after initialization Anubis::Core ActiveRecord. Sets default parameters.
+  def after_initialize_core_anubis_model
+    self.need_refresh = false
+    self.redis = Redis.new
+    self.current_user = nil
+  end
+
+  ##
+  # Return defined locale according by I18n
+  def current_locale
+    I18n.locale.to_s
+  end
+
+  ##
+  # Checks if this record may be destroyed.
+  def can_destroy?
+    result = true
+    self.class.reflect_on_all_associations.all? do |assoc|
+      result = self.send(assoc.name).nil? if assoc.macro == :has_one
+      result = self.send(assoc.name).empty? if (assoc.macro == :has_many) && result
+    end
+    result
+  end
+
+  ##
+  # Returns the default ActiveRecord 'where' for defined model.
+  # @param object [ApplicationController] pointer to used Application controller
+  # @param pid [Integer] parent model id if present (default: 0). Variable doesn't necessary
+  # @return [Hash] ActiveRecord 'where' definition
+  def self.get_where(object, pid = 0)
+    { }
+  end
+
+  ##
+  # Returns model's system title. Default value is the row ID. For another result procedure should be overridden.
+  # @return [String] model's system title
+  def sys_title
+    self.id
+  end
+
+  ##
+  # Returns the ability to create new data. By default all items may be deleted. For another result
+  # procedure should be overridden.
+  # @return [Boolean] true if new data may be created.
+  def can_new(args = {})
+    true
+  end
+
+  ##
+  # Returns the ability to edit the data. By default all items may be edited. For another result
+  # procedure should be overridden.
+  # @return [Boolean] true if data may be edited
+  def can_edit(args = {})
+    true
+  end
+
+  ##
+  # Returns the ability to delete a data. By default all items may be deleted. For another result
+  # procedure should be overridden.
+  # @return [Boolean] true if data may be deleted
+  def can_delete(args = {})
+    true
+  end
+
+  ##
+  # Sets current locale and nullifies locale variable that presents model translation data.
+  # @param value [String] new locale value ('ru', 'en', etc)
+  def current_locale=(value)
+    @current_locale = value
+    @model_locale = nil
+  end
+
+  private
+
+  ##
+  # Is called before validation model's data. Sets user id of user that modify model's data
+  # (if updated_user_id field presents in database)
+  def before_validation_core_anubis_model
+    begin
+      self.updated_user_id = self.current_user.id if self.current_user
+    rescue
+
+    end
+  end
+
+  protected
+
+  ##
+  # Returns text that was converted for russian quotes.
+  # @param str [String] - source text
+  # @return [String] converted text
+  def convert_russian_quotes(str)
+    return str.gsub(/^"/, "«").gsub(/ "/, " «").gsub(/«"/, "««").gsub(/" /, "» ").gsub(/"$/, "»").gsub(/"»/, "»»")
+  end
+
+  ##
+  # @!group Block of UUID functions
+
+  ##
+  # Decodes binary UUID data into the UUID string
+  # @param data [Binary] binary representation of UUID
+  # @return [String, nil] string representation of UUID or nil if can't be decoded
+  def bin_to_uuid(data)
+    begin
+      data = data.unpack('H*')[0]
+      return data[0..7]+'-'+data[8..11]+'-'+data[12..15]+'-'+data[16..19]+'-'+data[20..31]
+    rescue
+      return nil
+    end
+  end
+
+  ##
+  # Encodes string UUID data into the binary UUID
+  # @param data [Binary] string representation of UUID
+  # @return [Binary, nil] binary representation of UUID or nil if can't be encoded
+  def uuid_to_bin(data)
+    begin
+      return [data.delete('-')].pack('H*')
+    rescue
+      return nil
+    end
+  end
+
+  public
+
+  ##
+  # Generates new UUID data
+  # @return [String] string representation of UUID
+  def new_uuid
+    SecureRandom.uuid
+  end
+
+  # @!endgroup
+
+  ##
+  # @!group Block of Redis functions
+
+  ##
+  # Returns defined application prefix for redis cache for current record. Default value ''
+  def redis_prefix
+    begin
+      value = Rails.configuration.redis_prefix
+    rescue
+      return ''
+    end
+    return value + ':'
+  end
+
+  ##
+  # Returns defined application prefix for redis cache for model. Default value ''
+  def self.redis_prefix
+    begin
+      value = Rails.configuration.redis_prefix
+    rescue
+      return ''
+    end
+    return value + ':'
+  end
+
+  ##
+  # Returns reference to Redis database
+  def self.redis
+    Redis.new
+  end
+
+  # @!endgroup
+
+  def get_locale
+    if self.current_locale && self.current_locale != ''
+      return self.current_locale
+    end
+
+    self.default_locale
+  end
+
+  def default_locale
+    Rails.configuration.i18n.default_locale.to_s
+  end
+
+  def get_locale_field(field, used_locale = nil)
+    field = field.to_s.to_sym
+    used_locale = self.current_locale.to_s unless used_locale
+
+    return '' unless self[field]
+    return self[field][used_locale] if self[field].key? used_locale
+    return '' unless self[field].key? self.default_locale.to_s
+
+    self[field][self.default_locale.to_s]
+  end
+
+  def set_locale_field(field, value, used_locale = nil)
+    field = field.to_s.to_sym
+    used_locale = self.current_locale.to_s unless used_locale
+
+    self[field] = {} unless self[field]
+    self[field][self.default_locale.to_s] = value unless self[field].key? self.default_locale.to_s
+    self[field][used_locale] = value
+  end
+
+  def is_field_localized(field, used_locale = nil)
+    field = field.to_s.to_sym
+    used_locale = self.current_locale.to_s unless used_locale
+
+    return false unless self[field]
+    return true if self[field].key? used_locale
+
+    false
+  end
+end

data/app/models/anoubis/core/locales.rb

@@ -0,0 +1,27 @@
+##
+# Defines all available locales.
+module Anoubis::Core::Locales
+  # List of all possible locales.
+  LIST = {
+    ru: { id: 1, name: 'Russian' },
+    en: { id: 2, name: 'English' },
+    kz: { id: 3, name: 'Kazakh' }
+  }.freeze
+
+  class << self
+    ##
+    # Returns the title of chosen locale
+    # @param key [String] identificator of locale ('ru', 'en', etc.)
+    # @return [String] english title of locale
+    def name(key)
+      LIST[key.to_sym][:name]
+    end
+
+    ##
+    # Converts list of locales into enum attribute
+    # @return [Symbol] return symbols array for all locales.
+    def enums
+      LIST.reduce({}) { |res, v| res.merge("#{v.first}": v.last[:id]) }
+    end
+  end
+end

data/app/models/anoubis/sso/client/application_record.rb

@@ -0,0 +1,3 @@
+class Anoubis::Sso::Client::ApplicationRecord < Anoubis::Core::ApplicationRecord
+  self.abstract_class = true
+end

data/app/models/anoubis/sso/client/group.rb

@@ -0,0 +1,19 @@
+class Anoubis::Sso::Client::Group < Anoubis::Sso::Client::ApplicationRecord
+  self.table_name = 'groups'
+
+  VALID_IDENT_REGEX = /\A[a-z]*\z/i
+
+  # @!attribute ident
+  #   @return [String] the group's identifier. Identifier consists of lowercase alphabetical symbols.
+  validates :ident, length: { minimum: 3, maximum: 50 }, uniqueness: { case_sensitive: false }, format: { with: VALID_IDENT_REGEX }
+
+  validates :title, presence: true, length: { maximum: 100 }
+
+  def title
+    get_locale_field 'title_locale'
+  end
+
+  def title=(value)
+    self.set_locale_field 'title_locale', value
+  end
+end