biovision-base 0.5.170614

data/app/models/concerns/biovision/user_privilege_base.rb

@@ -0,0 +1,46 @@
+module Biovision::UserPrivilegeBase
+  extend ActiveSupport::Concern
+
+  included do
+    belongs_to :user
+    belongs_to :privilege, counter_cache: :users_count
+
+    validates_uniqueness_of :privilege_id, scope: [:user_id]
+  end
+
+  module ClassMethods
+    # @param [User] user
+    # @return [Array<Integer>]
+    def ids(user)
+      privileges = user&.privileges
+      return [] if privileges.blank?
+      privileges.map(&:ids).flatten.uniq
+    end
+
+    # @param [User] user
+    # @param [Symbol] privilege_name
+    def user_has_privilege?(user, privilege_name)
+      return false if user.nil?
+      return true if user.super_user?
+      privilege = Privilege.find_by(slug: privilege_name.to_s)
+      ids(user).include?(privilege&.id)
+    end
+
+    # @param [User] user
+    def user_has_any_privilege?(user)
+      return false if user.nil?
+      return true if user.super_user?
+      exists?(user: user)
+    end
+
+    # @param [User] user
+    # @param [Symbol] group_name
+    def user_in_group?(user, group_name)
+      return false if user.nil?
+      return true if user.super_user?
+      privilege_ids = PrivilegeGroup.ids(group_name)
+      return false if privilege_ids.blank?
+      exists?(user: user, privilege_id: privilege_ids)
+    end
+  end
+end

data/app/models/concerns/has_owner.rb

@@ -0,0 +1,19 @@
+module HasOwner
+  extend ActiveSupport::Concern
+
+  included do
+    scope :owned_by, ->(user) { where(user: user) }
+    scope :with_user_id, ->(user_id) { where(user_id: user_id) unless user_id.blank? }
+  end
+
+  # @param [User] user
+  # @return [Boolean]
+  def owned_by?(user)
+    !user.nil? && (self.user == user)
+  end
+
+  # @return [String]
+  def owner_name
+    user&.profile_name || I18n.t(:anonymous)
+  end
+end

data/app/models/concerns/required_unique_name.rb

@@ -0,0 +1,13 @@
+module RequiredUniqueName
+  extend ActiveSupport::Concern
+
+  included do
+    before_validation { self.name = name.strip unless name.nil? }
+    validates_presence_of :name
+    validates_uniqueness_of :name
+
+    scope :ordered_by_name, -> { order('name asc') }
+    scope :with_name_like, ->(name) { where('name ilike ?', "%#{name}%") unless name.blank? }
+    scope :with_name, ->(name) { where('name ilike ?', name) unless name.blank? }
+  end
+end

data/app/models/concerns/required_unique_slug.rb

@@ -0,0 +1,12 @@
+module RequiredUniqueSlug
+  extend ActiveSupport::Concern
+
+  included do
+    before_validation { self.slug = slug.strip unless slug.nil? }
+    validates :slug, uniqueness: { case_sensitive: false }, presence: true
+
+    scope :ordered_by_slug, -> { order('slug asc') }
+    scope :with_slug_like, ->(slug) { where('slug ilike ?', "%#{slug}%") unless slug.blank? }
+    scope :with_slug, ->(slug) { where('slug ilike ?', slug) unless slug.blank? }
+  end
+end

data/app/models/concerns/toggleable.rb

@@ -0,0 +1,29 @@
+# Adds list of toggleable attributes to model
+#
+# @author Maxim Khan-Magomedov <maxim.km@gmail.com>
+module Toggleable
+  extend ActiveSupport::Concern
+
+  included do
+    class_attribute :toggleable_attributes, instance_predicate: false, instance_accessor: false
+
+    # @param [String, Symbol] attribute
+    # @return [Hash]
+    def toggle_parameter(attribute)
+      return unless self::toggleable_attributes.include? attribute.to_sym
+      toggle! attribute
+      { attribute => self[attribute] }
+    end
+  end
+
+  module ClassMethods
+
+    private
+
+    # @param [Array<Symbol, String>] attributes
+    def toggleable(*attributes)
+      cattr_accessor :toggleable_attributes
+      self.toggleable_attributes = attributes.flatten
+    end
+  end
+end

