biovision-base 0.22.180920.0 → 0.34.190331.1

data/app/models/code_type.rb

@@ -1,11 +1,19 @@
+# frozen_string_literal: true
+
+# Code type
+#
+# Attributes:
+#   - name [String]
+#   - slug [String]
 class CodeType < ApplicationRecord
   include RequiredUniqueName
   include RequiredUniqueSlug
 
-  SLUG_LIMIT = 20
   NAME_LIMIT = 100
+  SLUG_LIMIT = 20
 
   validates_length_of :name, maximum: NAME_LIMIT
+  validates_length_of :slug, maximum: SLUG_LIMIT
 
   has_many :codes, dependent: :delete_all
 end

data/app/models/concerns/flat_priority.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+# Model has flat priority field
+#
+# Adds sorting items by priority
+# @author Maxim Khan-Magomedov <maxim.km@gmail.com>
+module FlatPriority
+  extend ActiveSupport::Concern
+
+  included do
+    after_initialize :set_next_priority
+    before_validation :normalize_priority
+
+    scope :ordered_by_priority, -> { order('priority asc, id asc') }
+
+    def self.priority_range
+      (1..32_767)
+    end
+  end
+
+  # @param [Integer] delta
+  def change_priority(delta)
+    swap_priority_with_adjacent(priority + delta)
+
+    self.class.ordered_by_priority.map { |e| [e.id, e.priority] }.to_h
+  end
+
+  protected
+
+  # @param [Integer] new_priority
+  def swap_priority_with_adjacent(new_priority)
+    adjacent = self.class.find_by(priority: new_priority)
+    if adjacent.is_a?(self.class) && (adjacent.id != id)
+      adjacent.update!(priority: priority)
+    end
+    update(priority: new_priority)
+  end
+
+  def set_next_priority
+    return unless id.nil? && priority == 1
+
+    self.priority = self.class.maximum(:priority).to_i + 1
+  end
+
+  def normalize_priority
+    range = self.class.priority_range
+    self.priority = range.first if priority < range.first
+    self.priority = range.last if priority > range.last
+  end
+end

data/app/models/concerns/nested_priority.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+# Model has nested priority field
+#
+# Adds sorting items by priority with siblings
+# @author Maxim Khan-Magomedov <maxim.km@gmail.com>
+module NestedPriority
+  extend ActiveSupport::Concern
+
+  included do
+    after_initialize :set_next_priority
+    before_validation :normalize_priority
+
+    scope :ordered_by_priority, -> { order('priority asc, id asc') }
+
+    def self.priority_range
+      (1..32_767)
+    end
+
+    # Change this method in models to get siblings
+    #
+    # @param [ApplicationRecord] _entity
+    def self.siblings(_entity)
+      all
+    end
+  end
+
+  # @param [Integer] delta
+  def change_priority(delta)
+    swap_priority_with_adjacent(priority + delta)
+
+    siblings = self.class.siblings(self)
+    siblings.ordered_by_priority.map { |e| [e.id, e.priority] }.to_h
+  end
+
+  protected
+
+  # @param [Integer] new_priority
+  def swap_priority_with_adjacent(new_priority)
+    adjacent = self.class.siblings(self).find_by(priority: new_priority)
+    if adjacent.is_a?(self.class) && (adjacent.id != id)
+      adjacent.update!(priority: priority)
+    end
+    update(priority: new_priority)
+  end
+
+  def set_next_priority
+    return unless id.nil? && priority == 1
+
+    self.priority = self.class.siblings(self).maximum(:priority).to_i + 1
+  end
+
+  def normalize_priority
+    range = self.class.priority_range
+    self.priority = range.first if priority < range.first
+    self.priority = range.last if priority > range.last
+  end
+end

data/app/models/concerns/required_unique_slug.rb

@@ -1,3 +1,6 @@
+# frozen_string_literal: true
+
+# Mixin for adding required unique slug constrain
 module RequiredUniqueSlug
   extend ActiveSupport::Concern
 
@@ -6,7 +9,7 @@ module RequiredUniqueSlug
     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('lower(slug) = lower(?)', slug) unless slug.blank? }
+    scope :with_slug_like, ->(v) { where('slug ilike ?', "%#{v}%") unless v.blank? }
+    scope :with_slug, ->(v) { where('lower(slug) = lower(?)', v) unless v.blank? }
   end
 end

data/app/models/editable_page.rb

