comunit-base 0.37.200628.0

data/app/models/candidate.rb

@@ -0,0 +1,144 @@
+# frozen_string_literal: true
+
+# Candidate for election campaign
+#
+# Attributes:
+#   about [text], optional
+#   agent_id [Agent], optional
+#   approved [boolean]
+#   birthday [date]
+#   campaign_id [Campaign]
+#   created_at [DateTime]
+#   data [JSON]
+#   details_url [String]
+#   image [SimpleImageUploader]
+#   ip [Inet]
+#   lead [text]
+#   name [string]
+#   patronymic [string], optional
+#   program [text], optional
+#   region_id [Region], optional
+#   supports_impeachment [Boolean]
+#   surname [string]
+#   sync_state [JSON]
+#   updated_at [DateTime]
+#   user_id [User], optional
+#   uuid [uuid]
+#   visible [boolean]
+class Candidate < ApplicationRecord
+  include Checkable
+  include Toggleable
+  include HasOwner
+
+  ABOUT_LIMIT = 65_535
+  LEAD_LIMIT = 500
+  NAME_LIMIT = 50
+  URL_LIMIT = 255
+
+  toggleable :visible, :approved, :supports_impeachment
+
+  mount_uploader :image, SimpleImageUploader
+
+  belongs_to :agent, optional: true
+  belongs_to :campaign, counter_cache: true
+  belongs_to :region, optional: true
+  belongs_to :user, optional: true
+  has_many :candidate_political_forces, dependent: :destroy
+  has_many :political_forces, through: :candidate_political_forces
+
+  after_initialize { self.uuid = SecureRandom.uuid if uuid.nil? }
+
+  validates_presence_of :birthday, :lead, :name, :surname
+  validates_uniqueness_of :uuid
+  validates_length_of :about, maximum: ABOUT_LIMIT
+  validates_length_of :details_url, maximum: URL_LIMIT
+  validates_length_of :lead, maximum: LEAD_LIMIT
+  validates_length_of :name, maximum: NAME_LIMIT
+  validates_length_of :patronymic, maximum: NAME_LIMIT
+  validates_length_of :surname, maximum: NAME_LIMIT
+
+  scope :visible, -> { where(approved: true, visible: true) }
+  scope :ordered_by_surname, -> { order('surname asc, name asc, patronymic asc') }
+  scope :list_for_visitors, -> { visible.ordered_by_surname }
+  scope :list_for_administration, -> { ordered_by_surname }
+  scope :surname_like, ->(v) { where('surname ilike ?', "%#{v}%") unless v.blank? }
+  scope :with_force, ->(v) { joins(:candidate_political_forces).where(candidate_political_forces: { political_force_id: v }) unless v.blank? }
+  scope :filtered, ->(f) { surname_like(f[:surname]).with_force(f[:force]) }
+
+  def self.entity_parameters(as_user = false)
+    usual = %i[about birthday image lead name patronymic program region_id surname]
+    extended = %i[approved supports_impeachment visible]
+
+    as_user ? usual : usual + extended
+  end
+
+  def self.creation_parameters(as_user = false)
+    entity_parameters(as_user) + %i[campaign_id]
+  end
+
+  # @param [TrueClass|FalseClass] use_patronymic
+  def full_name(use_patronymic = false)
+    parts = [surname, name]
+    parts << patronymic if use_patronymic
+
+    parts.join(' ')
+  end
+
+  def image_alt_text
+    full_name(true)
+  end
+
+  def age
+    return 0 if birthday.blank?
+
+    now = Time.now
+    result = now.year - birthday.year
+    result -= 1 if birthday.month > now.month || (birthday.month >= now.month && birthday.day > now.day)
+    result
+  end
+
+  def assign_data_from_user
+    return if user.nil?
+
+    profile = user.data['profile'] || {}
+    new_data = {
+      name: profile['name'],
+      patronymic: profile['patronymic'],
+      surname: profile['surname'],
+      birthday: user.data['birthday']
+    }
+
+    assign_attributes(new_data)
+  end
+
+  # @param [User] user
+  # @param [String] role
+  def user?(user, role)
+    candidate_users.where(user: user).with_role(role).exists?
+  end
+
+  # @param [User] user
+  # @param [String] role
+  def team_membership_available?(user, role)
+    return false if user.nil?
+
+    !user?(user, role)
+  end
+
+  # @param [User] user
+  # @param [String] role
+  def add_user(user, role = nil)
+    return if user.nil?
+    return unless CandidateUser::ROLES.include?(role)
+
+    instance = candidate_users.find_or_initialize_by(user: user)
+    instance.data['roles'] ||= {}
+    instance.data['roles'][role] = true
+
+    instance.save
+  end
+
+  def url
+    "/campaigns/#{campaign.slug}/candidate-#{id}"
+  end
+end

