comunit-base 0.37.200628.0

data/app/models/event_sponsor.rb

@@ -0,0 +1,69 @@
+class EventSponsor < ApplicationRecord
+  include Toggleable
+
+  NAME_LIMIT     = 100
+  URL_LIMIT      = 250
+  PRIORITY_LIMIT = (1..999)
+
+  toggleable :visible
+
+  belongs_to :event
+
+  mount_uploader :image, EventSponsorImageUploader
+
+  after_initialize :set_next_priority
+
+  before_validation :normalize_priority
+  validates_presence_of :name
+  validates_length_of :name, maximum: NAME_LIMIT
+  validates_length_of :url, maximum: URL_LIMIT
+
+  scope :siblings, ->(event) { where(event: event) }
+  scope :ordered_by_priority, -> { order('priority asc, name asc') }
+  scope :visible, -> { where(visible: true) }
+
+  def self.page_for_administration
+    ordered_by_priority
+  end
+
+  def self.page_for_visitors
+    visible.ordered_by_priority
+  end
+
+  def self.entity_parameters
+    %i(image name url visible priority)
+  end
+
+  def self.creation_parameters
+    entity_parameters + %i(event_id)
+  end
+
+  def locked?
+    event.locked?
+  end
+
+  # @param [Integer] delta
+  def change_priority(delta)
+    new_priority = priority + delta
+    adjacent     = EventSponsor.siblings(event).find_by(priority: new_priority)
+    if adjacent.is_a?(EventSponsor) && (adjacent.id != id)
+      adjacent.update!(priority: priority)
+    end
+    self.update(priority: new_priority)
+
+    EventSponsor.siblings(event).ordered_by_priority.map { |e| [e.id, e.priority] }.to_h
+  end
+
+  private
+
+  def set_next_priority
+    if id.nil? && priority == 1
+      self.priority = EventSponsor.siblings(event).maximum(:priority).to_i + 1
+    end
+  end
+
+  def normalize_priority
+    self.priority = PRIORITY_LIMIT.first if priority < PRIORITY_LIMIT.first
+    self.priority = PRIORITY_LIMIT.last if priority > PRIORITY_LIMIT.last
+  end
+end

data/app/models/featured_post.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+# Featured post
+class FeaturedPost < ApplicationRecord
+  include NestedPriority
+
+  PRIORITY_RANGE = (1..100).freeze
+
+  belongs_to :language
+  belongs_to :post
+
+  validates_uniqueness_of :post_id, scope: :language_id
+
+  scope :ordered_by_priority, -> { order 'priority asc, id desc' }
+  scope :list_for_language, ->(language) { where(language: language).ordered_by_priority }
+
+  def self.siblings(entity)
+    where(language_id: entity.language_id)
+  end
+end

data/app/models/group.rb

@@ -0,0 +1,34 @@
+class Group < ApplicationRecord
+  include RequiredUniqueName
+  include RequiredUniqueSlug
+
+  DESCRIPTION_LIMIT = 350
+
+  has_many :user_groups, dependent: :destroy
+  has_many :users, through: :user_groups
+
+  validates_length_of :description, maximum: DESCRIPTION_LIMIT
+
+  def self.page_for_administration
+    ordered_by_name
+  end
+
+  def self.entity_parameters
+    %i(name slug description)
+  end
+
+  # @param [User] user
+  def has_user?(user)
+    user_groups.where(user: user).exists?
+  end
+
+  # @param [User] user
+  def add_user(user)
+    UserGroup.find_or_create_by(user: user, group: self)
+  end
+
+  # @param [User] user
+  def remove_user(user)
+    user_groups.where(user: user).destroy_all
+  end
+end

data/app/models/illustration.rb

@@ -0,0 +1,11 @@
+class Illustration < ApplicationRecord
+  include HasOwner
+
+  belongs_to :user, optional: true
+
+  mount_uploader :image, IllustrationImageUploader
+
+  def self.entity_parameters
+    %i(name image)
+  end
+end

data/app/models/news.rb