data/app/models/editable_page.rb

@@ -0,0 +1,30 @@
+class EditablePage < ApplicationRecord
+  include RequiredUniqueName
+  include RequiredUniqueSlug
+
+  NAME_LIMIT = 100
+  SLUG_LIMIT = 100
+  META_LIMIT = 250
+  BODY_LIMIT = 65535
+
+  mount_uploader :image, EditablePageImageUploader
+
+  validates_length_of :name, maximum: NAME_LIMIT
+  validates_length_of :slug, maximum: SLUG_LIMIT
+  validates_length_of :title, maximum: META_LIMIT
+  validates_length_of :keywords, maximum: META_LIMIT
+  validates_length_of :description, maximum: META_LIMIT
+  validates_length_of :body, maximum: BODY_LIMIT
+
+  def self.page_for_administration
+    ordered_by_name
+  end
+
+  def self.entity_parameters
+    %i(image name title keywords description body)
+  end
+
+  def self.creation_parameters
+    entity_parameters + %i(slug)
+  end
+end

data/app/models/foreign_site.rb

@@ -0,0 +1,75 @@
+class ForeignSite < ApplicationRecord
+  include RequiredUniqueName
+  include RequiredUniqueSlug
+
+  NAME_LIMIT = 50
+  SLUG_LIMIT = 50
+
+  has_many :foreign_users, dependent: :delete_all
+
+  validates_length_of :name, maximum: NAME_LIMIT
+  validates_length_of :slug, maximum: SLUG_LIMIT
+
+  def self.page_for_administration
+    ordered_by_name
+  end
+
+  # @param [Hash] data
+  # @param [Hash] tracking
+  def authenticate(data, tracking)
+    user = foreign_users.find_by(slug: data[:uid])&.user
+    user || create_user(data, tracking)
+  end
+
+  private
+
+  # @param [Hash] data
+  # @param [Hash] tracking
+  # @return [User]
+  def create_user(data, tracking)
+    parameters = {
+      user: native_user(data, tracking),
+      slug: data[:uid],
+      name: data[:info][:name],
+      email: data[:info][:email],
+      data: JSON.generate(data.dig(:extra, :raw_info))
+    }.merge(tracking)
+    foreign_users.create!(parameters).user
+  end
+
+  # @param [Hash] data
+  # @param [Hash] tracking
+  # @return [User]
+  def native_user(data, tracking)
+    user  = nil
+    email = data.dig(:info, :email)
+    unless email.blank?
+      user = User.with_email(email).first
+    end
+    user || create_native_user(data, tracking)
+  end
+
+  # @param [Hash] data
+  # @param [Hash] tracking
+  # @return [User]
+  def create_native_user(data, tracking)
+    screen_name = data.dig(:info, :nickname)
+    image_url   = data.dig(:info, :image)
+    password    = SecureRandom.urlsafe_base64(12)
+    hash_salt   = BCrypt::Engine.generate_salt
+    parameters  = {
+      foreign_slug: true,
+      slug: "#{slug}-#{data[:uid]}",
+      email: data[:info][:email],
+      name: data[:info][:first_name],
+      surname: data[:info][:last_name],
+      screen_name: screen_name.blank? ? data[:name] : screen_name,
+      password_digest: BCrypt::Engine.hash_secret(password, hash_salt),
+      email_confirmed: true,
+    }.merge(tracking)
+
+    parameters[:remote_image_url] = data[:info][:image] unless image_url.blank?
+
+    User.create!(parameters)
+  end
+end

data/app/models/foreign_user.rb

