comunit-base 0.37.200628.0

data/app/models/privilege.rb

@@ -0,0 +1,188 @@
+class Privilege < ApplicationRecord
+  include Checkable
+  include Toggleable
+
+  DESCRIPTION_LIMIT = 350
+  NAME_LIMIT        = 250
+  SLUG_LIMIT        = 250
+  PRIORITY_RANGE    = (1..32_767)
+
+  toggleable :regional, :administrative
+
+  belongs_to :parent, class_name: Privilege.to_s, optional: true
+  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
+  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 { self.regional = true if parent&.regional? }
+  before_validation :normalize_priority
+
+  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] }
+  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) }
+  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) }
+  scope :list_for_administration, -> { ordered_by_name }
+
+  def self.page_for_administration
+    ordered_by_name
+  end
+
+  def self.entity_parameters
+    %i[administrative description name priority regional slug]
+  end
+
+  def self.creation_parameters
+    entity_parameters + %i[parent_id]
+  end
+
+  # @return [String]
+  def full_title
+    (parents.map(&:name) + [name]).join ' / '
+  end
+
+  # @deprecated use #subbranch_ids
+  def ids
+    subbranch_ids
+  end
+
+  # @return [Array<Integer>]
+  def subbranch_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!
+    return if parent.nil?
+
+    self.parents_cache = "#{parent.parents_cache},#{parent_id}".gsub(/\A,/, '')
+    save!
+  end
+
+  def cache_children!
+    child_privileges.order('id asc').each do |child|
+      self.children_cache += [child.id] + child.children_cache
+    end
+    save!
+  end
+
+  def can_be_deleted?
+    deletable? && child_privileges.count < 1
+  end
+
+  # @param [User] user
+  # @param [Array] region_ids
+  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
+  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?
+    UserPrivilege.create(criteria) unless UserPrivilege.exists?(criteria)
+  end
+
+  # @param [User] user
+  # @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?
+    UserPrivilege.where(criteria).delete_all
+  end
+
+  # @param [Integer] delta
+  def change_priority(delta)
+    new_priority = priority + delta
+    criteria     = { priority: new_priority }
+    adjacent     = self.class.siblings(self).find_by(criteria)
+    if adjacent.is_a?(self.class) && (adjacent.id != id)
+      adjacent.update!(priority: priority)
+    end
+    update(priority: new_priority)
+
+    self.class.for_tree(parent_id).map { |e| [e.id, e.priority] }.to_h
+  end
+
+  private
+
+  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
+    self.priority = PRIORITY_RANGE.first if priority < PRIORITY_RANGE.first
+    self.priority = PRIORITY_RANGE.last if priority > PRIORITY_RANGE.last
+  end
+
+  # @param [User] user
+  def user_in_non_regional_branch?(user)
+    selected_ids = Privilege.where(regional: false, 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

data/app/models/promo_block.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+class PromoBlock < ApplicationRecord
+  include Checkable
+  include Toggleable
+  include RequiredUniqueSlug
+
+  DESCRIPTION_LIMIT = 250
+  NAME_LIMIT        = 50
+  SLUG_LIMIT        = 50
+  SLUG_PATTERN      = /\A[a-z0-9][-_a-z0-9]*[a-z0-9]\z/.freeze
+  SLUG_PATTERN_HTML = '^[a-zA-Z0-9][-_a-zA-Z0-9]*[a-zA-Z0-9]$'
+
+  toggleable :visible
+
+  belongs_to :language, optional: true
+  has_many :promo_items, dependent: :destroy
+
+  before_validation { self.slug = slug.downcase unless slug.nil? }
+  validates_length_of :description, maximum: DESCRIPTION_LIMIT
+  validates_length_of :name, maximum: NAME_LIMIT
+  validates_format_of :slug, with: SLUG_PATTERN
+  validates_length_of :slug, maximum: SLUG_LIMIT
+
+  scope :visible, -> { where(visible: true) }
+  scope :list_for_administration, -> { ordered_by_slug }
+
+  # @param [String] slug
+  # @param [String] language_code
+  def self.localized_block(slug, language_code)
+    language = Language.find_by(code: language_code)
+    criteria = { visible: true, slug: slug }
+    find_by(criteria.merge(language: language)) || find_by(criteria)
+  end
+
+  def self.entity_parameters
+    %i[description language_id name slug visible]
+  end
+
+  # @param [User] user
+  def editable_by?(user)
+    UserPrivilege.user_has_privilege?(user, :promo_manager)
+  end
+
+  # @return [PromoItem]
+  def item_for_visitors
+    promo_items.list_for_visitors.order('random()').first
+  end
+end

data/app/models/promo_item.rb

@@ -0,0 +1,36 @@
+class PromoItem < ApplicationRecord
+  include Checkable
+  include HasOwner
+  include Toggleable
+
+  CODE_LIMIT  = 5000
+  LEAD_LIMIT  = 250
+  META_LIMIT  = 250
+  NAME_LIMIT  = 50
+  TITLE_LIMIT = 100
+  URL_LIMIT   = 250
+
+  toggleable :visible
+
+  mount_uploader :image, PromoImageUploader
+
+  belongs_to :promo_block, counter_cache: true
+  belongs_to :user
+  belongs_to :agent, optional: true
+
+  validates_presence_of :name
+  validates_length_of :code, maximum: CODE_LIMIT
+  validates_length_of :lead, maximum: LEAD_LIMIT
+  validates_length_of :name, maximum: NAME_LIMIT
+  validates_length_of :title, maximum: TITLE_LIMIT
+  validates_length_of :url, maximum: URL_LIMIT
+
+  scope :ordered_by_views, -> { order('view_count desc') }
+  scope :visible, -> { where(visible: true) }
+  scope :list_for_administration, -> { order('id desc') }
+  scope :list_for_visitors, -> { visible }
+
+  def self.entity_parameters
+    %i[code image image_alt_text lead name promo_block_id title url]
+  end
+end

data/app/models/region.rb

@@ -0,0 +1,149 @@
+# frozen_string_literal: true
+
+# Region
+#
+# Attributes:
+#   children_cache [Array<integer>]
+#   country_id [Country], optional
+#   created_at [DateTime]
+#   data [json]
+#   header_image [SimpleImageUploader], optional
+#   latitude [float]
+#   locative [string], optional
+#   long_slug [string]
+#   longitude [float]
+#   map_geometry [text], optional
+#   name [string]
+#   parent_id [Region], optional
+#   parents_cache [string]
+#   posts_count [integer]
+#   short_name [string], optional
+#   slug [string]
+#   svg_geometry [text], optional
+#   users_count [integer]
+#   visible [boolean]
+class Region < ApplicationRecord
+  include NestedPriority
+  include Toggleable
+
+  toggleable :visible
+
+  mount_uploader :header_image, SimpleImageUploader
+
+  belongs_to :country, optional: true, counter_cache: true
+  belongs_to :parent, class_name: Region.to_s, optional: true
+  has_many :child_regions, class_name: Region.to_s, foreign_key: :parent_id
+
+  validates_presence_of :long_slug, :name, :slug
+
+  scope :ordered_by_slug, -> { order('slug asc') }
+  scope :ordered_by_name, -> { order('name asc') }
+  scope :visible, -> { where(visible: true) }
+  scope :with_posts, -> { where('posts_count > 0') }
+  scope :only_with_ids, ->(v) { where(id: v) unless v.nil? }
+  scope :for_tree, ->(country_id = nil, parent_id = nil) { where(parent_id: parent_id).ordered_by_name }
+
+  # @param [Region] item
+  def self.siblings(item)
+    where(country_id: item&.country_id, parent_id: item&.parent_id)
+  end
+
+  def self.entity_parameters
+    %i[header_image priority visible]
+  end
+
+  def self.synchronization_parameters
+    ignored = %w[header_image users_count]
+
+    column_names.reject { |c| ignored.include?(c) }
+  end
+
+  # Post moved to other region
+  #
+  # Decrements posts_count for region with old_id and increments for new_id
+  #
+  # @param [Integer|nil] old_id
+  # @param [Integer|nil] new_id
+  def self.update_post_count(old_id, new_id)
+    part = 'update regions set posts_count = posts_count'
+    unless new_id.nil?
+      region = find(new_id)
+      connection.execute("#{part} + 1 where id in (#{region.branch_ids.join(',')})")
+    end
+    return if old_id.nil?
+
+    region = find(old_id)
+    connection.execute("#{part} - 1 where id in (#{region.branch_ids.join(',')})")
+  end
+
+  # @param [User] user
+  def editable_by?(user)
+    Biovision::Components::RegionsComponent.allow?(user, 'manager')
+  end
+
+  def parents
+    return [] if parents_cache.blank?
+
+    Region.where(id: parent_ids).order('id asc')
+  end
+
+  def parent_ids
+    parents_cache.split(',').compact
+  end
+
+  # @return [Array<Integer>]
+  def branch_ids
+    parents_cache.split(',').map(&:to_i).reject { |i| i < 1 }.uniq + [id]
+  end
+
+  # @return [Array<Integer>]
+  def subbranch_ids
+    [id] + children_cache
+  end
+
+  def depth
+    parent_ids.count
+  end
+
+  def long_name
+    return name if parents.blank?
+
+    "#{parents.map(&:name).join('/')}/#{name}"
+  end
+
+  def branch_name
+    return short_name if parents.blank?
+
+    "#{parents.map(&:short_name).join('/')}/#{short_name}"
+  end
+
+  def cache_parents!
+    return if parent.nil?
+
+    self.parents_cache = "#{parent.parents_cache},#{parent_id}".gsub(/\A,/, '')
+    save!
+  end
+
+  # @param [Array] new_cache
+  def cache_children!(new_cache = [])
+    if new_cache.blank?
+      new_cache = child_regions.order('id asc').pluck(:id, :children_cache)
+    end
+
+    self.children_cache += [new_cache.flatten]
+    self.children_cache.uniq!
+
+    save!
+    parent&.cache_children!([id] + children_cache)
+  end
+
+  # @param [User] user
+  def add_user(user)
+    RegionUser.create(region: self, user: user)
+  end
+
+  # @param [User] user
+  def remove_user(user)
+    RegionUser.where(region: self, user: user).delete_all
+  end
+end

data/app/models/region_user.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+# Allowed region for user
+#
+# Attributes:
+#   created_at [DateTime]
+#   region_id [Region], optional
+#   updated_at [DateTime]
+#   user_id [User]
+class RegionUser < ApplicationRecord
+  include HasOwner
+
+  belongs_to :region, optional: true
+  belongs_to :user
+
+  validates_uniqueness_of :region_id, scope: :user_id
+
+  scope :recent, -> { order('id desc') }
+
+  # @param [User] user
+  def self.allowed_region_ids(user)
+    region_ids = owned_by(user).pluck(:region_id)
+
+    return [] if region_ids.empty?
+
+    Region.where(id: region_ids).pluck(:children_cache).flatten.uniq
+  end
+end