data/app/models/candidate_political_force.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+# Link between candidate and political force
+#
+# Attributes:
+#   candidate_id [Candidate]
+#   created_at [DateTime]
+#   political_force_id [PoliticalForce]
+#   updated_at [DateTime]
+class CandidatePoliticalForce < ApplicationRecord
+  belongs_to :candidate
+  belongs_to :political_force, counter_cache: :candidates_count
+
+  validates_uniqueness_of :political_force_id, scope: :candidate_id
+end

data/app/models/central_region.rb

@@ -0,0 +1,53 @@
+class CentralRegion
+  def id
+    nil
+  end
+
+  def name
+    I18n.t('activerecord.attributes.central_region.name')
+  end
+
+  def short_name
+    I18n.t('activerecord.attributes.central_region.short_name')
+  end
+
+  def locative
+    I18n.t('activerecord.attributes.central_region.locative')
+  end
+
+  def slug
+    ''
+  end
+
+  def long_slug
+    ''
+  end
+
+  def image
+    nil
+  end
+
+  def header_image
+    nil
+  end
+
+  def parents
+    []
+  end
+
+  def parent
+    nil
+  end
+
+  def parent_id
+    nil
+  end
+
+  def child_regions
+    []
+  end
+
+  def subbranch_ids
+    []
+  end
+end

data/app/models/concerns/post_child_with_priority.rb

@@ -0,0 +1,49 @@
+module PostChildWithPriority
+  extend ActiveSupport::Concern
+
+  included do
+    belongs_to :post
+
+    after_initialize :set_next_priority
+    before_validation :normalize_priority
+
+    scope :siblings, ->(entity) { where(post_id: entity.post_id) }
+    scope :ordered_by_priority, -> { order 'priority asc, id desc' }
+
+    def self.priority_range
+      (1..32767)
+    end
+
+    # @param [User] user
+    def editable_by?(user)
+      post.editable_by?(user)
+    end
+
+    # @param [Integer] delta
+    def change_priority(delta)
+      new_priority = priority + delta
+      criteria     = { post_id: post_id, priority: new_priority }
+      adjacent     = self.class.find_by(criteria)
+      if adjacent.is_a?(self.class) && (adjacent.id != id)
+        adjacent.update!(priority: priority)
+      end
+      self.update(priority: new_priority)
+
+      self.class.siblings(self).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.siblings(self).maximum(:priority).to_i + 1
+      end
+    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
+end

data/app/models/country.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+# Country.
+#
+# Only visibility and priority are available for editing. Primary model data
+# is in central site.
+#
+# Attributes:
+#   created_at [DateTime]
+#   locative [string]
+#   name [string]
+#   priority [integer]
+#   regions_count [integer]
+#   short_name [string]
+#   slug [string]
+#   updated_at [DateTime]
+#   visible [boolean]
+class Country < ApplicationRecord
+  include FlatPriority
+  include Toggleable
+
+  toggleable :visible
+
+  has_many :regions, dependent: :delete_all
+
+  scope :visible, -> { where(visible: true) }
+  scope :list_for_visitors, -> { visible.ordered_by_priority }
+  scope :list_for_administration, -> { ordered_by_priority }
+
+  def self.entity_parameters
+    %i[visible priority]
+  end
+end

data/app/models/decision.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+# Decision to make
+#
+# Attributes:
+#   active [boolean]
+#   answers [jsonb]
+#   body [text]
+#   created_at [DateTime]
+#   data [jsonb]
+#   end_date [date]
+#   name [string]
+#   simple_image_id [SimpleImage]
+#   updated_at [DateTime]
+#   uuid [uuid]
+#   visible [boolean]
+class Decision < ApplicationRecord
+  include Checkable
+  include HasSimpleImage
+  include HasUuid
+  include Toggleable
+
+  NAME_LIMIT = 250
+
+  toggleable :active, :visible
+
+  validates_presence_of :body, :name
+  validates_length_of :name, maximum: NAME_LIMIT
+
+  scope :visible, -> { where(visible: true) }
+  scope :recent, -> { order('id desc') }
+  scope :list_for_visitors, -> { visible.recent }
+  scope :list_for_administration, -> { recent }
+
+  def self.entity_parameters
+    %i[active body end_date name simple_image_id visible]
+  end
+end

data/app/models/decision_user.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+# Decision by user
+#
+# Attributes:
+#   agent_id [Agent], optional
+#   answer [uuid]
+#   created_at [DateTime]
+#   data [jsonb]
+#   decision_id [Decision]
+#   ip [inet]
+#   region_id [Region], optional
+#   updated_at [DateTime]
+#   user_id [User]
+class DecisionUser < ApplicationRecord
+  include HasOwner
+
+  belongs_to :agent, optional: true
+  belongs_to :decision
+  belongs_to :region, optional: true
+  belongs_to :user
+
+  validates_presence_of :answer
+  validates_uniqueness_of :decision_id, scope: :user_id
+end