@@ -1,44 +1,66 @@
+# frozen_string_literal: true
+
+# Editable page for site
+#
+# Attributes:
+#   - body [String]
+#   - image [EditablePageImageUploader], optional
+#   - image_alt_text [String], optional
+#   - language_id [Language]
+#   - meta_description [String], optional
+#   - meta_keywords [String], optional
+#   - meta_title [String], optional
+#   - name [String]
+#   - nav_group [String], optional
+#   - priority [Integer]
+#   - slug [String]
+#   - url [String], optional
+#   - visible [Boolean]
 class EditablePage < ApplicationRecord
   include RequiredUniqueName
+  include FlatPriority
+  include MetaTexts
+  include Checkable
+  include Toggleable
 
+  BODY_LIMIT = 65_535
+  META_LIMIT = 255
   NAME_LIMIT = 100
   SLUG_LIMIT = 100
-  META_LIMIT = 250
-  BODY_LIMIT = 65535
 
-  PRIORITY_RANGE = (1..999)
+  toggleable :visible
 
   mount_uploader :image, EditablePageImageUploader
 
   belongs_to :language, optional: true
 
-  after_initialize :set_next_priority
   before_validation { self.slug = slug.strip unless slug.nil? }
-  before_validation :normalize_priority
 
   validates_presence_of :slug
+  validates_uniqueness_of :slug, scope: [:language_id]
+  validates_length_of :body, maximum: BODY_LIMIT
+  validates_length_of :image_alt_text, maximum: META_LIMIT
   validates_length_of :name, maximum: NAME_LIMIT
   validates_length_of :slug, maximum: SLUG_LIMIT
-  validates_length_of :title, maximum: META_LIMIT
-  validates_length_of :image_alt_text, maximum: META_LIMIT
-  validates_length_of :keywords, maximum: META_LIMIT
-  validates_length_of :description, maximum: META_LIMIT
-  validates_length_of :body, maximum: BODY_LIMIT
-  validates_uniqueness_of :slug, scope: [:language_id]
+  validates_length_of :url, maximum: META_LIMIT
 
-  scope :ordered_by_priority, -> { order('priority asc, slug asc') }
   scope :ordered_by_slug, -> { order('slug asc') }
-  scope :with_slug_like, ->(slug) { where('slug ilike ?', "%#{slug}%") unless slug.blank? }
-  scope :with_slug, ->(slug) { where('lower(slug) = lower(?)', slug) unless slug.blank? }
+  scope :visible, -> { where(visible: true) }
+  scope :with_slug_like, ->(v) { where('slug ilike ?', "%#{v}%") unless v.blank? }
+  scope :with_slug, ->(v) { where(slug: v) unless v.blank? }
+  scope :for_group, ->(v) { where(nav_group: v) }
+  scope :for_language, ->(v) { where(language: v) }
   scope :siblings, ->(s) { where(language: s.language, nav_group: s.nav_group) }
   scope :list_for_administration, -> { ordered_by_priority }
+  scope :list_for_visitors, -> { visible.ordered_by_priority }
 
   def self.page_for_administration
     ordered_by_slug
   end
 
   def self.entity_parameters
-    %i(body description image image_alt_text keywords language_id name nav_group title slug url)
+    data = %i[body image image_alt_text language_id name nav_group slug url]
+    data + meta_text_fields
   end
 
   # @param [String] slug
@@ -62,33 +84,23 @@ class EditablePage < ApplicationRecord
     find_by(url: url, language: language) || find_by(url: url)
   end
 
-  # @param [User] user
-  def editable_by?(user)
-    UserPrivilege.user_has_privilege?(user, :chief_editor)
+  # @deprecated use #meta_title
+  def title
+    name
   end
 
-  # @param [Integer] delta
-  def change_priority(delta)
-    new_priority = priority + delta
-    adjacent     = self.class.find_by(priority: new_priority)
-    if adjacent.is_a?(self.class) && (adjacent.id != id)
-      adjacent.update!(priority: priority)
-    end
-    update(priority: new_priority)
-
-    self.class.ordered_by_priority.map { |e| [e.id, e.priority] }.to_h
+  # @deprecated use #meta_keywords
+  def keywords
+    meta_keywords
   end
 
-  private
-
-  def set_next_priority
-    if id.nil? && priority == 1
-      self.priority = self.class.maximum(:priority).to_i + 1
-    end
+  # @deprecated use #meta_description
+  def description
+    meta_description
   end
 
