biovision-base 0.5.170614

data/app/helpers/codes_helper.rb

@@ -0,0 +1,10 @@
+module CodesHelper
+  # @param [Code] entity
+  def admin_code_link(entity)
+    link_to entity.body, admin_code_path(entity.id)
+  end
+
+  def code_types_for_select
+    CodeType.order('id asc').map { |c| [c.name, c.id] }
+  end
+end

data/app/helpers/editable_pages_helper.rb

@@ -0,0 +1,20 @@
+module EditablePagesHelper
+  # @param [EditablePage] entity
+  def admin_editable_page_link(entity)
+    link_to(entity.name, admin_editable_page_path(entity.id))
+  end
+
+  # @param [EditablePage] entity
+  def editable_page_image_preview(entity)
+    return '' if entity.image.blank?
+    versions = "#{entity.image.preview_2x.url} 2x"
+    image_tag(entity.image.preview.url, alt: entity.name, srcset: versions)
+  end
+
+  # @param [EditablePage] entity
+  def editable_page_image_medium(entity)
+    return '' if entity.image.blank?
+    versions = "#{entity.image.medium_2x.url} 2x"
+    image_tag(entity.image.medium.url, alt: entity.name, srcset: versions)
+  end
+end

data/app/helpers/privileges_helper.rb

@@ -0,0 +1,11 @@
+module PrivilegesHelper
+  # @param [Privilege] entity
+  def admin_privilege_link(entity)
+    link_to(entity.name, admin_privilege_path(entity.id))
+  end
+
+  # @param [PrivilegeGroup] entity
+  def admin_privilege_group_link(entity)
+    link_to(entity.name, admin_privilege_group_path(entity.id))
+  end
+end

data/app/helpers/tracking_helper.rb

@@ -0,0 +1,17 @@
+module TrackingHelper
+  # @param [Agent] entity
+  def admin_agent_link(entity)
+    link_to(entity.name, admin_agent_path(entity.id))
+  end
+
+  # @param [Browser] entity
+  def admin_browser_link(entity)
+    link_to(entity.name, admin_browser_path(entity.id))
+  end
+
+  def browsers_for_select
+    options = [[t(:not_set), '']]
+    Browser.ordered_by_name.each { |browser| options << [browser.name, browser.id] }
+    options
+  end
+end

data/app/jobs/application_job.rb

@@ -0,0 +1,7 @@
+class ApplicationJob < ActiveJob::Base
+  # Automatically retry jobs that encountered a deadlock
+  # retry_on ActiveRecord::Deadlocked
+
+  # Most jobs are safe to ignore if the underlying records are no longer available
+  # discard_on ActiveJob::DeserializationError
+end

data/app/jobs/clean_tokens_job.rb

@@ -0,0 +1,8 @@
+class CleanTokensJob < ApplicationJob
+  queue_as :default
+
+  def perform(*args)
+    Token.where(active: false).where('updated_at < ?', 1.month.ago).delete_all
+    Token.where('last_used < ?', 1.year.ago).delete_all
+  end
+end

data/app/mailers/code_sender.rb

@@ -0,0 +1,15 @@
+class CodeSender < ApplicationMailer
+  # @param [Integer] code_id
+  def email(code_id)
+    @code = Code.find_by(id: code_id)
+
+    mail to: @code.user.email unless @code.nil?
+  end
+
+  # @param [Integer] code_id
+  def password(code_id)
+    @code = Code.find_by(id: code_id)
+
+    mail to: @code.user.email unless @code.nil?
+  end
+end

data/app/models/agent.rb

@@ -0,0 +1,38 @@
+class Agent < ApplicationRecord
+  include Toggleable
+  include RequiredUniqueName
+
+  PER_PAGE   = 20
+  NAME_LIMIT = 255
+
+  toggleable :mobile, :bot, :active
+
+  belongs_to :browser, optional: true, counter_cache: true
+
+  validates_length_of :name, maximum: NAME_LIMIT
+
+  scope :bots, ->(flag) { where(bot: flag.to_i > 0) unless flag.blank? }
+  scope :mobile, ->(flag) { where(mobile: flag.to_i > 0) unless flag.blank? }
+  scope :active, ->(flag) { where(active: flag.to_i > 0) unless flag.blank? }
+  scope :filtered, ->(f) { with_name_like(f[:name]).bots(f[:bots]).mobile(f[:mobile]).active(f[:active]) }
+
+  # @param [Integer] page
+  # @param [Hash] filter
+  def self.page_for_administration(page = 1, filter = {})
+    filtered(filter).ordered_by_name.page(page).per(PER_PAGE)
+  end
+
+  def self.entity_parameters
+    %i(browser_id name mobile bot active)
+  end
+
+  # Get instance of Agent for given string
+  #
+  # Trims agent name upto 255 characters
+  #
+  # @param [String] name
+  # @return [Agent]
+  def self.named(name)
+    find_or_create_by(name: name[0..254])
+  end
+end