data/app/models/deed.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+# Deed offer of request
+#
+# Attributes:
+#   agent_id [Agent]
+#   comments_count [Integer]
+#   created_at [DateTime]
+#   data [JSON]
+#   description [Text], optional
+#   done [Boolean]
+#   image [SimpleImageUploader]
+#   ip [Inet]
+#   offer [Boolean]
+#   region_id [Region], optional
+#   title [String]
+#   updated_at [DateTime]
+#   user_id [User]
+#   uuid [UUID]
+#   view_count [Integer]
+#   visible [Boolean]
+class Deed < ApplicationRecord
+  include Checkable
+  include HasOwner
+  include HasUuid
+  include Toggleable
+
+  DESCRIPTION_LIMIT = 65_535
+  TITLE_LIMIT = 255
+
+  toggleable :done, :offer, :visible
+
+  mount_uploader :image, SimpleImageUploader
+
+  belongs_to :user
+  belongs_to :region, optional: true
+  belongs_to :agent, optional: true
+  has_many :deed_images, dependent: :destroy
+  has_many :comments, as: :commentable, dependent: :delete_all
+  has_many :deed_deed_categories, dependent: :destroy
+  has_many :deed_categories, through: :deed_deed_categories
+
+  validates_presence_of :title, :description
+  validates_length_of :description, maximum: DESCRIPTION_LIMIT
+  validates_length_of :title, maximum: TITLE_LIMIT
+
+  scope :recent, -> { order('id desc') }
+  scope :visible, -> { where(visible: true) }
+  scope :offers, -> { where(offer: true) }
+  scope :requests, -> { where(offer: false) }
+  scope :list_for_visitors, -> { visible.recent }
+  scope :list_for_administration, -> { recent }
+
+  # @param [Integer] page
+  def self.page_for_administration(page = 1)
+    list_for_administration.page(page)
+  end
+
+  # @param [Integer] page
+  def self.page_for_visitors(page = 1)
+    list_for_visitors.page(page)
+  end
+
+  # @param [User] user
+  # @param [Integer] page
+  def self.page_for_owner(user, page = 1)
+    owned_by(user).recent.page(page)
+  end
+
+  def self.entity_parameters
+    %i[description done image offer region_id title]
+  end
+
+  # @param [User] user
+  def commentable_by?(user)
+    !user.nil?
+  end
+end

data/app/models/deed_category.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+# Deed category
+#
+# Attributes:
+#   children_cache [Array<Integer>]
+#   created_at [DateTime]
+#   data [JSON]
+#   deeds_count [Integer]
+#   name [String]
+#   parent_id [DeedCategory], optional
+#   parents_cache [String]
+#   priority [Integer]
+#   updated_at [DateTime]
+#   uuid [UUID]
+#   visible [Boolean]
+class DeedCategory < ApplicationRecord
+  include Checkable
+  include HasUuid
+  include NestedPriority
+  include Toggleable
+
+  NAME_LIMIT = 75
+
+  toggleable :visible
+
+  belongs_to :parent, class_name: DeedCategory.to_s, optional: true
+  has_many :child_categories, class_name: DeedCategory.to_s, foreign_key: :parent_id
+  has_many :deed_deed_categories, dependent: :delete_all
+  has_many :deeds, through: :deed_deed_categories
+
+  before_save { children_cache.uniq! }
+  after_create :cache_parents!
+  after_save { parent&.cache_children! }
+
+  validates_length_of :name, maximum: NAME_LIMIT
+  validates_presence_of :name
+  validates_uniqueness_of :name, scope: :parent_id
+
+  scope :visible, -> { where(visible: true) }
+  scope :list_for_visitors, -> { visible.ordered_by_priority }
+  scope :list_for_administration, -> { ordered_by_priority }
+
+  # @param [DeedCategory] entity
+  def self.siblings(entity)
+    where(parent_id: entity&.parent_id)
+  end
+
+  def self.entity_parameters
+    %i[name priority visible]
+  end
+
+  def self.creation_parameters
+    entity_parameters + %i[parent_id]
+  end
+
+  # @param [Deed] deed
+  def deed?(deed)
+    deed_deed_categories.where(deed: deed).exists?
+  end
+
+  # @param [Deed] deed
+  def add_deed(deed)
+    deed_deed_categories.create(deed: deed)
+  end
+
+  # @param [Deed] deed
+  def remove_deed(deed)
+    deed_deed_categories.where(deed: deed).destroy_all
+  end
+
+  def depth
+    parents_cache.split(',').count
+  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_categories.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
+end