anoubis 1.0.0

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

@@ -0,0 +1,220 @@
+module Anubis
+  module Output
+    ##
+    # Output subclass that represents data for menu action
+    class Menu < Basic
+      # @!attribute [rw] items
+      #   @return [Array] the array of menu elements {Anubis::Output::MenuItem}.
+      class_attribute :items
+
+      # @!attribute [rw] keys
+      #   @return [Hash] the hash of menu elements {Anubis::Output::MenuItem} with 'mode' as a key.
+      class_attribute :keys
+
+      # @!attribute [rw] user
+      #   @return [Hash] the hash of user information.
+      class_attribute :user
+
+      ##
+      # Initializes menu output data. Generates default values.
+      def initialize
+        super
+        self.items = []
+        self.keys = {}
+        self.user = {}
+      end
+
+      ##
+      # Adds new element into menu hash
+      # @param [Hash] options the menu element options
+      # @option options [String] :title The title of the menu element.
+      # @option options [String] :page_title The page title of the menu element.
+      # @option options [String] :short_title The short title of the menu element.
+      # @option options [String] :mode The mode of the menu element.
+      # @option options [String] :action The action type of the menu element ('menu', 'data').
+      # @option options [Number] :position The position of the menu element in current level.
+      # @option options [Number] :tab The level of the menu element.
+      # @option options [String] :state The show state of the menu element ('visible', 'hidden').
+      # @option options [String] :access The access to the menu element for current user ('read', 'write').
+      def addElement(options)
+        if options.has_key? :parent
+          if !self.keys.has_key? options[:parent].to_s.to_sym
+            options[:parent] = nil
+          end
+        end
+        menu = MenuItem.new options
+        self.items.push menu
+        self.keys[menu.mode.to_s.to_sym] = self.items[self.items.count-1]
+      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[:menu] = []
+        self.items.each { |item|
+          result[:menu].push(item.to_h) if item
+        }
+        result[:user] = self.user
+        result
+      end
+
+      ##
+      # Generates output message based on {#result self.result} variable.
+      # @return [String] output message
+      def message
+        case self.result
+        when 0
+          return I18n.t('success')
+        else
+          return I18n.t('invalid_menu_output')
+        end
+      end
+
+      ##
+      # Returns menu element
+      # @param mode [String] the mode of returned menu element
+      # @return [MenuItem | nil] menu element or nil if element isn't exists
+      def key(mode)
+        if self.keys.has_key? mode.to_s.to_sym
+
+          return self.keys[mode.to_s.to_sym]
+        else
+          return nil
+        end
+      end
+    end
+
+    ##
+    # Subclass of menu element.
+    class MenuItem
+      # @!attribute [rw] mode
+      #   @return [String] the mode of the menu element. Identificator represents path of controller.
+      class_attribute :mode
+
+      # @!attribute [rw] title
+      #   @return [String] the title of the menu element.
+      class_attribute :title
+
+      # @!attribute [rw] page_title
+      #   @return [String] the page title of the menu element. Uses for show in page title.
+      class_attribute :page_title
+
+      # @!attribute [rw] short_title
+      #   @return [String] the short title of the menu element. Uses for short menu link.
+      class_attribute :short_title
+
+      # @!attribute [rw] position
+      #   @return [Number] the position of the menu element in current level.
+      class_attribute :position
+
+      # @!attribute [rw] tab
+      #   @return [Number] the level of the menu element.
+      class_attribute :tab
+
+      # @!attribute [rw] action
+      #   @return [String] the action type of the menu element ('menu', 'data').
+      class_attribute :action
+
+      # @!attribute [rw] access
+      #   @return [String] the access to the menu element for current user ('read', 'write').
+      class_attribute :access
+
+      # @!attribute [rw] state
+      #   @return [String] the show state of the menu element ('visible', 'hidden').
+      class_attribute :state
+
+      # @!attribute [rw] parent
+      #   @return [String] the mode of parent menu of the menu element when tab more then 0.
+      class_attribute :parent
+
+      ##
+      # Initializes menu element data. Generates default values.
+      def initialize(options = {})
+        if options.has_key? :mode
+          self.mode = options[:mode]
+        else
+          self.mode = ''
+        end
+
+        if options.has_key? :title
+          self.title = options[:title]
+        else
+          self.title = ''
+        end
+
+        if options.has_key? :page_title
+          self.page_title = options[:page_title]
+        else
+          self.page_title = ''
+        end
+
+        if options.has_key? :short_title
+          self.short_title = options[:short_title]
+        else
+          self.short_title = ''
+        end
+
+        if options.has_key? :position
+          self.position = options[:position]
+        else
+          self.position = 0
+        end
+
+        if options.has_key? :tab
+          self.tab = options[:tab]
+        else
+          self.tab = 0
+        end
+
+        if options.has_key? :action
+          self.action = options[:action]
+        else
+          self.action = 'data'
+        end
+
+        if options.has_key? :access
+          self.access = options[:access]
+        else
+          self.access = 'read'
+        end
+
+        if options.has_key? :state
+          self.state = options[:state]
+        else
+          self.state = 'visible'
+        end
+
+        if options.has_key? :parent
+          if options[:parent]
+            self.parent = options[:parent]
+          else
+            self.parent = ''
+          end
+        else
+          self.parent = ''
+        end
+      end
+
+      ##
+      # Generates hash representation of output class
+      # @return [Hash] hash representation of all data
+      def to_h
+        {
+            mode: self.mode,
+            title: self.title,
+            page_title: self.page_title,
+            short_title: self.short_title,
+            position: self.position,
+            tab: self.tab,
+            action: self.action,
+            access: self.access,
+            state:self.state,
+            parent: self.parent
+        }
+      end
+    end
+  end
+end

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

