anoubis 1.0.0

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

@@ -0,0 +1,109 @@
+##
+# Model links {Menu} and {Group}. Describes group access to menu.
+class Anubis::Sso::Client::GroupMenu < Anubis::Sso::Client::ApplicationRecord
+  # Redefines default table name
+  self.table_name = 'group_menus'
+
+  before_validation :before_validation_sso_client_group_menu
+  after_create :after_create_sso_client_group_menu
+  before_update :before_update_sso_client_group_menu
+  after_destroy :after_destroy_sso_client_group_menu
+
+
+  # @!attribute group
+  #   @return [Group] reference to the {Group} model
+  belongs_to :group, :class_name => 'Anubis::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'
+  validates :menu, presence: true, uniqueness: { scope: [:group_id] }
+
+  # @!attribute access
+  #   @return ['not', 'read', 'write', 'disable'] group access to menu element.
+  #     - 'not' --- menu element doesn't available for this group
+  #     - 'read' --- group has access to menu element only for read data
+  #     - 'write' --- group has access to menu element for read and write data
+  #     - 'disable' --- group hasn't access to menu element
+  enum access: { not: 0, read: 20, write: 40, disable: 60 }
+
+  ##
+  # Is called before validation when the link between menu and group is being created or updated.
+  # Procedure checks if group belongs a system that has access to this menu element. If {#access} doesn't
+  # defined then {#access} sets to 'read'
+  def before_validation_sso_client_group_menu
+    self.access = 'read' if !self.access
+  end
+
+  ##
+  # Is called after new link between menu and group was created. If new element has parent with link that
+  # 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|
+        menu.access = 'read'
+      end
+    end
+    self.after_modify_sso_client_group_menu
+  end
+
+  ##
+  # Is called before link between menu and group will be updated. Procedure prevents changing {#menu}
+  # and {#group} value.
+  def before_update_sso_client_group_menu
+    self.menu_id = self.menu_id_was if self.menu_id_changed?
+    self.group_id = self.group_id_was if self.group_id_changed?
+    self.after_modify_sso_client_group_menu
+  end
+
+  ##
+  # 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|
+        group_menu.destroy
+      end
+    end
+    self.after_modify_sso_client_group_menu
+  end
+
+  ##
+  # Deletes all user's keys that belong this menu element in Redis database.
+  def after_modify_sso_client_group_menu
+    if self.redis
+      self.redis.keys(self.redis_prefix + '*_' + self.menu.mode).each do |data|
+        self.redis.del data
+      end
+    end
+  end
+
+  def title
+    self.get_localized_menu 'title'
+  end
+
+  def page_title
+    self.get_localized_menu 'page_title'
+  end
+
+  def short_title
+    self.get_localized_menu 'short_title'
+  end
+
+  def get_localized_menu(field)
+    loc_field = (field.to_s + '_locale').to_sym
+    begin
+      self[loc_field] = JSON.parse(self[loc_field]) if self[loc_field]
+    rescue
+
+    end
+
+    begin
+      result = self.get_locale_field loc_field.to_s
+    rescue
+      result = eval('self.menu.' + field.to_s)
+    end
+
+    result
+  end
+end

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