-  def normalize_priority
-    self.priority = PRIORITY_RANGE.first if priority < PRIORITY_RANGE.first
-    self.priority = PRIORITY_RANGE.last if priority > PRIORITY_RANGE.last
+  # @param [User] user
+  def editable_by?(user)
+    UserPrivilege.user_has_privilege?(user, :content_manager)
   end
 end

data/app/models/foreign_site.rb

@@ -65,9 +65,11 @@ class ForeignSite < ApplicationRecord
       screen_name: screen_name.blank? ? data[:name] : screen_name,
       password_digest: BCrypt::Engine.hash_secret(password, hash_salt),
       email_confirmed: true,
-      profile_data: {
-        name: data[:info][:first_name],
-        surname: data[:info][:last_name]
+      data: {
+        profile: {
+          name: data[:info][:first_name],
+          surname: data[:info][:last_name]
+        }
       }
     }.merge(tracking)
 

data/app/models/language.rb

@@ -1,16 +1,20 @@
+# frozen_string_literal: true
+
+# Language
+#
+# Attributes:
+#   active [Boolean]
+#   code [String]
+#   created_at [DateTime]
+#   priority [Integer]
+#   slug [String]
+#   updated_at [DateTime]
+#   users_count [Integer]
 class Language < ApplicationRecord
-  SLUG_LIMIT     = 20
-  CODE_LIMIT     = 8
-  PRIORITY_RANGE = (1..999)
+  include FlatPriority
 
-  has_many :users, dependent: :nullify
-  has_many :user_languages, dependent: :delete_all
-  has_many :editable_pages, dependent: :nullify
-  has_many :feedback_requests, dependent: :nullify
-
-  after_initialize :set_next_priority
-
-  before_validation :normalize_priority
+  SLUG_LIMIT = 20
+  CODE_LIMIT = 8
 
   validates_presence_of :code, :slug
   validates_format_of :code, with: /\A[a-z][a-z_]*[a-z]\z/i
@@ -20,31 +24,5 @@ class Language < ApplicationRecord
   validates_uniqueness_of :code
   validates_uniqueness_of :slug
 
-  scope :ordered_by_priority, -> { order('priority asc') }
   scope :active, -> { where(active: true) }
-
-  # @param [Integer] delta
-  def change_priority(delta)
-    new_priority = priority + delta
-    adjacent     = self.class.find_by(priority: new_priority)
-    if adjacent.is_a?(self.class) && (adjacent.id != id)
-      adjacent.update!(priority: priority)
-    end
-    update(priority: new_priority)
-
-    self.class.ordered_by_priority.map { |e| [e.id, e.priority] }.to_h
-  end
-
-  private
-
-  def set_next_priority
-    if id.nil? && priority == 1
-      self.priority = self.class.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
 end

data/app/models/metric.rb

@@ -1,8 +1,7 @@
 class Metric < ApplicationRecord
   include RequiredUniqueName
 
-  DESCRIPTION_LIMIT = 250
-  PERIOD_RANGE      = (1..365)
+  PERIOD_RANGE = (1..365).freeze
 
   METRIC_HTTP_400 = 'errors.http.bad_request.hit'
   METRIC_HTTP_401 = 'errors.http.unauthorized.hit'
@@ -15,14 +14,13 @@ class Metric < ApplicationRecord
   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)
+    %i[incremental start_with_zero show_on_dashboard default_period description]
   end
 
   # @param [String] name

data/app/models/privilege.rb

@@ -1,15 +1,16 @@
 class Privilege < ApplicationRecord
+  include Checkable
   include Toggleable
 
   DESCRIPTION_LIMIT = 350
   NAME_LIMIT        = 250
   SLUG_LIMIT        = 250
-  PRIORITY_RANGE    = (1..32767)
+  PRIORITY_RANGE    = (1..32_767).freeze
 
-  toggleable :regional, :administrative
+  toggleable :administrative
 
   belongs_to :parent, class_name: Privilege.to_s, optional: true
-  has_many :children, class_name: Privilege.to_s, foreign_key: :parent_id
+  has_many :child_privileges, 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
@@ -19,10 +20,11 @@ class Privilege < ApplicationRecord
 
   before_validation { self.name = name.strip unless name.nil? }
   before_validation { self.slug = Canonizer.transliterate(name.to_s) if slug.blank? }
-  before_validation { self.regional = true if parent&.regional? }
   before_validation :normalize_priority
 