@@ -0,0 +1,43 @@
+module Anubis
+  module Output
+    ##
+    # Output subclass that represents data for update or create action
+    class Update < Basic
+      # @!attribute [rw]
+      # @return [Hash] the hash of defined fields.
+      class_attribute :values, default: {}
+
+      # @!attribute [rw]
+      # @return [Array<String>] hash of errors
+      class_attribute :errors, default: []
+
+      # @!attribute [rw]
+      # @return [String] resulting post action
+      class_attribute :action, default: ''
+
+      ##
+      # Initializes menu output data. Generates default values.
+      def initialize
+        super
+        self.values = {}
+        self.errors = []
+        self.action = ''
+        self.messages[:'-3'] = I18n.t('errors.update_error')
+      end
+
+      ##
+      # Generates hash representation of output class
+      # @return [Hash] hash representation of all data
+      def to_h
+        result = super.to_h
+        result[:errors] = self.errors if self.errors.length > 0
+        return result if self.result != 0
+        result.merge!({
+                          values: self.values,
+                          action: self.action
+                      })
+        result
+      end
+    end
+  end
+end

data/app/controllers/anoubis/sso/client/application_controller.rb

@@ -0,0 +1,139 @@
+class Anubis::Sso::Client::ApplicationController < Anubis::Core::ApplicationController
+
+  def sso_server
+    Rails.configuration.sso_server
+  end
+
+  def sso_system_uuid
+    Rails.configuration.sso_system_uuid
+  end
+
+  def sso_system_secret
+    Rails.configuration.sso_system_secret
+  end
+
+  def user_model
+    begin
+      model = Rails.configuration.user_model.classify.constantize
+    rescue
+      model = Anubis::Sso::Server::User
+    end
+
+    model
+  end
+
+  def authentication
+    if !self.token
+      self.error_exit({ error: I18n.t('errors.authentication_required') })
+      return false
+    end
+
+    session = self.redis.get(self.redis_prefix + 'session:' + self.token)
+
+    if !session
+      session = self.get_session_from_sso_server self.token
+    else
+      session = JSON.parse(session,{ symbolize_names: true })
+    end
+
+    if !session
+      self.error_exit({ error: I18n.t('errors.authentication_required') })
+      return false
+    end
+
+    if session[:update].to_datetime + 300.seconds < Time.now
+      session = self.get_session_from_sso_server self.token
+    end
+
+    if !session
+      self.redis.del self.redis_prefix + 'session:' + self.token
+      self.error_exit({ error: I18n.t('errors.authentication_required') })
+      return false
+    end
+
+    if session[:time].to_datetime + session[:timeout].to_f / 86400 < Time.now
+      self.redis.del self.redis_prefix + 'session:' + self.token
+      self.error_exit({ error: I18n.t('errors.authentication_required') })
+      return false
+    end
+
+    session[:time] = Time.now
+
+    self.redis.set(self.redis_prefix + 'session:' + self.token, session.to_json, ex: session[:timeout])
+
+    begin
+      self.current_user = self.user_model.new(self.user_model.load_cache(self.redis, session[:uuid]))
+    rescue
+      self.current_user = nil
+    end
+
+    true
+  end
+
+  def get_session_from_sso_server(session)
+    #require 'rest-client'
+
+    #session = JSON.parse(RestClient.get(self.sso_server + 'api/1/login/' + session + '?sso_system=' + self.sso_system_uuid + '&secret_key=' + self.sso_system_secret + '&locale=' + self.locale), { symbolize_names: true })
+    begin
+      ses_data = JSON.parse(RestClient.get(self.sso_server + 'api/1/login/' + session + '?sso_system=' + self.sso_system_uuid + '&secret_key=' + self.sso_system_secret + '&locale=' + self.locale), { symbolize_names: true })
+    rescue
+      return nil
+    end
+
+    return nil if ses_data[:result] != 0
+
+
+    user_data = self.get_user_data_by_uuid ses_data[:uuid], ses_data, true
+
+
+    return {
+      uuid: user_data.uuid,
+      login: ses_data[:login_time],
+      time: Time.now,
+      timeout: user_data.timeout,
+      update: Time.now
+    }
+  end
+
+  ##
+  # Returns user data by UUI
+  def get_user_data_by_uuid(uuid, sso_data = nil, force = false)
+    unless force
+      begin
+        user_data = self.user_model.new(JSON.parse(self.redis.get(self.redis_prefix + 'user:' + uuid), { symbolize_names: true }))
+      rescue
+        user_data = nil
+      end
+    end
+
+    unless user_data
+      user_data = self.user_model.find_or_create_by(uuid: uuid)
+
+      user_data.save_cache(sso_data) if user_data
+    end
+
+    user_data
+  end
+
+  ##
+  # Return access status for current user
+  def menu_access(controller, exit = true)
+    menu_access_status = 'not'
+
+    if self.current_user
+      if self.current_user.menus
+        if self.current_user.menus.key? controller.to_s.to_sym
+          menu_access_status = self.current_user.menus[controller.to_s.to_sym]
+        end
+      end
+    end
+
+    if menu_access_status == 'not'
+      self.error_exit({ error: I18n.t('errors.access_not_allowed') }) if exit
+      return false
+    end
+
+    self.writer = true if menu_access_status == 'write'
+    true
+  end
+end