@@ -0,0 +1,110 @@
+class News < ApplicationRecord
+  # include Elasticsearch::Model
+  # include Elasticsearch::Model::Callbacks
+  include HasOwner
+  include Toggleable
+
+  PER_PAGE = 20
+  LEAD_LIMIT = 350
+
+  # index_name Rails.configuration.news_index_name
+
+  toggleable :visible, :show_name, :approved, :allow_comments
+
+  mount_uploader :image, PostImageUploader
+
+  belongs_to :user
+  belongs_to :agent, optional: true
+  belongs_to :region, optional: true
+  belongs_to :news_category, counter_cache: :items_count
+  belongs_to :entry, optional: true
+  # has_many :figures, dependent: :destroy
+  has_many :comments, as: :commentable, dependent: :destroy
+
+  enum post_type: [:news, :comment, :topic]
+
+  before_validation :generate_slug
+
+  validates_presence_of :post_type, :title, :slug, :lead, :body
+
+  scope :popular, -> { order 'view_count desc' }
+  scope :in_region, -> (region) { where(region_id: region.id.nil? ? nil : region&.subbranch_ids) }
+  scope :in_category, -> (category) { where(news_category: category) }
+  scope :with_category_ids, -> (ids) { where(news_category_id: Array(ids)) }
+  scope :of_type, -> (type) { where post_type: News.post_types[type] }
+  scope :recent, -> { order 'created_at desc' }
+  scope :visible, -> { where visible: true, deleted: false }
+  scope :federal, -> { where region_id: nil }
+
+  # @param [Integer] page
+  def self.page_for_administration(page)
+    recent.page(page).per(PER_PAGE)
+  end
+
+  # @param [Integer] page
+  def self.page_for_visitors(page)
+    visible.recent.page(page).per(PER_PAGE)
+  end
+
+  # @param [User] user
+  # @param [Integer] page
+  def self.page_for_owner(user, page)
+    owned_by(user).where(deleted: false).recent.page(page).per(PER_PAGE)
+  end
+
+  # @param [Region] selected_region
+  # @param [Region] excluded_region
+  def self.regional(selected_region = nil, excluded_region = nil)
+    excluded_ids = Array(excluded_region&.subbranch_ids)
+    if selected_region.nil?
+      chunk = excluded_ids.any? ? where('region_id not in (?)', excluded_ids) : where('region_id is not null')
+    else
+      chunk = where(region_id: selected_region.subbranch_ids - excluded_ids)
+    end
+    chunk
+  end
+
+  def self.repost_parameters
+    for_image = %i(image image_name image_author_name image_author_link)
+    for_image + %i(lead region_id news_category_id show_name source source_link)
+  end
+
+  def self.entity_parameters
+    for_author = %i(author_name author_title author_url)
+    for_meta   = %i(meta_title meta_keywords meta_description)
+    basic_data = %i(title body post_type slug visible translation)
+    repost_parameters + for_author + for_meta + basic_data
+  end
+
+  def category
+    self.news_category
+  end
+
+  def regional?
+    region_id.to_i > 0
+  end
+
+  # @param [User] user
+  def editable_by?(user)
+    !deleted? && !locked? && (owned_by?(user) || UserPrivilege.user_has_privilege?(user, :chief_editor))
+  end
+
+  # @param [User] user
+  def commentable_by?(user)
+    visible? && !deleted? && user.is_a?(User)
+  end
+
+  # @param [User] user
+  def visible_to?(user)
+    visible? || editable_by?(user)
+  end
+
+  private
+
+  def generate_slug
+    if slug.blank?
+      postfix   = (created_at || Time.now).strftime('%d%m%Y')
+      self.slug = "#{Canonizer.transliterate(title.to_s)}_#{postfix}"
+    end
+  end
+end

data/app/models/news_category.rb

@@ -0,0 +1,60 @@
+class NewsCategory < ApplicationRecord
+  include Toggleable
+  include RequiredUniqueName
+
+  toggleable :visible
+
+  has_many :news
+
+  after_initialize :set_next_priority
+
+  before_validation { self.slug = Canonizer.transliterate(name.to_s) if slug.blank? }
+
+  validates_presence_of :slug, :priority
+  validates_uniqueness_of :slug
+
+  scope :ordered_by_priority, -> { order 'priority asc' }
+  scope :visible, -> { where visible: true, deleted: false }
+  scope :for_editor, ->(user) { where(deleted: false).ordered_by_priority }
+
+  def self.page_for_administration
+    ordered_by_priority
+  end
+
+  def self.page_for_visitors
+    visible.ordered_by_priority
+  end
+
+  def self.entity_parameters
+    %i(name slug priority visible)
+  end
+
+  # @param [News] news
+  def has_news?(news)
+    news.news_category == self
+  end
+
+  def full_title
+    name
+  end
+
+  # @param [Integer] delta
+  def change_priority(delta)
+    new_priority = priority + delta
+    adjacent     = NewsCategory.find_by(priority: new_priority)
+    if adjacent.is_a?(NewsCategory) && (adjacent.id != id)
+      adjacent.update!(priority: priority)
+    end
+    self.update(priority: new_priority)
+
+    NewsCategory.ordered_by_priority.map { |e| [e.id, e.priority] }.to_h
+  end
+
+  private
+
+  def set_next_priority
+    if id.nil? && priority == 1
+      self.priority = NewsCategory.maximum(:priority).to_i + 1
+    end
+  end
+end

data/app/models/notification.rb

