anoubis 1.0.0 → 1.0.8

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

@@ -1,9 +1,9 @@
-class Anubis::Tenant::ApplicationController < Anubis::Core::ApplicationController
+class Anoubis::Tenant::ApplicationController < Anoubis::Core::ApplicationController
   ##
   # Get current user model
   # @return [ActiveRecord] defined user model. It is used for get current user data. May be redefined when user model is changed
   def get_user_model
-    Anubis::Tenant::User
+    Anoubis::Tenant::User
   end
 
   ##
@@ -20,7 +20,7 @@ class Anubis::Tenant::ApplicationController < Anubis::Core::ApplicationControlle
     menu_access_status = redis.get self.redis_prefix + self.current_user.uuid+'_'+controller
 
     if !menu_access_status
-      access = Anubis::Tenant::GroupMenu.accesses[:read].to_s+','+Anubis::Tenant::GroupMenu.accesses[:write].to_s
+      access = Anoubis::Tenant::GroupMenu.accesses[:read].to_s+','+Anoubis::Tenant::GroupMenu.accesses[:write].to_s
       query = <<-SQL
           SELECT `t`.* FROM
             (SELECT `menus`.`id`, `menus`.`mode`, `menus`.`action`, `menus`.`menu_id`,
@@ -33,7 +33,7 @@ class Anubis::Tenant::ApplicationController < Anubis::Core::ApplicationControlle
             WHERE `t`.`access` IN (#{access})
             ORDER BY `t`.`menu_id`
       SQL
-      menu = Anubis::Tenant::GroupMenu.find_by_sql(query).first
+      menu = Anoubis::Tenant::GroupMenu.find_by_sql(query).first
       if (!menu)
         redis.set self.redis_prefix + self.current_user.uuid+'_'+controller, 'not'
         self.error_exit({ error: I18n.t('errors.access_not_allowed') }) if exit

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

@@ -1,10 +1,10 @@
-module Anubis
+module Anoubis
   module Tenant
     module Index
       ##
       # Module contains all basic actions for {IndexController}.
       module Actions
-        include Anubis::Core::Index::Actions
+        include Anoubis::Core::Index::Actions
 
         ##
         # <i>Login</i> action of index controller. Procedure checks user credential. If credentials are correct than user enters
@@ -28,7 +28,7 @@ module Anubis
         #
         # <b>Results:</b><br>
         #
-        # Resulting data is placed in self.output({Anubis::OutputLogin}) class and returns in JSON format.
+        # Resulting data is placed in self.output({Anoubis::OutputLogin}) class and returns in JSON format.
         #
         # <b>Examples:</b>
         #
@@ -48,18 +48,18 @@ module Anubis
         #     "message": "Incorrect user login or password"
         #   }
         def login
-          self.output = Anubis::Output::Login.new
+          self.output = Anoubis::Output::Login.new
           if params.has_key?(:login) && params.has_key?(:password)
-            user = Anubis::Tenant::User.where(login: params[:login].downcase, status: 0).first
+            user = Anoubis::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
+              tenant = Anoubis::Tenant::Tenant.where(state: Anoubis::Tenant::Tenant.states[:default]).first
+              user = Anoubis::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
+              tenant = Anoubis::Tenant::Tenant.find(1)
+              user = Anoubis::Tenant::User.where(login: (params[:login]+'.'+tenant.ident).downcase, status: 0).first
             end
 
             if user && user.authenticate(params[:password])
@@ -108,7 +108,7 @@ module Anubis
         #
         # <b>Results:</b><br>
         #
-        # Resulting data is placed in self.output({Anubis::Output::Menu}) variable and returns in JSON format.
+        # Resulting data is placed in self.output({Anoubis::Output::Menu}) variable and returns in JSON format.
         #
         # <b>Examples:</b>
         #
@@ -138,9 +138,9 @@ module Anubis
         #     "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]
+          self.output = Anoubis::Output::Menu.new
+          access = Anoubis::Tenant::GroupMenu.accesses[:read].to_s+','+Anoubis::Tenant::GroupMenu.accesses[:write].to_s
+          locale = Anoubis::Tenant::MenuLocale.locales[self.locale.to_s.to_sym]
           query = <<-SQL
           SELECT `t`.* FROM
             (
@@ -163,7 +163,7 @@ module Anubis
             )
           ORDER BY `t`.`menu_id`, `t`.`position`
           SQL
-          Anubis::Tenant::GroupMenu.find_by_sql(query).each do |data|
+          Anoubis::Tenant::GroupMenu.find_by_sql(query).each do |data|
             self.output.addElement({
                                      mode: data.mode,
                                      title: data.title,
@@ -173,7 +173,7 @@ module Anubis
                                      tab: data.tab,
                                      action: data.action,
                                      access: data.access,
-                                     state: Anubis::Tenant::Menu.states.invert[data.state],
+                                     state: Anoubis::Tenant::Menu.states.invert[data.state],
                                      parent: data.parent_mode
                                    })
             #self.output[:data].push menu_id[data.id.to_s.to_sym]

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

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

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

@@ -1,16 +1,16 @@
-require_dependency "anubis/tenant/application_controller"
-require_dependency "anubis/tenant/index/actions"
-require_dependency "anubis/tenant/index/callbacks"
+require_dependency "anoubis/tenant/application_controller"
+require_dependency "anoubis/tenant/index/actions"
+require_dependency "anoubis/tenant/index/callbacks"
 
-module Anubis
+module Anoubis
   ##
   # 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
+    class IndexController < Anoubis::Tenant::ApplicationController
+      include Anoubis::Tenant::Index::Actions
+      include Anoubis::Tenant::Index::Callbacks
 
       ##
       # Check if authentication required

data/app/models/anoubis/application_record.rb

@@ -24,7 +24,7 @@ class Anoubis::ApplicationRecord < ActiveRecord::Base
   # @return [String] {https://github.com/redis/redis-rb Redis} prefix
   def redis_prefix
     begin
-      value = Rails.configuration.redis_prefix
+      value = Rails.configuration.anoubis_redis_prefix
     rescue
       return ''
     end
@@ -36,10 +36,98 @@ class Anoubis::ApplicationRecord < ActiveRecord::Base
   # @return [String] {https://github.com/redis/redis-rb Redis} prefix
   def self.redis_prefix
     begin
-      value = Rails.configuration.redis_prefix
+      value = Rails.configuration.anoubis_redis_prefix
     rescue
       return ''
     end
     return value + ':'
   end
+
+  ##
+  # Return defined locale according by I18n
+  # @return [String] current locale
+  def current_locale
+    I18n.locale.to_s
+  end
+
+  ##
+  # Returns {current_locale}. If current locale isn't set then returns {default_locale}.
+  # @return [String] current locale
+  def get_locale
+    if current_locale && current_locale != ''
+      return current_locale
+    end
+
+    default_locale
+  end
+
+  ##
+  # Default locale that setup in Rails.configuration.i18n.default_locale configuration parameter
+  # @return [String] default locale
+  def default_locale
+    Rails.configuration.i18n.default_locale.to_s
+  end
+
+  ##
+  # Returns localized field by identifier
+  # @param field [String] Field identifier
+  # @param used_locale [String | nil] Locale identifier (by default used {current_locale})
+  # @return [String] localized field
+  def get_locale_field(field, used_locale = nil)
+    field = field.to_s.to_sym
+    used_locale = 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? default_locale.to_s
+
+    self[field][default_locale.to_s]
+  end
+
+  ##
+  # Sets localized data
+  # @param field [String] field identifier
+  # @param value [String] localized string
+  # @param used_locale [String | nil] Locale identifier (by default used {current_locale})
+  def set_locale_field(field, value, used_locale = nil)
+    field = field.to_s.to_sym
+    used_locale = current_locale.to_s unless used_locale
+
+    self[field] = {} unless self[field]
+    self[field][default_locale.to_s] = value unless self[field].key? default_locale.to_s
+    self[field][used_locale] = value
+  end
+
+  ##
+  # Returns true if field has localized data
+  # @param field [String] Field identifier
+  # @param used_locale [String | nil] Locale identifier (by default used {current_locale})
+  # @return [Boolean] true if field has localized data
+  def is_field_localized(field, used_locale = nil)
+    field = field.to_s.to_sym
+    used_locale = current_locale.to_s unless used_locale
+
+    return false unless self[field]
+    return true if self[field].key? used_locale
+
+    false
+  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 system title of table element
+  # @return [String] System title
+  def sys_title
+    id.to_s
+  end
 end

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

@@ -1,6 +1,6 @@
 ##
-# Default ApplicationRecord for Anubis::Core library.
-class Anubis::Core::ApplicationRecord < ActiveRecord::Base
+# Default ApplicationRecord for Anoubis::Core library.
+class Anoubis::Core::ApplicationRecord < ActiveRecord::Base
   self.abstract_class = true
 
   # @!attribute created_at
@@ -39,7 +39,7 @@ class Anubis::Core::ApplicationRecord < ActiveRecord::Base
   public
 
   ##
-  # Is called after initialization Anubis::Core ActiveRecord. Sets default parameters.
+  # Is called after initialization Anoubis::Core ActiveRecord. Sets default parameters.
   def after_initialize_core_anubis_model
     self.need_refresh = false
     self.redis = Redis.new

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

@@ -1,6 +1,6 @@
 ##
 # Model links {Menu} and {Group}. Describes group access to menu.
-class Anubis::Sso::Client::GroupMenu < Anubis::Sso::Client::ApplicationRecord
+class Anoubis::Sso::Client::GroupMenu < Anoubis::Sso::Client::ApplicationRecord
   # Redefines default table name
   self.table_name = 'group_menus'
 
@@ -12,12 +12,12 @@ class Anubis::Sso::Client::GroupMenu < Anubis::Sso::Client::ApplicationRecord
 
   # @!attribute group
   #   @return [Group] reference to the {Group} model
-  belongs_to :group, :class_name => 'Anubis::Sso::Client::Group'
+  belongs_to :group, :class_name => 'Anoubis::Sso::Client::Group'
   validates :group, presence: true, uniqueness: { scope: [:menu_id] }
 
   # @!attribute menu
   #   @return [Menu] reference to the {Menu} model
-  belongs_to :menu, :class_name => 'Anubis::Sso::Client::Menu'
+  belongs_to :menu, :class_name => 'Anoubis::Sso::Client::Menu'
   validates :menu, presence: true, uniqueness: { scope: [:group_id] }
 
   # @!attribute access
@@ -41,7 +41,7 @@ class Anubis::Sso::Client::GroupMenu < Anubis::Sso::Client::ApplicationRecord
   # doesn't present in database then adds this link to database with {#access} defined as 'read'.
   def after_create_sso_client_group_menu
     if self.menu.menu_id != nil
-      Anubis::Sso::Client::GroupMenu.find_or_create_by(menu_id: self.menu.menu_id, group_id: self.group_id) do |menu|
+      Anoubis::Sso::Client::GroupMenu.find_or_create_by(menu_id: self.menu.menu_id, group_id: self.group_id) do |menu|
         menu.access = 'read'
       end
     end
@@ -60,8 +60,8 @@ class Anubis::Sso::Client::GroupMenu < Anubis::Sso::Client::ApplicationRecord
   ##
   # Is called after link between menu and group had been deleted from database. It also deletes all child links.
   def after_destroy_sso_client_group_menu
-    Anubis::Sso::Client::Menu.select(:id).where(menu_id: self.menu_id).each do |menu|
-      Anubis::Sso::Client::GroupMenu.where(menu_id: menu.id, group_id: self.group_id).each do |group_menu|
+    Anoubis::Sso::Client::Menu.select(:id).where(menu_id: self.menu_id).each do |menu|
+      Anoubis::Sso::Client::GroupMenu.where(menu_id: menu.id, group_id: self.group_id).each do |group_menu|
         group_menu.destroy
       end
     end

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

@@ -1,4 +1,4 @@
-class Anubis::Sso::Client::Menu < Anubis::Sso::Client::ApplicationRecord
+class Anoubis::Sso::Client::Menu < Anoubis::Sso::Client::ApplicationRecord
   self.table_name = 'menus'
 
   before_create :before_create_sso_client_menu
@@ -31,8 +31,8 @@ class Anubis::Sso::Client::Menu < Anubis::Sso::Client::ApplicationRecord
 
   # @!attribute menu
   #   @return [Menu, nil] the parent menu for element menu (if exists).
-  belongs_to :menu, class_name: 'Anubis::Sso::Client::Menu', optional: true
-  has_many :menus, class_name: 'Anubis::Sso::Client::Menu'
+  belongs_to :menu, class_name: 'Anoubis::Sso::Client::Menu', optional: true
+  has_many :menus, class_name: 'Anoubis::Sso::Client::Menu'
 
   # @!attribute title
   #   @return [String] the menu's localized title.
@@ -82,13 +82,13 @@ class Anubis::Sso::Client::Menu < Anubis::Sso::Client::ApplicationRecord
   #     - 'hidden' --- element is hidden.
   enum state: { visible: 0, hidden: 1 }
 
-  has_many :group_menus, class_name: 'Anubis::Sso::Client::GroupMenu'
+  has_many :group_menus, class_name: 'Anoubis::Sso::Client::GroupMenu'
 
   ##
   # Is called before menu will be created in database. Sets {#position} as last {#position} + 1 on current {#tab}.
   # After this calls {#before_update_menu} for additional modification.
   def before_create_sso_client_menu
-    data = Anubis::Sso::Client::Menu.where(menu_id: self.menu_id).maximum(:position)
+    data = Anoubis::Sso::Client::Menu.where(menu_id: self.menu_id).maximum(:position)
     self.position = if data then data + 1 else 0 end
 
     self.before_update_sso_client_menu
@@ -104,7 +104,7 @@ class Anubis::Sso::Client::Menu < Anubis::Sso::Client::ApplicationRecord
     self.page_size = 20 if self.page_size == 0
     self.page_size = self.page_size.to_i
 
-    parent_menu = Anubis::Sso::Client::Menu.where(id: self.menu_id).first
+    parent_menu = Anoubis::Sso::Client::Menu.where(id: self.menu_id).first
     if parent_menu
       self.tab = parent_menu.tab + 1
     else
@@ -137,8 +137,8 @@ class Anubis::Sso::Client::Menu < Anubis::Sso::Client::ApplicationRecord
             SET menus.position = menus.position - 1
             WHERE menus.tab = #{self.tab} AND menus.position > #{self.position}
     SQL
-    Anubis::Sso::Client::Menu.connection.execute query
-    Anubis::Sso::Client::Menu.where(menu_id: self.id).find_each do |menu|
+    Anoubis::Sso::Client::Menu.connection.execute query
+    Anoubis::Sso::Client::Menu.where(menu_id: self.id).find_each do |menu|
       menu.destroy
     end
   end

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

@@ -1,4 +1,4 @@
-class Anubis::Sso::Client::User < Anubis::Sso::Client::ApplicationRecord
+class Anoubis::Sso::Client::User < Anoubis::Sso::Client::ApplicationRecord
   self.table_name = 'users'
 
   after_destroy :after_destroy_anubis_sso_client_user
@@ -64,7 +64,7 @@ class Anubis::Sso::Client::User < Anubis::Sso::Client::ApplicationRecord
 
   def get_menus
     self.menus = {}
-    access = Anubis::Sso::Client::GroupMenu.accesses[:read].to_s+','+Anubis::Sso::Client::GroupMenu.accesses[:write].to_s
+    access = Anoubis::Sso::Client::GroupMenu.accesses[:read].to_s+','+Anoubis::Sso::Client::GroupMenu.accesses[:write].to_s
     query = <<-SQL
           SELECT `menus`.`id`, `menus`.`mode`, MAX(`group_menus`.`access`) AS `access`
           FROM (`menus`, `group_menus`, `groups`, `user_groups`)
@@ -72,7 +72,7 @@ class Anubis::Sso::Client::User < Anubis::Sso::Client::ApplicationRecord
             `groups`.`id` = `user_groups`.`group_id` AND `user_groups`.`user_id` = #{self.id} 
           GROUP BY `menus`.`id`, `menus`.`mode`
     SQL
-    Anubis::Sso::Client::GroupMenu.find_by_sql(query).each do |data|
+    Anoubis::Sso::Client::GroupMenu.find_by_sql(query).each do |data|
       self.menus[data[:mode]] = data.access
     end
 

data/app/models/anoubis/sso/server/user.rb

@@ -1,4 +1,4 @@
-class Anubis::Sso::Server::User < Anubis::Core::ApplicationRecord
+class Anoubis::Sso::Server::User < Anoubis::Core::ApplicationRecord
   has_secure_password
 
   self.table_name = 'users'

data/app/models/anoubis/tenant/group_menu.rb

@@ -37,7 +37,7 @@ class Anoubis::Tenant::GroupMenu < Anoubis::Core::ApplicationRecord
       errors.add(:base, I18n.t('anubis.group_menus.errors.no_access'))
       throw(:abort, __method__)
     end
-    self.access = Anubis::Tenant::GroupMenu.accesses[:read] if !self.access
+    self.access = Anoubis::Tenant::GroupMenu.accesses[:read] if !self.access
   end
 
   ##
@@ -45,8 +45,8 @@ class Anoubis::Tenant::GroupMenu < Anoubis::Core::ApplicationRecord
   # doesn't present in database then adds this link to database with {#access} defined as 'read'.
   def after_create_group_menu
     if self.menu.menu_id != nil
-      Anubis::Tenant::GroupMenu.find_or_create_by(menu_id: self.menu.menu_id, group_id: self.group_id) do |menu|
-        menu.access = Anubis::Tenant::GroupMenu.accesses[:read]
+      Anoubis::Tenant::GroupMenu.find_or_create_by(menu_id: self.menu.menu_id, group_id: self.group_id) do |menu|
+        menu.access = Anoubis::Tenant::GroupMenu.accesses[:read]
       end
     end
     self.after_modify_group_menu
@@ -64,8 +64,8 @@ class Anoubis::Tenant::GroupMenu < Anoubis::Core::ApplicationRecord
   ##
   # Is called after link between menu and group had been deleted from database. It also deletes all child links.
   def after_destroy_group_menu
-    Anubis::Tenant::Menu.select(:id).where(menu_id: self.menu_id).each do |menu|
-      Anubis::Tenant::GroupMenu.where(menu_id: menu.id, group_id: self.group_id).each do |group_menu|
+    Anoubis::Tenant::Menu.select(:id).where(menu_id: self.menu_id).each do |menu|
+      Anoubis::Tenant::GroupMenu.where(menu_id: menu.id, group_id: self.group_id).each do |group_menu|
         group_menu.destroy
       end
     end

data/app/models/anoubis/tenant/menu.rb

@@ -1,7 +1,7 @@
 ##
 # Menu model. Stores information about all menu elements of the portal. Menu model defines the dependence
 # between controller and user access.
-class Anubis::Tenant::Menu < ApplicationRecord
+class Anoubis::Tenant::Menu < ApplicationRecord
   # Redefines default table name
   self.table_name = 'menus'
 
@@ -33,12 +33,12 @@ class Anubis::Tenant::Menu < ApplicationRecord
 
   # @!attribute menu
   #   @return [Menu, nil] the parent menu for element menu (if exists).
-  belongs_to :menu, class_name: 'Anubis::Tenant::Menu', optional: true
-  has_many :menus, class_name: 'Anubis::Tenant::Menu'
+  belongs_to :menu, class_name: 'Anoubis::Tenant::Menu', optional: true
+  has_many :menus, class_name: 'Anoubis::Tenant::Menu'
 
-  has_many :group_menus, class_name: 'Anubis::Tenant::GroupMenu'
-  has_many :system_menus, class_name: 'Anubis::Tenant::SystemMenu'
-  has_many :menu_locales, class_name: 'Anubis::Tenant::MenuLocale'
+  has_many :group_menus, class_name: 'Anoubis::Tenant::GroupMenu'
+  has_many :system_menus, class_name: 'Anoubis::Tenant::SystemMenu'
+  has_many :menu_locales, class_name: 'Anoubis::Tenant::MenuLocale'
 
   # @!attribute status
   #   @return ['enabled', 'disabled'] the status of menu element.
@@ -56,7 +56,7 @@ class Anubis::Tenant::Menu < ApplicationRecord
   # Is called before menu will be created in database. Sets {#position} as last {#position} + 1 on current {#tab}.
   # After this calls {#before_update_menu} for additional modification.
   def before_create_menu
-    data = Anubis::Tenant::Menu.where(menu_id: self.menu_id).maximum(:position)
+    data = Anoubis::Tenant::Menu.where(menu_id: self.menu_id).maximum(:position)
     self.position = if data then data + 1 else 0 end
 
     self.before_update_menu
@@ -72,7 +72,7 @@ class Anubis::Tenant::Menu < ApplicationRecord
     self.page_size = 20 if !self.page_size
     self.page_size = self.page_size.to_i
 
-    parent_menu = Anubis::Tenant::Menu.where(id: self.menu_id).first
+    parent_menu = Anoubis::Tenant::Menu.where(id: self.menu_id).first
     if parent_menu
       self.tab = parent_menu.tab + 1
     else
@@ -91,7 +91,7 @@ class Anubis::Tenant::Menu < ApplicationRecord
   # Is called before menu will be deleted from database. Checks the ability to destroy a menu. Delete
   # all translations for menu model from {MenuLocale}.
   def before_destroy_menu
-    Anubis::Tenant::MenuLocale.where(menu_id: self.id).each do |menu_locale|
+    Anoubis::Tenant::MenuLocale.where(menu_id: self.id).each do |menu_locale|
       menu_locale.destroy
     end
 
@@ -117,14 +117,14 @@ class Anubis::Tenant::Menu < ApplicationRecord
             SET menus.position = menus.position - 1
             WHERE menus.tab = #{self.tab} AND menus.position > #{self.position}
     SQL
-    Anubis::Tenant::Menu.connection.execute query
+    Anoubis::Tenant::Menu.connection.execute query
     #i = self.position
-    #Anubis::Tenant::Menu.where(menu_id: self.menu_id, position: (self.position+1..Float::INFINITY)).find_each do |menu|
+    #Anoubis::Tenant::Menu.where(menu_id: self.menu_id, position: (self.position+1..Float::INFINITY)).find_each do |menu|
     #        menu.position = i
     #        menu.save
     #        i += 1
     #      end
-    Anubis::Tenant::Menu.where(menu_id: self.id).find_each do |menu|
+    Anoubis::Tenant::Menu.where(menu_id: self.id).find_each do |menu|
       menu.destroy
     end
   end
@@ -133,7 +133,7 @@ class Anubis::Tenant::Menu < ApplicationRecord
   # Returns model localization data from {MenuLocale}.
   # @return [MenuLocale] localization for current menu
   def model_locale
-    @model_locale ||= self.menu_locales.where(locale: Anubis::Tenant::MenuLocale.locales[self.current_locale.to_sym]).first
+    @model_locale ||= self.menu_locales.where(locale: Anoubis::Tenant::MenuLocale.locales[self.current_locale.to_sym]).first
   end
 
   # @!attribute title

data/app/models/anoubis/tenant/system.rb

@@ -60,7 +60,7 @@ class Anoubis::Tenant::System < Anoubis::Core::ApplicationRecord
       data = Anoubis::Tenant::Group.find_or_create_by(ident: 'admin', system_id: self.id)
       I18n.available_locales.each do |locale|
         I18n.locale = locale
-        Anubis::Tenant::GroupLocale.find_or_create_by(group_id: data.id, locale: Anubis::Tenant::MenuLocale.locales[locale.to_s.to_sym]) do |system_locale|
+        Anoubis::Tenant::GroupLocale.find_or_create_by(group_id: data.id, locale: Anoubis::Tenant::MenuLocale.locales[locale.to_s.to_sym]) do |system_locale|
           system_locale.title = I18n.t('anubis.install.admins_group')
         end
       end
@@ -75,7 +75,7 @@ class Anoubis::Tenant::System < Anoubis::Core::ApplicationRecord
 
   ##
   # Is called after system had been updated. If {#ident} value had been changed then procedure updates
-  # every {Anubis::Group#full_ident} value.
+  # every {Anoubis::Group#full_ident} value.
   def after_update_system
     if self.ident_was != self.ident
       update_groups_full_ident self.id, self.ident
@@ -91,7 +91,7 @@ class Anoubis::Tenant::System < Anoubis::Core::ApplicationRecord
       throw(:abort, __method__)
     end
 
-    Anubis::Tenant::SystemLocale.where(system_id: self.id).each do |system_locale|
+    Anoubis::Tenant::SystemLocale.where(system_id: self.id).each do |system_locale|
       system_locale.destroy
     end
 
@@ -109,14 +109,14 @@ class Anoubis::Tenant::System < Anoubis::Core::ApplicationRecord
     query = <<-SQL
             UPDATE groups SET groups.full_ident = CONCAT('#{ident}.', groups.ident) WHERE groups.system_id = #{id}
     SQL
-    Anubis::Tenant::Group.connection.execute query
+    Anoubis::Tenant::Group.connection.execute query
   end
 
   ##
   # Returns model localization data from {SystemLocale}.
   # @return [SystemLocale] localization for current system
   def model_locale
-    @model_locale ||= self.system_locales.where(locale: Anubis::Tenant::SystemLocale.locales[self.current_locale.to_sym]).first
+    @model_locale ||= self.system_locales.where(locale: Anoubis::Tenant::SystemLocale.locales[self.current_locale.to_sym]).first
   end
 
   # @!attribute title

data/app/models/anoubis/tenant/user.rb

@@ -1,6 +1,6 @@
 ##
 # Main User model. Stores inforation about all users that can access to the portal.
-class Anubis::Tenant::User < ApplicationRecord
+class Anoubis::Tenant::User < ApplicationRecord
   # @!attribute patronymic
   #   @return [String] user's patronymic
 
@@ -70,8 +70,8 @@ class Anubis::Tenant::User < ApplicationRecord
 
   # @!attribute tenant
   #   @return [Tenant] the tenant that owns this user.
-  belongs_to :tenant, class_name: 'Anubis::Tenant::Tenant'
-  has_many :user_groups, class_name: 'Anubis::Tenant::UserGroup'
+  belongs_to :tenant, class_name: 'Anoubis::Tenant::Tenant'
+  has_many :user_groups, class_name: 'Anoubis::Tenant::UserGroup'
 
   has_one_attached :avatar
 
@@ -145,7 +145,7 @@ class Anubis::Tenant::User < ApplicationRecord
       throw(:abort, __method__)
     end
 
-    Anubis::Tenant::UserGroup.where(user_id: self.id).delete_all
+    Anoubis::Tenant::UserGroup.where(user_id: self.id).delete_all
   end
 
   ##