-  before_save :compact_children_cache
+  before_save { children_cache.uniq! }
+  after_create :cache_parents!
+  after_save { parent&.cache_children! }
 
   validates_presence_of :name, :slug, :priority
   validates :name, uniqueness: { case_sensitive: false, scope: [:parent_id] }
@@ -33,7 +35,7 @@ class Privilege < ApplicationRecord
 
   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 :visible, -> { where(visible: true) }
   scope :administrative, -> { where(administrative: true) }
   scope :for_tree, ->(parent_id = nil) { where(parent_id: parent_id).ordered_by_priority }
   scope :siblings, ->(item) { where(parent_id: item.parent_id) }
@@ -44,11 +46,11 @@ class Privilege < ApplicationRecord
   end
 
   def self.entity_parameters
-    %i(administrative description name priority regional slug)
+    %i[administrative description name priority slug]
   end
 
   def self.creation_parameters
-    entity_parameters + %i(parent_id)
+    entity_parameters + %i[parent_id]
   end
 
   # @return [String]
@@ -58,7 +60,7 @@ class Privilege < ApplicationRecord
 
   # @deprecated use #subbranch_ids
   def ids
-    [id] + children_cache
+    subbranch_ids
   end
 
   # @return [Array<Integer>]
@@ -81,20 +83,20 @@ class Privilege < ApplicationRecord
 
   def cache_parents!
     return if parent.nil?
+
     self.parents_cache = "#{parent.parents_cache},#{parent_id}".gsub(/\A,/, '')
     save!
   end
 
   def cache_children!
-    children.order('id asc').map do |child|
+    child_privileges.order('id asc').each do |child|
       self.children_cache += [child.id] + child.children_cache
     end
     save!
-    parent&.cache_children!
   end
 
   def can_be_deleted?
-    children.count < 1
+    deletable? && child_privileges.count < 1
   end
 
   # @param [User] user
@@ -102,20 +104,16 @@ class Privilege < ApplicationRecord
   def has_user?(user, region_ids = [])
     return false if user.nil?
     return true if user.super_user?
-    result = user_in_non_regional_branch?(user)
 
-    if regional? && region_ids.any? && !result
-      result = user_in_regional_branch?(user, region_ids)
-    end
-    result
+    user_in_non_regional_branch?(user)
   end
 
   # @param [User] user
   # @param [Integer] region_id
   def grant(user, region_id = nil)
     return if user.nil?
-    criteria             = { privilege: self, user: user }
-    criteria[:region_id] = region_id if regional?
+
+    criteria = { privilege: self, user: user }
     UserPrivilege.create(criteria) unless UserPrivilege.exists?(criteria)
   end
 
@@ -123,8 +121,8 @@ class Privilege < ApplicationRecord
   # @param [Integer] region_id
   def revoke(user, region_id = nil)
     return if user.nil?
-    criteria             = { privilege: self, user: user }
-    criteria[:region_id] = region_id if regional?
+
+    criteria = { privilege: self, user: user }
     UserPrivilege.where(criteria).delete_all
   end
 
@@ -144,9 +142,9 @@ class Privilege < ApplicationRecord
   private
 
   def set_next_priority
-    if id.nil? && priority == 1
-      self.priority = self.class.siblings(self).maximum(:priority).to_i + 1
-    end
+    return unless id.nil? && priority == 1
+
+    self.priority = self.class.siblings(self).maximum(:priority).to_i + 1
   end
 
   def normalize_priority
@@ -154,33 +152,13 @@ class Privilege < ApplicationRecord
     self.priority = PRIORITY_RANGE.last if priority > PRIORITY_RANGE.last
   end
 
-  def compact_children_cache
-    self.children_cache.uniq!
-  end
-
   # @param [User] user
   def user_in_non_regional_branch?(user)
-    selected_ids = Privilege.where(regional: false, id: branch_ids).pluck(:id)
+    selected_ids = Privilege.where(id: branch_ids).pluck(:id)
     if selected_ids.any?
       UserPrivilege.exists?(privilege_id: selected_ids, user: user)
     else
       false
     end
   end
-
-  # @param [User] user
-  # @param [Array] region_ids
-  def user_in_regional_branch?(user, region_ids)
-    selected_ids = Privilege.where(regional: true, id: branch_ids).pluck(:id)
-    if selected_ids.any?
-      criteria = {
-        privilege_id: selected_ids,
-        region_id:    region_ids,
-        user:         user
-      }
-      UserPrivilege.exists?(criteria)
-    else
-      false
-    end
-  end
 end