@@ -0,0 +1,145 @@
+class Anubis::Sso::Client::Menu < Anubis::Sso::Client::ApplicationRecord
+  self.table_name = 'menus'
+
+  before_create :before_create_sso_client_menu
+  before_update :before_update_sso_client_menu
+  before_save :before_save_sso_client_menu
+  before_destroy :before_destroy_sso_client_menu
+  after_destroy :after_destroy_sso_client_menu
+
+  VALID_IDENT_REGEX = /\A[a-z_\/0-9]*\z/i
+
+  # @!attribute mode
+  #   @return [String] the controller path for menu element.
+  validates :mode, length: { minimum: 3, maximum: 100 }, uniqueness: { case_sensitive: false }, format: { with: VALID_IDENT_REGEX }
+
+  # @!attribute action
+  #   @return [String] the default action of menu element ('data', 'menu', etc.).
+  validates :action, presence: true
+
+  # @!attribute tab
+  #   @return [Integer] the nesting level of menu element
+  validates :tab, presence: true, numericality: { only_integer: true, greater_than_or_equal_to: 0 }
+
+  # @!attribute position
+  #   @return [Integer] the order position of menu element in current level.
+  validates :position, presence: true, numericality: { only_integer: true, greater_than_or_equal_to: 0 }
+
+  # @!attribute page_size
+  #   @return [Integer] the default page size for table of data frame.
+  validates :page_size, numericality: { only_integer: true, greater_than_or_equal_to: 0 }
+
+  # @!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'
+
+  # @!attribute title
+  #   @return [String] the menu's localized title.
+  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
+
+  # @!attribute page_title
+  #   @return [String] the menu's localized page title. Uses in frontend application.
+  validates :page_title,  presence: true, length: { minimum: 3, maximum: 200 }
+
+  def page_title
+    get_locale_field 'page_title_locale'
+  end
+
+  def page_title=(value)
+    self.set_locale_field 'page_title_locale', value
+  end
+
+  # @!attribute short_title
+  #   @return [String] the menu's localized short title. Uses in frontend application.
+  validates :short_title,  length: { maximum: 200 }
+
+  def short_title
+    get_locale_field 'short_title_locale'
+  end
+
+  def short_title=(value)
+    self.set_locale_field 'short_title_locale', value
+  end
+
+  # @!attribute status
+  #   @return ['enabled', 'disabled'] the status of menu element.
+  #     - 'enabled' --- element is enabled and is used by the system.
+  #     - 'disabled' --- element is disabled and isn't used by the system.
+  enum status: { enabled: 0, disabled: 1 }
+
+  # @!attribute state
+  #   @return ['visible', 'hidden'] the visibility of menu element. Attribute is used in fronted application.
+  #     - 'visible' --- element is visible.
+  #     - 'hidden' --- element is hidden.
+  enum state: { visible: 0, hidden: 1 }
+
+  has_many :group_menus, class_name: 'Anubis::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)
+    self.position = if data then data + 1 else 0 end
+
+    self.before_update_sso_client_menu
+  end
+
+  ##
+  # Is called before menu will be stored in database. Sets {#mode} and {#action} in lowercase. If {#page_size}
+  # doesn't defined then sets it to 20. If defined parent menu element then sets {#tab} based on {#tab} of
+  # parent menu element + 1.
+  def before_update_sso_client_menu
+    self.mode = mode.downcase
+    self.action = self.action.downcase
+    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
+    if parent_menu
+      self.tab = parent_menu.tab + 1
+    else
+      self.tab = 0
+    end
+  end
+
+  ##
+  # Is called right before menu will be stored in database (after {#before_create_menu} and {#before_update_menu}).
+  # Deletes cache data for this menu in Redis database.
+  def before_save_sso_client_menu
+    self.redis.del(self.redis_prefix + 'menu:' + self.mode) if self.redis
+  end
+
+  ##
+  # 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_sso_client_menu
+    if !self.can_destroy?
+      errors.add(:base, I18n.t('anubis.menus.errors.has_childs'))
+      throw(:abort, __method__)
+    end
+  end
+
+  ##
+  # Is called after menu was deleted from database. Procedure recalculates position of other menu elements.
+  def after_destroy_sso_client_menu
+    query = <<-SQL
+            UPDATE menus
+            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|
+      menu.destroy
+    end
+  end
+end

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