data/app/models/application_record.rb

@@ -0,0 +1,3 @@
+class ApplicationRecord < ActiveRecord::Base
+  self.abstract_class = true
+end

data/app/models/browser.rb

@@ -0,0 +1,22 @@
+class Browser < ApplicationRecord
+  include Toggleable
+  include RequiredUniqueName
+
+  PER_PAGE   = 20
+  NAME_LIMIT = 250
+
+  toggleable :mobile, :bot, :active
+
+  has_many :agents, dependent: :nullify
+
+  validates_length_of :name, maximum: NAME_LIMIT
+
+  # @param [Integer] page
+  def self.page_for_administration(page = 1)
+    ordered_by_name.page(page).per(PER_PAGE)
+  end
+
+  def self.entity_parameters
+    %i(name mobile bot active)
+  end
+end

data/app/models/code.rb

@@ -0,0 +1,58 @@
+class Code < ApplicationRecord
+  include HasOwner
+
+  PER_PAGE       = 20
+  BODY_LIMIT     = 50
+  PAYLOAD_LIMIT  = 250
+  QUANTITY_RANGE = (0..32767)
+
+  belongs_to :user, optional: true
+  belongs_to :agent, optional: true
+  belongs_to :code_type
+
+  after_initialize :generate_body
+
+  before_validation :sanitize_quantity
+
+  validates_presence_of :body
+  validates_uniqueness_of :body
+  validates_length_of :body, maximum: BODY_LIMIT
+  validates_length_of :payload, maximum: PAYLOAD_LIMIT
+
+  scope :recent, -> { order('id desc') }
+  scope :active, -> { where('quantity > 0') }
+
+  # @param [Integer] page
+  def self.page_for_administration(page = 1)
+    recent.page(page).per(PER_PAGE)
+  end
+
+  def self.entity_parameters
+    %i(body payload quantity)
+  end
+
+  def self.creation_parameters
+    entity_parameters + %i(user_id code_type_id)
+  end
+
+  def activated?
+    quantity < 1
+  end
+
+  def active?
+    quantity > 0
+  end
+
+  private
+
+  def generate_body
+    return unless body.nil?
+    number    = SecureRandom.random_number(0xffff_ffff_ffff_ffff)
+    self.body = number.to_s(36).scan(/.{4}/).join('-').upcase
+  end
+
+  def sanitize_quantity
+    self.quantity = QUANTITY_RANGE.first if quantity < QUANTITY_RANGE.first
+    self.quantity = QUANTITY_RANGE.last if quantity > QUANTITY_RANGE.last
+  end
+end

data/app/models/code_type.rb

@@ -0,0 +1,11 @@
+class CodeType < ApplicationRecord
+  include RequiredUniqueName
+  include RequiredUniqueSlug
+
+  SLUG_LIMIT = 20
+  NAME_LIMIT = 100
+
+  validates_length_of :name, maximum: NAME_LIMIT
+
+  has_many :codes, dependent: :delete_all
+end

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