@@ -0,0 +1,26 @@
+class ForeignUser < ApplicationRecord
+  PER_PAGE = 20
+
+  belongs_to :agent, optional: true
+  belongs_to :foreign_site, counter_cache: true
+  belongs_to :user
+
+  before_validation :trim_fields
+  validates_uniqueness_of :slug, scope: [:foreign_site_id]
+
+  scope :ordered_by_slug, -> { order('slug asc') }
+
+  # @param [Integer] page
+  def self.page_for_administration(page = 1)
+    ordered_by_slug.page(page).per(PER_PAGE)
+  end
+
+  private
+
+  def trim_fields
+    self.slug  = slug[0..255] unless slug.nil?
+    self.name  = name[0..255] unless name.nil?
+    self.email = email[0..255] unless email.nil?
+    self.data  = data[0..65535] unless data.nil?
+  end
+end

data/app/models/metric.rb

@@ -0,0 +1,67 @@
+class Metric < ApplicationRecord
+  include RequiredUniqueName
+
+  DESCRIPTION_LIMIT = 250
+  PERIOD_RANGE      = (1..365)
+
+  METRIC_HTTP_401 = 'errors.http.unauthorized.hit'
+  METRIC_HTTP_404 = 'errors.http.not_found.hit'
+  METRIC_HTTP_503 = 'errors.http.service_unavailable.hit'
+  METRIC_HTTP_505 = 'errors.http.internal_server_error.hit'
+
+  has_many :metric_values, dependent: :destroy
+
+  before_validation :normalize_period
+  validates_length_of :description, maximum: DESCRIPTION_LIMIT
+
+  def self.page_for_administration
+    order('name asc')
+  end
+
+  def self.entity_parameters
+    %i(incremental start_with_zero show_on_dashboard default_period description)
+  end
+
+  # @param [String] name
+  # @param [Integer] quantity
+  def self.register(name, quantity = 1)
+    instance = Metric.find_by(name: name) || create(name: name, incremental: !(name =~ /\.hit\z/).nil?)
+    instance.metric_values.create(time: Time.now, quantity: quantity)
+    value = instance.incremental? ? instance.metric_values.sum(:quantity) : quantity
+
+    instance.update(value: value, previous_value: instance.value)
+  end
+
+  # @param [Integer] period
+  def values(period = 7)
+    current_value = 0
+    metric_values.since(period.days.ago).ordered_by_time.map do |v|
+      current_value = incremental? ? current_value + v.quantity : v.quantity
+      [v.time.strftime('%d.%m.%Y %H:%M'), current_value]
+    end.to_h
+  end
+
+  # @param [Integer] period
+  # @param [Integer] resolution
+  def graph_data(period = default_period, resolution = 4)
+    result        = Hash.new(0)
+    current_value = 0
+    metric_values.since(period.days.ago).ordered_by_time.each do |v|
+      key           = v.time_for_graph(resolution).strftime('%d.%m.%Y %H:%M')
+      current_value = incremental? ? current_value + v.quantity : v.quantity
+      if result.key?(key)
+        result[key] = current_value
+      else
+        result[key] += current_value
+      end
+    end
+    result
+  end
+
+  private
+
+  def normalize_period
+    self.default_period = PERIOD_RANGE.first if default_period < PERIOD_RANGE.first
+    self.default_period = PERIOD_RANGE.last if default_period > PERIOD_RANGE.last
+  end
+end

data/app/models/metric_value.rb

@@ -0,0 +1,15 @@
+class MetricValue < ApplicationRecord
+  belongs_to :metric
+
+  validates_presence_of :time, :quantity
+
+  scope :recent, -> { order('id desc') }
+  scope :since, -> (time) { where('time >= ?', time) }
+  scope :ordered_by_time, -> { order('time asc') }
+
+  # @param [Integer] resolution hour count per chunk
+  def time_for_graph(resolution = 4)
+    rounded = time - time.sec - time.min * 60 - (time.hour % resolution * 3600)
+    rounded + resolution.hours
+  end
+end

data/app/models/privilege.rb

@@ -0,0 +1,3 @@
+class Privilege < ApplicationRecord
+  include Biovision::PrivilegeBase
+end

data/app/models/privilege_group.rb