@@ -0,0 +1,81 @@
+class Anubis::Sso::Client::User < Anubis::Sso::Client::ApplicationRecord
+  self.table_name = 'users'
+
+  after_destroy :after_destroy_anubis_sso_client_user
+  after_save :after_save_anubis_sso_client_user
+
+  attr_accessor :name
+  attr_accessor :surname
+  attr_accessor :locale
+  attr_accessor :timeout
+  attr_accessor :timezone
+  attr_accessor :menus
+
+  def save_cache(sso_data)
+    if sso_data
+      self.name = sso_data[:name] if sso_data.key? :name
+      self.surname = sso_data[:surname] if sso_data.key? :surname
+      self.locale = sso_data[:locale] if sso_data.key? :locale
+      self.timeout = sso_data[:timeout] if sso_data.key? :timeout
+      self.timezone = sso_data[:timezone] if sso_data.key? :timezone
+    end
+    self.redis.set(self.redis_prefix + 'user:' + self.uuid, self.to_json) if self.redis
+  end
+
+  def clear_cache
+    self.redis.del(self.redis_prefix + 'user:' + self.uuid) if self.redis
+  end
+
+  def self.load_cache(redis, uuid)
+    begin
+      data = JSON.parse redis.get(User.redis_prefix + 'user:' + uuid), { symbolize_names: true }
+    rescue
+      data = nil
+    end
+
+    unless data
+      user = self.where(uuid: uuid).first
+      if user
+        return JSON.parse(user.to_json(except: [:password_digest]), { symbolize_names: true })
+      end
+    end
+
+    data
+  end
+
+  def attributes
+    super.merge({
+      name: self.name,
+      surname: self.surname,
+      locale: self.locale,
+      timeout: self.timeout,
+      timezone: self.timezone,
+      menus: self.get_menus
+    })
+  end
+
+  def after_save_anubis_sso_client_user
+    self.clear_cache
+  end
+
+  def after_destroy_anubis_sso_client_user
+    self.clear_cache
+  end
+
+  def get_menus
+    self.menus = {}
+    access = Anubis::Sso::Client::GroupMenu.accesses[:read].to_s+','+Anubis::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`)
+          WHERE `menus`.`status` = 0 AND `menus`.`id` = `group_menus`.`menu_id` AND `group_menus`.`access` IN (#{access}) AND `group_menus`.`group_id` = `groups`.`id` AND
+            `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|
+      self.menus[data[:mode]] = data.access
+    end
+
+    self.menus
+  end
+end

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

@@ -0,0 +1,32 @@
+##
+# UserGroup model. It links User and Group models.
+class Anoubis::Sso::Client::UserGroup < Anoubis::Sso::Client::ApplicationRecord
+  self.table_name = 'user_groups'
+
+  before_update :before_update_sso_client_user_group
+  after_create :after_modify_sso_client_user_group
+  after_destroy :after_modify_sso_client_user_group
+
+  belongs_to :group, class_name: 'Anoubis::Sso::Client::Group'
+  validates :group, presence: true, uniqueness: { scope: [:user_id] }
+  belongs_to :user, class_name: 'Anoubis::Sso::Client::User'
+  validates :user, presence: true, uniqueness: { scope: [:group_id] }
+
+  ##
+  # Can't change elements
+  def before_update_sso_client_user_group
+    self.user_id = self.user_id_was if self.user_id_changed?
+    self.group_id = self.group_id_was if self.group_id_changed?
+  end
+
+  ##
+  # Delete all redis keys of menu for defined user
+  def after_modify_sso_client_user_group
+    if self.redis
+      self.redis.keys(self.redis_prefix + self.user.uuid.to_s + '_*').each do |data|
+        self.redis.del data
+      end
+      self.redis.del self.redis_prefix + 'user:' + self.user.uuid.to_s
+    end
+  end
+end

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

@@ -0,0 +1,36 @@
+class Anoubis::Sso::Server::System < Anoubis::Core::ApplicationRecord
+  self.table_name = 'systems'
+
+  before_validation :before_validation_anoubis_sso_server_system_on_create, on: :create
+  after_save :after_save_anoubis_sso_server_system
+  after_destroy :after_destroy_anoubis_sso_server_system
+
+  #VALID_HTTP_REGEX = /\A(https?:\/\/)?([\da-z\.-]+)\.([a-z\.]{2,6})([\/\w\.-]*)*\/?\Z/i
+
+  validates :title, presence: true, length: { maximum: 100 }
+  validates :host, presence: true, length: { maximum: 200 }#, format: { with: VALID_HTTP_REGEX }
+  validates :uuid, presence: true, length: { maximum: 40 }, uniqueness: { case_sensitive: true }
+
+  enum status: { enabled: 0, disabled: 1 }
+
+  def before_validation_anoubis_sso_server_system_on_create
+    self.uuid = SecureRandom.uuid unless self.uuid
+    self.secret_key = SecureRandom.uuid unless self.secret_key
+  end
+
+  def after_save_anoubis_sso_server_system
+    if self.status == 'enabled'
+      self.redis.set self.redis_cache_name, { host: self.host, secret_key: self.secret_key, callback: self.callback, silent: self.silent }.to_json
+    else
+      self.after_destroy_system
+    end
+  end
+
+  def after_destroy_anubis_sso_server_system
+    self.redis.del self.redis_cache_name
+  end
+
+  def redis_cache_name
+    self.redis_prefix + 'system:' + self.uuid
+  end
+end

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