@@ -0,0 +1,143 @@
+module Biovision::PrivilegeBase
+  extend ActiveSupport::Concern
+
+  included do
+    DESCRIPTION_LIMIT = 350
+    NAME_LIMIT        = 250
+    SLUG_LIMIT        = 250
+    PRIORITY_RANGE    = (1..32767)
+
+    belongs_to :parent, class_name: Privilege.to_s, optional: true
+    has_many :children, class_name: Privilege.to_s, foreign_key: :parent_id
+    has_many :user_privileges, dependent: :destroy
+    has_many :users, through: :user_privileges
+    has_many :privilege_group_privileges, dependent: :destroy
+    has_many :privilege_groups, through: :privilege_group_privileges
+
+    after_initialize :set_next_priority
+
+    before_validation { self.name = name.strip unless name.nil? }
+    before_validation { self.slug = Canonizer.transliterate(name.to_s) if slug.blank? }
+    before_validation :normalize_priority
+
+    before_save :compact_children_cache
+
+    validates_presence_of :name, :slug, :priority
+    validates :name, uniqueness: { case_sensitive: false, scope: [:parent_id] }
+    validates :slug, uniqueness: { case_sensitive: false }
+    validates_length_of :name, maximum: NAME_LIMIT
+    validates_length_of :slug, maximum: SLUG_LIMIT
+    validates_length_of :description, maximum: DESCRIPTION_LIMIT
+
+    scope :ordered_by_priority, -> { order('priority asc, name asc') }
+    scope :ordered_by_name, -> { order('name asc, slug asc') }
+    scope :visible, -> { where(visible: true, deleted: false) }
+    scope :for_tree, ->(parent_id = nil) { where(parent_id: parent_id).ordered_by_priority }
+    scope :siblings, ->(item) { where(parent_id: item.parent_id) }
+  end
+
+  # @return [String]
+  def full_title
+    (parents.map(&:name) + [name]).join ' / '
+  end
+
+  # @return [Array<Integer>]
+  def ids
+    [id] + children_cache
+  end
+
+  # @return [Array<Integer>]
+  def branch_ids
+    parents_cache.split(',').map(&:to_i).reject { |i| i < 1 }.uniq + [id]
+  end
+
+  def parents
+    if parents_cache.blank?
+      []
+    else
+      Privilege.where(id: parents_cache.split(',').compact).order('id asc')
+    end
+  end
+
+  def cache_parents!
+    if parent.nil?
+      self.parents_cache = ''
+    else
+      self.parents_cache = parent.parents_cache + ",#{parent_id}"
+    end
+    save!
+  end
+
+  def cache_children!
+    children.order('id asc').map do |child|
+      self.children_cache += [child.id] + child.children_cache
+    end
+    save!
+    parent&.cache_children!
+  end
+
+  def can_be_deleted?
+    children.count < 1
+  end
+
+  # @param [User] user
+  def has_user?(user)
+    return false if user.nil?
+    user_privileges.exists?(user: user) || user.super_user?
+  end
+
+  # @param [User] user
+  def grant(user)
+    criteria = { privilege: self, user: user }
+    UserPrivilege.create(criteria) unless UserPrivilege.exists?(criteria)
+  end
+
+  # @param [User] user
+  def revoke(user)
+    criteria = { privilege: self, user: user }
+    UserPrivilege.where(criteria).destroy_all
+  end
+
+  # @param [Integer] delta
+  def change_priority(delta)
+    new_priority = priority + delta
+    adjacent     = Privilege.siblings(self).find_by(priority: new_priority)
+    if adjacent.is_a?(Privilege) && (adjacent.id != id)
+      adjacent.update!(priority: priority)
+    end
+    update(priority: new_priority)
+
+    Privilege.for_tree(parent_id).map { |e| [e.id, e.priority] }.to_h
+  end
+
+  private
+
+  def set_next_priority
+    if id.nil? && priority == 1
+      self.priority = Privilege.siblings(self).maximum(:priority).to_i + 1
+    end
+  end
+
+  def normalize_priority
+    self.priority = PRIORITY_RANGE.first if priority < PRIORITY_RANGE.first
+    self.priority = PRIORITY_RANGE.last if priority > PRIORITY_RANGE.last
+  end
+
+  def compact_children_cache
+    self.children_cache.uniq!
+  end
+
+  module ClassMethods
+    def page_for_administration
+      ordered_by_name
+    end
+
+    def entity_parameters
+      %i(name slug priority description)
+    end
+
+    def creation_parameters
+      entity_parameters + %i(parent_id)
+    end
+  end
+end

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