@@ -0,0 +1,64 @@
+class Notification < ApplicationRecord
+  include HasOwner
+
+  PER_PAGE = 10
+
+  belongs_to :user
+
+  enum category: [:new_message, :new_follower, :entry_comment, :post_comment, :news_comment]
+
+  validates_presence_of :category
+
+  scope :unread, -> { where(read_by_user: false) }
+  scope :recent, -> { order('id desc') }
+
+  # @param [User] user
+  # @param [Integer] page
+  def self.page_for_owner(user, page)
+    owned_by(user).recent.page(page).per(PER_PAGE)
+  end
+
+  # @param [User] user
+  # @param [Integer] category
+  # @param [Integer] payload
+  def self.notify(user, category, payload)
+    criteria = { user: user, category: category, payload: payload }
+    instance = unread.find_by(criteria)
+    if instance.nil?
+      create!(criteria)
+    else
+      instance.increment! :repetition_count
+    end
+  end
+
+  # @param [ApplicationRecord] entity
+  def self.category_from_object(entity)
+    case entity.class.to_s
+      when UserMessage.to_s
+        categories[:new_message]
+      when UserLink.to_s
+        categories[:new_follower]
+      when Entry.to_s
+        categories[:entry_comment]
+      when Post.to_s
+        categories[:post_comment]
+      when News.to_s
+        categories[:news_comment]
+      else
+        nil
+    end
+  end
+
+  def payload_object
+    case category.to_sym
+      when :entry_comment
+        Entry.find_by(id: payload)
+      when :post_comment
+        Post.find_by(id: payload)
+      when :news_comment
+        News.find_by(id: payload)
+      else
+        User.find_by(id: payload)
+    end
+  end
+end

data/app/models/photo.rb

@@ -0,0 +1,53 @@
+class Photo < ApplicationRecord
+  PER_PAGE = 20
+
+  mount_uploader :image, PhotoUploader
+
+  belongs_to :album, counter_cache: true
+
+  after_initialize { self.uuid = SecureRandom.uuid if uuid.nil? }
+  after_initialize :set_next_priority
+
+  validates_presence_of :name, :image, :description
+
+  scope :ordered_by_priority, -> { order('priority asc, name asc') }
+  scope :siblings, ->(item) { where(album: item&.album) }
+
+  # @param [Integer] page
+  def self.page_for_administration(page = 1)
+    ordered_by_priority.page(page).per(PER_PAGE)
+  end
+
+  # @param [Integer] page
+  def self.page_for_visitors(page = 1)
+    ordered_by_priority.page(page).per(PER_PAGE)
+  end
+
+  def self.entity_parameters
+    %i(image name description)
+  end
+
+  def self.creation_parameters
+    entity_parameters + %i(album_id)
+  end
+
+  # @param [Integer] delta
+  def change_priority(delta)
+    new_priority = priority + delta
+    adjacent     = Photo.siblings(self).find_by(priority: new_priority)
+    if adjacent.is_a?(Photo) && (adjacent.id != id)
+      adjacent.update!(priority: priority)
+    end
+    update(priority: new_priority)
+
+    Photo.siblings(self).map { |e| [e.id, e.priority] }.to_h
+  end
+
+  private
+
+  def set_next_priority
+    if id.nil? && priority == 1
+      self.priority = Photo.siblings(self).maximum(:priority).to_i + 1
+    end
+  end
+end

data/app/models/political_force.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+# Political force
+#
+# Attributes:
+#   candidates_count [integer]
+#   created_at [DateTime]
+#   data [jsonb]
+#   flare [string], optional
+#   image [string], optional
+#   name [string]
+#   slug [string]
+#   sync_state [JSON]
+#   updated_at [DateTime]
+#   uuid [UUID]
+class PoliticalForce < ApplicationRecord
+  include Checkable
+  include RequiredUniqueName
+  include RequiredUniqueSlug
+
+  FLARE_LIMIT = 20
+  NAME_LIMIT = 100
+  SLUG_LIMIT = 20
+  SLUG_PATTERN = /\A[a-z][-_a-z]+[a-z]\z/.freeze
+  SLUG_PATTERN_HTML = '^[a-zA-Z][-_a-zA-Z]+[a-zA-Z]$'
+
+  mount_uploader :image, SimpleImageUploader
+
+  has_many :candidate_political_forces, dependent: :delete_all
+  has_many :candidates, through: :candidate_political_forces
+
+  after_initialize { self.uuid = SecureRandom.uuid if uuid.nil? }
+
+  before_validation { self.slug = slug.to_s.downcase }
+  validates_uniqueness_of :uuid
+  validates_length_of :flare, maximum: FLARE_LIMIT
+  validates_length_of :name, maximum: NAME_LIMIT
+  validates_length_of :slug, maximum: SLUG_LIMIT
+  validates_format_of :slug, with: SLUG_PATTERN
+
+  scope :list_for_visitors, -> { ordered_by_name }
+  scope :list_for_administration, -> { ordered_by_name }
+
+  def self.entity_parameters
+    %i[flare image name slug]
+  end
+
+  # @param [Candidate] entity
+  def candidate?(entity)
+    candidate_political_forces.where(candidate: entity).exists?
+  end
+
+  # @param [Candidate] entity
+  def add_candidate(entity)
+    candidate_political_forces.create(candidate: entity)
+  end
+
+  # @param [Candidate] entity
+  def remove_candidate(entity)
+    candidate_political_forces.where(candidate: entity).destroy_all
+  end
+end