@@ -0,0 +1,79 @@
+class Anubis::Sso::Server::User < Anubis::Core::ApplicationRecord
+  has_secure_password
+
+  self.table_name = 'users'
+
+  before_validation :before_validation_anubis_sso_server_user_on_create, on: :create
+  before_save :before_save_anubis_sso_server_user
+  after_destroy :after_destroy_anubis_sso_server_user
+
+  VALID_EMAIL_REGEX = /\A[\w+\-.]+@[a-z\d\-.]+\.[a-z]+\z/i
+
+  validates :login, presence: true, length: { maximum: 50 },
+            format: { with: VALID_EMAIL_REGEX },
+            uniqueness: { case_sensitive: true }
+
+  validates :name, presence: true, length: { maximum: 100 }
+  validates :surname, presence: true, length: { maximum: 100 }
+
+  validates :password, length: { in: 5..30 }, on: [:create]
+  validates :password, length: { in: 5..30 }, on: [:update], if: :password_changed?
+  validates :password_confirmation, length: { in: 5..30 }, on: [:create]
+  validates :password_confirmation, length: { in: 5..30 }, on: [:update], if: :password_changed?
+
+  validates :auth_key, length: { maximum: 32 }
+
+  validates :timeout, presence: true, numericality: { only_integer: true, greater_than_or_equal_to: 300 }
+
+  validates :uuid, presence: true, length: { maximum: 40 }, uniqueness: { case_sensitive: true }
+
+  enum status: { pending: 0, enabled: 1, disabled: 100 }
+  validates :status, inclusion: { in: self.statuses }
+
+  enum role: { user_role: 0, admin_role: 100 }
+  validates :role, inclusion: { in: self.roles }
+
+  def before_validation_anubis_sso_server_user_on_create
+    self.uuid = SecureRandom.uuid
+    self.timezone = 'GMT' if !self.timezone
+  end
+
+  def before_save_anubis_sso_server_user
+    self.timezone = 'GMT' if !self.timezone
+    self.login = self.login.downcase
+    self.clear_cache
+  end
+
+  def after_destroy_anubis_sso_server_user
+    self.clear_cache
+  end
+
+  def save_cache
+    self.redis.set(self.redis_prefix + 'user:' + self.uuid, self.to_json(except: [:password_digest])) if self.redis
+  end
+
+  def clear_cache
+    self.redis.del(self.redis_prefix + 'user:' + self.uuid) if self.redis
+  end
+
+  def password_changed?
+    !password.blank?
+  end
+
+  def self.load_cache(redis, uuid)
+    begin
+      data = JSON.parse redis.get(User.redis_prefix + 'user:' + uuid), { symbolize_names: true }
+    rescue
+      data = nil
+    end
+
+    unless data
+      user = self.where(uuid: uuid).first
+      if user
+        return JSON.parse(user.to_json(except: [:password_digest]), { symbolize_names: true })
+      end
+    end
+
+    data
+  end
+end

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

@@ -0,0 +1,41 @@
+##
+# Default ApplicationRecord for Anoubis::Core library.
+class Anoubis::Tenant::ApplicationRecord < Anoubis::Core::ApplicationRecord
+  self.abstract_class = true
+
+  before_update :before_update_tenant_anoubis_model
+  before_create :before_create_tenant_anoubis_model
+
+  ##
+  # 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)
+    if self.has_attribute? :tenant_id
+      return { tenant_id: object.current_user.tenant_id }
+    else
+      return {}
+    end
+  end
+
+  ##
+  # Is called before data will be updated in database. Prevents changing tenant
+  def before_update_tenant_anoubis_model
+    begin
+      self.tenant_id = self.tenant_id_was
+    rescue
+
+    end
+  end
+
+  ##
+  # Is called before data will be created in database. Sets tenant according by current user
+  def before_create_tenant_anoubis_model
+    begin
+      self.tenant_id = self.current_user.tenant_id
+    rescue
+
+    end
+  end
+end

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