data/app/controllers/anoubis/sso/client/data/actions.rb

@@ -0,0 +1,5 @@
+##
+# Module presents all default actions for for {DataController}.
+module Anubis::Sso::Client::Data::Actions
+  include Anubis::Core::Data::Actions
+end

data/app/controllers/anoubis/sso/client/data/callbacks.rb

@@ -0,0 +1,5 @@
+##
+# Module presents all callbacks called in actions.
+module Anubis::Sso::Client::Data::Callbacks
+  include Anubis::Core::Data::Callbacks
+end

data/app/controllers/anoubis/sso/client/data/convert.rb

@@ -0,0 +1,5 @@
+##
+# Data conversion moule between database and human representation
+module Anubis::Sso::Client::Data::Convert
+  include Anubis::Core::Data::Convert
+end

data/app/controllers/anoubis/sso/client/data/defaults.rb

@@ -0,0 +1,5 @@
+##
+# Module sets default parameters for {DataController}.
+module Anubis::Sso::Client::Data::Defaults
+  include Anubis::Core::Data::Defaults
+end

data/app/controllers/anoubis/sso/client/data/get.rb

@@ -0,0 +1,5 @@
+##
+# Module gets system data for {DataController}
+module Anubis::Sso::Client::Data::Get
+  include Anubis::Core::Data::Get
+end

data/app/controllers/anoubis/sso/client/data/load.rb

@@ -0,0 +1,26 @@
+##
+# Module loads data from external sources for {Anubis::Sso::Client::DataController}
+module Anubis::Sso::Client::Data::Load
+  include Anubis::Core::Data::Load
+
+  def load_menu_data
+    menu_json = self.redis.get(self.redis_prefix + 'menu:' + params[:controller])
+
+    unless menu_json
+      menu = Anubis::Sso::Client::Menu.where(mode: params[:controller], status: 'enabled').first
+      self.redis.set(self.redis_prefix + 'menu:'+ params[:controller], menu.to_json) if menu
+    else
+      menu = Anubis::Sso::Client::Menu.new(JSON.parse(menu_json,  { :symbolize_names => true }))
+    end
+
+    if menu
+      self.etc.menu = Anubis::Etc::Menu.new menu
+
+      if self.writer
+        self.etc.menu.access = 'write'
+      else
+        self.etc.menu.access = 'read'
+      end
+    end
+  end
+end

data/app/controllers/anoubis/sso/client/data/set.rb