@@ -0,0 +1,50 @@
+class PrivilegeGroup < ApplicationRecord
+  include RequiredUniqueSlug
+  include RequiredUniqueName
+
+  NAME_LIMIT        = 250
+  SLUG_LIMIT        = 50
+  DESCRIPTION_LIMIT = 350
+
+  has_many :privilege_group_privileges, dependent: :destroy
+  has_many :privileges, through: :privilege_group_privileges
+
+  validates_length_of :name, maximum: NAME_LIMIT
+  validates_length_of :slug, maximum: SLUG_LIMIT
+  validates_length_of :description, maximum: DESCRIPTION_LIMIT
+
+  def self.page_for_administration
+    ordered_by_name
+  end
+
+  # Privilege ids for group with given slug
+  #
+  # @param [Symbol|String]
+  def self.ids(slug)
+    instance = find_by(slug: slug.to_s)
+    return [] if instance.nil?
+    instance.privileges.map(&:ids).flatten.uniq
+  end
+
+  def self.entity_parameters
+    %i(name slug description)
+  end
+
+  # @param [Privilege] privilege
+  def has_privilege?(privilege)
+    privilege_group_privileges.exists?(privilege: privilege)
+  end
+
+  # @param [Privilege] privilege
+  def add_privilege(privilege)
+    criteria = { privilege_group: self, privilege: privilege }
+    return if PrivilegeGroupPrivilege.exists?(criteria)
+    PrivilegeGroupPrivilege.create(criteria)
+  end
+
+  # @param [Privilege] privilege
+  def remove_privilege(privilege)
+    criteria = { privilege_group: self, privilege: privilege }
+    PrivilegeGroupPrivilege.where(criteria).destroy_all
+  end
+end

data/app/models/privilege_group_privilege.rb

@@ -0,0 +1,6 @@
+class PrivilegeGroupPrivilege < ApplicationRecord
+  belongs_to :privilege_group
+  belongs_to :privilege
+
+  validates_uniqueness_of :privilege_id, scope: [:privilege_group_id]
+end

data/app/models/token.rb

@@ -0,0 +1,75 @@
+class Token < ApplicationRecord
+  include HasOwner
+  include Toggleable
+
+  PER_PAGE = 25
+
+  toggleable :active
+
+  has_secure_token
+
+  belongs_to :user
+  belongs_to :agent, optional: true
+
+  validates_uniqueness_of :token
+
+  scope :recent, -> { order('last_used desc nulls last') }
+  scope :active, ->(flag) { where(active: flag.to_i > 0) unless flag.blank? }
+  scope :filtered, ->(f) { with_user_id(f[:user_id]).active(f[:active]) }
+
+  # @param [Integer] page
+  def self.page_for_administration(page, filter = {})
+    filtered(filter).recent.page(page).per(PER_PAGE)
+  end
+
+  # @param [User] user
+  # @param [Integer] page
+  def self.page_for_owner(user, page)
+    owned_by(user).recent.page(page).per(PER_PAGE)
+  end
+
+  def self.entity_parameters
+    %i(active)
+  end
+
+  def self.creation_parameters
+    entity_parameters + %i(user_id)
+  end
+
+  # @param [String] input
+  def self.from_cookie(input)
+    find_by(token: input.to_s.split(':')[1].to_s)
+  end
+
+  # @param [String] input
+  # @param [Boolean] touch_user
+  def self.user_by_token(input, touch_user = false)
+    return if input.blank?
+    pair = input.split(':')
+    user_by_pair(pair[0], pair[1], touch_user)
+  end
+
+  # @param [Integer] user_id
+  # @param [String] token
+  # @param [Boolean] touch_user
+  def self.user_by_pair(user_id, token, touch_user = false)
+    instance = find_by(user_id: user_id, token: token, active: true)
+    return if instance.nil?
+    instance.update_columns(last_used: Time.now)
+    instance.user.update_columns(last_seen: Time.now) if touch_user
+    instance.user
+  end
+
+  def name
+    "[#{id}] #{user.profile_name}"
+  end
+
+  # @param [User] user
+  def editable_by?(user)
+    owned_by?(user) || UserPrivilege.user_has_privilege?(user, :administrator)
+  end
+
+  def cookie_pair
+    "#{user_id}:#{token}"
+  end
+end