anoubis 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: c2ef6417845dbb20f56a6bb3bdd5e304b442f681928f9f64765d68d1bf5f4c57
+  data.tar.gz: d2a87698442e6d1807ae9ed3104a706053f45654f80da248db873bc7a0a16a80
+SHA512:
+  metadata.gz: 9bba0811a68af029fbe976c8369372e7026d328386895892c9300d2e5f4f448863f3e5fb54e123d2987e1d214620cde0d7fa9d43244a64ab7438110949e91ad0
+  data.tar.gz: a588b8aff9758aa25f20e709ceb2f86d72090a3d281b7cdb71ad97ac93fe9d771414b09daa571e7511c2049e723b8a32e92d894dc8c4cd4ec29c3af1eaecb470

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2018 Andrey Ryabov
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,28 @@
+# Anoubis
+Short description and motivation.
+
+## Usage
+How to use my plugin.
+
+## Installation
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'anoubis'
+```
+
+And then execute:
+```bash
+$ bundle
+```
+
+Or install it yourself as:
+```bash
+$ gem install anoubis
+```
+
+## Contributing
+Contribution directions go here.
+
+## License
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,38 @@
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+
+require 'rdoc/task'
+
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'Anoubis'
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('README.md')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+APP_RAKEFILE = File.expand_path("spec/dummy/Rakefile", __dir__)
+load 'rails/tasks/engine.rake'
+
+load 'rails/tasks/statistics.rake'
+
+require 'bundler/gem_tasks'
+
+desc "Run all specs in spec directory (excluding plugin specs)"
+#RSpec::Core::RakeTask.new(:spec => 'app:db:migrate')
+#RSpec::Core::RakeTask.new(:spec => 'app:db:test:prepare')
+
+#task :default => :spec
+
+#require 'rake/testtask'
+
+#Rake::TestTask.new(:test) do |t|
+#  t.libs << 'test'
+#  t.pattern = 'test/**/*_test.rb'
+#  t.verbose = false
+#end
+
+#task default: :test

data/app/controllers/anoubis/application_controller.rb

@@ -0,0 +1,78 @@
+## Main application controller class inherited from {https://api.rubyonrails.org/v6.1.4/classes/ActionController/API.html ActionController::API}
+class Anoubis::ApplicationController < ActionController::API
+  prepend_before_action :pba_anoubis_application
+
+  include ActionController::Cookies
+
+  ## Redis database variable
+  attr_accessor :redis
+
+  ## Current used locale
+  attr_accessor :locale
+
+  ##
+  # Returns default locale initialized in application configuration file. Variable is taken from {https://guides.rubyonrails.org/i18n.html Rails.configuration.i18n.default_locale} parameter
+  # @return [String] default locale
+  def default_locale
+    Rails.configuration.i18n.default_locale.to_s
+  end
+
+  ## Returns {https://github.com/redis/redis-rb Redis} prefix for storing cache data
+  attr_accessor :redis_prefix
+
+  ##
+  # 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} 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
+    @redis_prefix ||= get_redis_prefix
+  end
+
+  private def get_redis_prefix
+    begin
+      value = Rails.configuration.anoubis_redis_prefix
+    rescue
+      return ''
+    end
+
+    value + ':'
+  end
+
+  ##
+  # Procedure fires before any action and setup default variables.
+  def pba_anoubis_application
+    self.locale = params[:locale] if params.has_key? :locale
+    self.locale = default_locale unless self.locale
+    self.locale = default_locale if self.locale == ''
+    begin
+      I18n.locale = locale
+    rescue
+      I18n.locale = default_locale
+    end
+  end
+
+  ##
+  # Generates options headers for CORS requests
+  # @param methods [String] list of allowed HTTP actions separated by space <i>(e.g. 'GET POST DELETE')</i>
+  def options(methods = 'POST')
+    if check_origin
+      headers['Access-Control-Allow-Origin'] = request.headers['origin']
+      headers['Access-Control-Allow-Methods'] = methods
+      headers['Access-Control-Max-Age'] = '1000'
+      headers['Access-Control-Allow-Headers'] = '*,x-requested-with,Content-Type,Authorization'
+    end
+  end
+
+  ##
+  # Check current origin of header. By default origin always valid
+  # @return [Boolean] request host origin validation
+  def check_origin
+    true
+  end
+end

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

@@ -0,0 +1,343 @@
+##
+# Application controller for Anubis library.
+class Anubis::Core::ApplicationController < ActionController::API
+  prepend_before_action :anubis_core_initialization
+
+  #include AbstractController::Translation
+  include ActionController::MimeResponds
+  #include ActionController::Parameters
+  #include ActionDispatch::Http::Parameters
+  #include ActionDispatch::Request
+
+  # @!attribute [rw] version
+  #   @return [Integer] Specifies the api version. Parameters receive from URL <i>(defaults to: 0)</i>.
+  attr_accessor :version
+
+  # @!attribute [rw] locale
+  #   @return [String] Specifies the current language locale <i>(defaults to: 'ru')</i>.
+  #   Parameters receive from URL or user definition
+  attr_accessor :locale
+
+  # @!attribute [rw] current_user
+  #   @return [ActiveRecord] Specifies current user <i>(defaults to: nil)</i>.
+  attr_accessor :current_user
+
+  # @!attribute [rw] output
+  #    @return [Anubis::Output] standard output.
+  attr_accessor :output
+
+  # @!attribute [rw] writer
+  #   @return [Object] Specifies access of current user to this controller <i>(defaults to: false)</i>.
+  attr_accessor :writer
+
+  # @!attribute [rw] etc
+  #   @return [Anubis::Etc::Base] global system parameters
+  attr_accessor :etc
+
+  # @!attribute [rw] exports
+  #   @return [Anubis::Export] Export data class
+  attr_accessor :exports
+
+  ##
+  # Returns redis database class
+  def redis
+    @redis ||= Redis.new
+  end
+
+  ##
+  # Sets default parameters for application controller.
+  def anubis_core_initialization
+    self.version = 0
+
+    if defined? params
+      self.etc = Anubis::Etc::Base.new({ params: params })
+    else
+      self.etc = Anubis::Etc::Base.new
+    end
+    self.output = nil
+    self.exports = nil
+    self.writer = false
+
+    self.current_user = nil
+    self.locale = params[:locale] if params.has_key? :locale
+    self.locale = 'ru' unless self.locale
+    self.locale = 'ru' if self.locale == ''
+    begin
+      I18n.locale = self.locale
+    rescue
+      I18n.locale = 'ru'
+    end
+
+    return if request.method == 'OPTIONS'
+
+    if !params.has_key? :version
+      self.error_exit({ error: I18n.t('errors.no_api_version') })
+      return
+    end
+
+    if self.access_allowed?
+      self.set_access_control_headers
+    else
+      self.error_exit({ error: I18n.t('errors.access_not_allowed') })
+    end
+
+    self.version = params[:version]
+
+    if self.authenticate?
+      if self.authentication
+        if self.check_menu_access?
+          return if !self.menu_access params[:controller]
+        end
+      end
+    end
+
+    #self.user_time_zone if self.current_user
+    Time.zone = self.current_user.timezone if self.current_user
+    self.after_initialization
+  end
+
+  ##
+  # Calls after first controller initialization
+  def after_initialization
+
+  end
+
+
+  ##
+  # Gracefully terminate script execution with code 422 (Unprocessable entity). And JSON data
+  # @param data [Hash] Resulting data
+  # @option data [Integer] :code resulting error code
+  # @option data [String] :error resulting error message
+  def error_exit(data)
+    result = {
+      result: -1,
+      message: 'Error'
+    }
+    result[:result] = data[:code] if data.has_key? :code
+    result[:message] = data[:error] if data.has_key? :error
+    respond_to do |format|
+      format.json { render json: result, status: :unprocessable_entity }
+    end
+    begin
+      exit
+    rescue SystemExit => e
+
+    end
+  end
+
+  ##
+  # 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
+    nil
+  end
+
+  ##
+  # Get current user model filed json exception
+  # @return [Array] defined user exception for to_json function
+  def get_user_model_except
+    []
+  end
+
+  ##
+  # @!group Block of authorization
+
+  ##
+  # Checks if needed user authentication.
+  # @return [Boolean] if true, then user must be authenticated.
+  def authenticate?
+    return true
+  end
+
+  ##
+  # Authenticates user in the system
+  def authentication
+    if !self.token
+      self.error_exit({ error: I18n.t('errors.authentication_required') })
+      return false
+    end
+
+    # Check session presence
+    session = self.redis.get(self.redis_prefix + 'session:' + self.token)
+    if !session
+      self.error_exit({ error: I18n.t('errors.session_expired') })
+      return false
+    end
+
+    session = JSON.parse(session, { symbolize_names: true })
+
+    if !session.has_key?(:uuid) || !session.has_key?(:ttl)
+      self.error_exit({ error: I18n.t('errors.session_expired') })
+      return false
+    end
+
+    if session[:ttl] < Time.now
+      self.error_exit({ error: I18n.t('errors.session_expired') })
+      self.redis.del(self.redis_prefix + 'session:' + self.token)
+      return false
+    end
+
+    # Load user data from redis database
+    user_json = self.redis.get(self.redis_prefix + 'user:' + session[:uuid])
+    if !user_json
+      # Check user presence based on session user UUID
+      user = self.get_user_model.where(uuid_bin: self.uuid_to_bin(session[:uuid])).first
+      if !user
+        self.error_exit({ error: I18n.t('errors.authentication_required') })
+        return false
+      end
+      user_json = self.redis_save_user user
+    end
+
+    begin
+      self.current_user = self.get_user_model.new(JSON.parse(user_json,{ symbolize_names: true }))
+    rescue
+      self.current_user = nil
+    end
+
+    if !self.current_user
+      self.error_exit({ error: I18n.t('errors.authentication_required') })
+      return false
+    end
+
+    session[:time] = Time.now
+    session[:ttl] = session[:time] + self.current_user.timeout
+    self.redis.set(self.redis_prefix + 'session:' + self.token, session.to_json)
+
+    true
+  end
+
+  ##
+  # Checks user must have access for current controller.
+  # @return [Boolean] if true, then user must have access for this controller.
+  def check_menu_access?
+    true
+  end
+
+  ##
+  # Check menu access for current user of current controller
+  # @return [Boolean] if true, then user have access for this controller.
+  def menu_access(controller, exit = true)
+    self.writer = true
+
+    true
+  end
+
+  ##
+  # Get current token based on HTTP Authorization
+  # @return [String] current token
+  def token
+    if Rails.env.development?
+      return params[:token] if params[:token]
+    end
+    request.env.fetch('HTTP_AUTHORIZATION', '').scan(/Bearer (.*)$/).flatten.last
+  end
+
+  # @!endgroup
+
+  ##
+  # Check access for API.
+  # @return [Boolean] access for requested client
+  def access_allowed?
+    allowed_sites = [request.env['HTTP_ORIGIN']]
+
+    allowed_sites.include?(request.env['HTTP_ORIGIN'])
+  end
+
+  ##
+  # Set allow header information for multi-domain requests. Requested for browsers when API is not in the same
+  # address as Frontend application.
+  def set_access_control_headers
+    headers['Access-Control-Allow-Origin'] = request.env['HTTP_ORIGIN']
+    headers['Access-Control-Allow-Methods'] = 'POST, GET, OPTIONS, DELETE, PUT, PATCH'
+    headers['Access-Control-Max-Age'] = '1000'
+    headers['Access-Control-Allow-Headers'] = '*,x-requested-with,Content-Type,Authorization'
+  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
+
+  ##
+  # Generates new UUID data
+  # @return [String] string representation of UUID
+  def new_uuid
+    SecureRandom.uuid
+  end
+
+  ##
+  # Generates new session ID
+  # @return [string] string representation of session (64 bytes)
+  def new_session_id
+    SecureRandom.hex(32)
+  end
+
+  # @!endgroup
+
+  ##
+  # Saves user data into redis database and returns user JSON representation
+  # @param user [ActiveRecord] current user data
+  # @return [String] JSON representation of user data
+  def redis_save_user(user)
+    user_json = user.to_json(except: self.get_user_model_except)
+    user_hash = JSON.parse user_json, { symbolize_names: true }
+    user_hash[:uuid] = user.uuid
+    user_json = user_hash.to_json
+    self.redis.set(self.redis_prefix + 'user:' + user.uuid, user_json)
+
+    user_json
+  end
+
+  ##
+  # Returns defined application prefix for redis cache for controller. Default value ''
+  def redis_prefix
+    begin
+      value = Rails.configuration.redis_prefix
+    rescue
+      return ''
+    end
+
+    value + ':'
+  end
+
+  ##
+  # Returns default defined locale
+  def default_locale
+    Rails.configuration.i18n.default_locale.to_s
+  end
+
+  ##
+  # Default route for OPTIONS method
+  def options
+    if self.access_allowed?
+      self.set_access_control_headers
+      head :ok
+    else
+      head :forbidden
+    end
+  end
+end