@@ -0,0 +1,124 @@
+module Biovision::UserBase
+  extend ActiveSupport::Concern
+
+  included do
+    include Toggleable
+
+    METRIC_REGISTRATION            = 'users.registration.hit'
+    METRIC_AUTHENTICATION_SUCCESS  = 'users.authentication.success.hit'
+    METRIC_AUTHENTICATION_FAILURE  = 'users.authentication.failure.hit'
+    METRIC_AUTHENTICATION_EXTERNAL = 'users.authentication.external.hit'
+
+    PER_PAGE = 20
+
+    SLUG_LIMIT   = 250
+    EMAIL_LIMIT  = 250
+    NAME_LIMIT   = 100
+    NOTICE_LIMIT = 255
+    PHONE_LIMIT  = 50
+
+    toggleable %i(allow_login bot email_confirmed phone_confirmed allow_mail)
+
+    belongs_to :agent, optional: true
+
+    has_secure_password
+
+    mount_uploader :image, AvatarUploader
+
+    enum gender: [:female, :male]
+
+    belongs_to :agent, optional: true
+    belongs_to :inviter, class_name: User.to_s, optional: true
+    has_many :invitees, class_name: User.to_s, foreign_key: :inviter_id, dependent: :nullify
+    has_many :tokens, dependent: :delete_all
+    has_many :codes, dependent: :delete_all
+    has_many :user_privileges, dependent: :destroy
+    has_many :privileges, through: :user_privileges
+    has_many :foreign_users, dependent: :delete_all
+
+    before_save :normalize_slug
+
+    validates_presence_of :screen_name, :email
+    validates_format_of :screen_name, with: /\A[a-z0-9_]{1,30}\z/i, if: :native_slug?
+    validates_format_of :email, with: /\A([^@\s]+)@((?:[-a-z0-9]+\.)+[a-z0-9][-a-z0-9]+)\z/i
+    validates :screen_name, uniqueness: { case_sensitive: false }
+    validates :email, uniqueness: { case_sensitive: false }
+    validates_length_of :slug, maximum: SLUG_LIMIT
+    validates_length_of :screen_name, maximum: SLUG_LIMIT
+    validates_length_of :name, maximum: NAME_LIMIT
+    validates_length_of :patronymic, maximum: NAME_LIMIT
+    validates_length_of :surname, maximum: NAME_LIMIT
+    validates_length_of :email, maximum: EMAIL_LIMIT
+    validates_length_of :phone, maximum: PHONE_LIMIT
+    validates_length_of :notice, maximum: NOTICE_LIMIT
+
+    scope :with_privilege, ->(privilege) { joins(:user_privileges).where(user_privileges: { privilege_id: privilege.branch_ids }) }
+    scope :bots, ->(flag) { where(bot: flag.to_i > 0) unless flag.blank? }
+    scope :name_like, ->(val) { where('name ilike ?', "%#{val}%") unless val.blank? }
+    scope :email_like, ->(val) { where('email ilike ?', "%#{val}%") unless val.blank? }
+    scope :with_email, ->(email) { where('lower(email) = lower(?)', email) }
+    scope :screen_name_like, ->(val) { where('screen_name ilike ?', "%#{val}%") unless val.blank? }
+    scope :search, ->(q) { where("lower(concat_ws(' ', slug, email, surname, name)) like ?", "%#{q.downcase}%") unless q.blank? }
+    scope :filtered, ->(f) { name_like(f[:name]).email_like(f[:email]).screen_name_like(f[:screen_name]) }
+  end
+
+  module ClassMethods
+    # @param [Integer] page
+    # @param [Hash] filter
+    def page_for_administration(page, filter = {})
+      bots(filter[:bots]).filtered(filter).order('id desc').page(page).per(PER_PAGE)
+    end
+
+    def profile_parameters
+      %i(image name patronymic surname birthday gender allow_mail)
+    end
+
+    def sensitive_parameters
+      %i(email phone password password_confirmation)
+    end
+
+    # Параметры при регистрации
+    def new_profile_parameters
+      profile_parameters + sensitive_parameters + %i(screen_name)
+    end
+
+    # Параметры для администрирования
+    def entity_parameters
+      flags = %i(bot allow_login email_confirmed phone_confirmed foreign_slug)
+
+      new_profile_parameters + flags + %i(screen_name notice)
+    end
+
+    def ids_range
+      min = User.minimum(:id).to_i
+      max = User.maximum(:id).to_i
+      (min..max)
+    end
+  end
+
+  def profile_name
+    screen_name
+  end
+
+  def name_for_letter
+    name || profile_name
+  end
+
+  def can_receive_letters?
+    allow_mail? && !email.blank?
+  end
+
+  def native_slug?
+    !foreign_slug?
+  end
+
+  private
+
+  def normalize_slug
+    if native_slug?
+      self.slug = screen_name.downcase
+    else
+      self.slug = slug.downcase
+    end
+  end
+end