@@ -0,0 +1,95 @@
+##
+# Group model. Stores information about usser's groups
+class Anoubis::Tenant::Group < Anoubis::Core::ApplicationRecord
+  # Redefines default table name
+  self.table_name = 'groups'
+
+  before_validation :before_validation_group_create, on: :create
+  before_validation :before_validation_group_update, on: :update
+  before_save :before_save_group
+  before_destroy :before_destroy_group
+
+  # Group's identifier consists of lowercase alphabetic symbols.
+  VALID_IDENT_REGEX = /[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: { scope: [:system_id], case_sensitive: false }, format: { with: VALID_IDENT_REGEX }
+
+  # @!attribute full_ident
+  #   @return [String] the calculated group's identification. This identification based on {System#ident} and {#ident}
+
+  # @!attribute system
+  #   @return [System] reference to system that owns this group
+  belongs_to :system, class_name: 'Anoubis::Tenant::System'
+
+  has_many :group_menus, class_name: 'Anoubis::Tenant::GroupMenu'
+  has_many :user_groups, class_name: 'Anoubis::Tenant::UserGroup'
+  has_many :group_locales, class_name: 'Anoubis::Tenant::GroupLocale'
+
+  ##
+  # Is called before validation when new group is being created. Sets {#ident} value as 'admin' and {#system}
+  # value to main system with id 1 if this is a first group.
+  def before_validation_group_create
+    if self.id
+      if self.id == 1
+        self.ident = 'admin'
+        self.system_id = 1
+        return true
+      end
+    end
+  end
+
+  ##
+  # Is called before validation when group is being updated. Prevents changing {#ident} value when {#ident}
+  # value is 'admin'
+  def before_validation_group_update
+    if self.ident != self.ident_was && self.ident_was == 'admin'
+      errors.add(:ident, I18n.t('tims.groups.errors.cant_change_admin_ident'))
+      throw(:abort, __method__)
+    end
+  end
+
+  ##
+  # Is called before group will be stored in database. Changes {#ident} value to lower case.
+  def before_save_group
+    self.full_ident = self.system.ident+'.'+self.ident
+  end
+
+  ##
+  # Is called before group will be deleted from database. Checks the ability to destroy a group. Prevents deleting
+  # group with id 1. Also destroys all associated links to {User} and {Menu}
+  def before_destroy_group
+    # Can't destroy admin group of main system
+    if self.ident == 'admin' && self.system_id == 1
+      errors.add(:base, I18n.t('anubis.groups.errors.cant_destroy_admin_group'))
+      throw(:abort, __method__)
+    end
+
+    Anoubis::Tenant::GroupLocale.where(group_id: self.id).each do |group_locale|
+      group_locale.destroy
+    end
+
+    unless user_groups.empty?
+      errors.add(:base, I18n.t('anubis.groups.errors.cant_destroy_group_with_users'))
+      throw(:abort, __method__)
+    end
+
+    # Before destroy group delete all associated links to users and menus
+    Anoubis::Tenant::GroupMenu.where(group_id: self.id).delete_all
+    #Anoubis::Tenant::UserGroup.where(group_id: self.id).delete_all
+  end
+
+  ##
+  # Returns model localization data from {GroupLocale}.
+  # @return [GroupLocale] localization for current group
+  def model_locale
+    @model_locale ||= self.group_locales.where(locale: Anoubis::Tenant::GroupLocale.locales[self.current_locale.to_sym]).first
+  end
+
+  # @!attribute title
+  # @return [String] the group's title. Title loads from {GroupLocale#title} based on {#current_locale}
+  def title
+    self.model_locale.title if self.model_locale
+  end
+end

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

@@ -0,0 +1,19 @@
+##
+# Localization for {Group} model. Model stores all translations for {Group} model.
+class Anoubis::Tenant::GroupLocale < Anoubis::Core::ApplicationRecord
+  # Redefines default table name
+  self.table_name = 'group_locales'
+
+  # @!attribute title
+  #   @return [String] the group's localized title
+  validates :title, length: { minimum: 3, maximum: 100 }
+
+  # @!attribute menu
+  #   @return [Group] reference to the {Group} model
+  belongs_to :group, :class_name => 'Anoubis::Tenant::Group'
+  validates :group, presence: true, uniqueness: { scope: [:locale] }
+
+  # @!attribute locale
+  #   @return [Locales] reference to locale
+  enum locale: Anoubis::Core::Locales.enums
+end