@@ -0,0 +1,5 @@
+##
+# Module sets system data for {DataController}
+module Anubis::Sso::Client::Data::Set
+  include Anubis::Core::Data::Set
+end

data/app/controllers/anoubis/sso/client/data/setup.rb

@@ -0,0 +1,5 @@
+##
+# Module setups system parameters for {DataController}
+module Anubis::Sso::Client::Data::Setup
+  include Anubis::Core::Data::Setup
+end

data/app/controllers/anoubis/sso/client/data_controller.rb

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

data/app/controllers/anoubis/sso/client/index/actions.rb

@@ -0,0 +1,79 @@
+module Anubis::Sso::Client::Index::Actions
+  def menu
+    self.output = Anubis::Output::Menu.new
+
+    if self.current_user
+      self.output.user = {
+        name: self.current_user.name,
+        surname: self.current_user.surname,
+        locale: self.current_user.locale
+      }
+    end
+
+    access = Anubis::Sso::Client::GroupMenu.accesses[:read].to_s+','+Anubis::Sso::Client::GroupMenu.accesses[:write].to_s
+    query = <<-SQL
+          SELECT `t`.* FROM
+            (
+              SELECT `t2`.`id`, `t2`.`mode`, `t2`.`action`, `t2`.`title_locale`, `t2`.`page_title_locale`, `t2`.`short_title_locale`, 
+                `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`.`id` AS `menu_id`, `menus`.`mode`, `menus`.`action`, `menus`.`title_locale`, `menus`.`page_title_locale`,
+                  `menus`.`short_title_locale`, `menus`.`position`, `menus`.`tab`, `menus`.`menu_id` AS `parent_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 `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_locale`, `t2`.`page_title_locale`, `t2`.`short_title_locale`,
+                  `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::Sso::Client::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::Sso::Client::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
+
+  def logout
+    self.output = Anubis::Output::Basic.new
+    self.output.result = 0
+
+    begin
+      RestClient.delete self.sso_server + 'api/1/login/' + self.token + '?sso_system=' + self.sso_system_uuid + '&secret_key=' + self.sso_system_secret
+      result = true
+    rescue
+      result = false
+    end
+
+    if result
+      self.redis.del self.redis_prefix + 'session:' + self.token
+    else
+      self.output.result = -1
+    end
+
+    respond_to do |format|
+      format.json { render json: around_menu_output(self.output.to_h) }
+    end
+  end
+end

data/app/controllers/anoubis/sso/client/index/callbacks.rb

@@ -0,0 +1,13 @@
+module Anubis::Sso::Client::Index::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

data/app/controllers/anoubis/sso/client/index_controller.rb

@@ -0,0 +1,18 @@
+require_dependency "anubis/sso/client/index/actions"
+require_dependency "anubis/sso/client/index/callbacks"
+
+class Anubis::Sso::Client::IndexController < Anubis::Sso::Client::ApplicationController
+  include Anubis::Sso::Client::Index::Actions
+  include Anubis::Sso::Client::Index::Callbacks
+
+  ##
+  # 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

data/app/controllers/anoubis/sso/server/application_controller.rb

@@ -0,0 +1,49 @@
+class Anubis::Sso::Server::ApplicationController < Anubis::Core::ApplicationController
+  def user_model
+    begin
+      model = Rails.configuration.user_model.classify.constantize
+    rescue
+      model = Anubis::Sso::Server::User
+    end
+
+    model
+  end
+
+  def front_url
+    Rails.configuration.sso_front_url
+  end
+
+  def domain_url
+    Rails.configuration.sso_domain_url
+  end
+
+  ##
+  # Returns user data by UUI
+  def get_user_data_by_uuid(uuid)
+    begin
+      user_data = self.user_model.new(JSON.parse(self.redis.get(self.redis_prefix + 'user:' + uuid), { symbolize_names: true }))
+    rescue
+      user_data = nil
+    end
+
+    unless user_data
+      user_data = self.user_model.where(uuid: uuid, status: 'enabled').first
+
+      user_data.save_cache if user_data
+    end
+
+    user_data
+  end
+
+  ##
+  # Format user information to result hash
+  def format_user_output(user_data, result)
+    result[:uuid] = user_data.uuid
+    result[:name] = user_data.name
+    result[:surname] = user_data.surname
+    result[:login] = user_data.login
+    result[:locale] = user_data.locale
+    result[:timezone] = user_data.timezone
+    result[:timeout] = user_data.timeout
+  end
+end