comunit-base 0.37.200628.0

data/app/helpers/users_helper.rb

@@ -0,0 +1,37 @@
+module UsersHelper
+  def attitudes_for_select
+    options = [[t(:not_selected), '']]
+    options + (-2..1).map { |o| [t("attitudes.#{o}"), o]}
+  end
+
+  # @param [Integer] gender_key
+  def marital_statuses_for_select(gender_key)
+    options = [[t(:not_selected), '']]
+    options + UserProfileHandler::MARITAL.keys.map { |o| [marital_status_name(gender_key, o), o] }
+  end
+
+  # @param [Integer] gender_key
+  # @param [Integer] key
+  def marital_status_name(gender_key, key)
+    gender = UserProfileHandler::GENDERS[gender_key]
+    prefix = 'activerecord.attributes.user_profile.marital_statuses.'
+    prefix << (gender.blank? ? 'default' : gender)
+    if UserProfileHandler::MARITAL.key?(key)
+      t("#{prefix}.#{UserProfileHandler::MARITAL[key]}")
+    else
+      t(:not_selected)
+    end
+  end
+
+  # @param [User] user
+  def marital_status_for_user(user)
+    marital_status_name(user.data.dig('profile', 'gender'), user.data.dig('profile', 'marital_status'))
+  end
+
+  # @param [User] user
+  def editorial_user_link(user)
+    return t(:anonymous) if user.nil?
+    text = user.profile_name
+    link_to text, editorial_user_path(id: user.id), class: 'profile'
+  end
+end

data/app/helpers/votes_helper.rb

@@ -0,0 +1,24 @@
+module VotesHelper
+  # @param [ApplicationRecord] entity
+  def admin_votable_link(entity)
+    text = entity.model_name.human
+    path = '#'
+    if entity.is_a?(Comment)
+      text << ": #{entity.commentable.model_name.human}"
+      text << " <cite>#{entity.commentable.title}</cite>"
+      path = admin_comment_path(id: entity.id)
+    end
+    link_to(text.html_safe, path)
+  end
+
+  # @param [ApplicationRecord] entity
+  def votable_link(entity)
+    text = entity.model_name.human
+    path = '#'
+    if entity.is_a?(Comment)
+      text += " #{entity.commentable.title}"
+      path = entity.commentable
+    end
+    link_to(text, path)
+  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/network_campaign_sync_job.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+# Synchronize campaign with main site
+class NetworkCampaignSyncJob < ApplicationJob
+  queue_as :default
+
+  # @param [Integer] entity_id
+  # @param [TrueClass|FalseClass] for_update
+  def perform(entity_id, for_update = false)
+    entity = Campaign.find_by(id: entity_id)
+
+    return if entity.nil?
+
+    handler = NetworkManager::CampaignHandler.new
+
+    return unless Rails.env.production?
+
+    for_update ? handler.update_remote(entity) : handler.create_remote(entity)
+  end
+end

data/app/jobs/network_candidate_sync_job.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+# Synchronize candidate with main site
+class NetworkCandidateSyncJob < ApplicationJob
+  queue_as :default
+
+  # @param [Integer] entity_id
+  # @param [TrueClass|FalseClass] for_update
+  def perform(entity_id, for_update = false)
+    entity = Candidate.find_by(id: entity_id)
+
+    return if entity.nil?
+
+    handler = NetworkManager::CandidateHandler.new
+
+    return unless Rails.env.production?
+
+    for_update ? handler.update_remote(entity) : handler.create_remote(entity)
+  end
+end

data/app/jobs/network_entity_sync_job.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+# Synchronize entity with main site
+class NetworkEntitySyncJob < ApplicationJob
+  queue_as :default
+
+  # @param [String] entity_class
+  # @param [Integer] entity_id
+  def perform(entity_class, entity_id)
+    handler = handler_from_string(entity_class)
+
+    return if handler.nil?
+
+    handler.entity = model_from_string(entity_class, entity_id)
+    handler.push
+  end
+
+  private
+
+  # @param [String] entity_class
+  def handler_from_string(entity_class)
+    handler_name = "Comunit::Network::Handlers::#{entity_class}Handler"
+    handler_name.safe_constantize&.new(nil)
+  end
+
+  # @param [String] entity_class
+  # @param [Integer] entity_id
+  def model_from_string(entity_class, entity_id)
+    entity_class.safe_constantize&.find_by(id: entity_id)
+  end
+end

data/app/jobs/network_political_force_sync_job.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+# Synchronize political_force with main site
+class NetworkPoliticalForceSyncJob < ApplicationJob
+  queue_as :default
+
+  # @param [Integer] entity_id
+  # @param [TrueClass|FalseClass] for_update
+  def perform(entity_id, for_update = false)
+    entity = PoliticalForce.find_by(id: entity_id)
+
+    return if entity.nil?
+
+    handler = NetworkManager::PoliticalForceHandler.new
+
+    return unless Rails.env.production?
+
+    for_update ? handler.update_remote(entity) : handler.create_remote(entity)
+  end
+end

data/app/jobs/network_post_sync_job.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+# Parse post body and synchronize post with main site
+class NetworkPostSyncJob < ApplicationJob
+  queue_as :default
+
+  # @param [Integer] entity_id
+  # @param [TrueClass|FalseClass] for_update
+  def perform(entity_id, for_update = false)
+    entity = Post.find_by(id: entity_id)
+
+    return if entity.nil?
+
+    handler = NetworkManager::PostHandler.new
+
+    entity.update(parsed_body: PostManager.new(entity).parsed_body)
+
+    return unless Rails.env.production?
+
+    for_update ? handler.update_remote(entity) : handler.create_remote(entity)
+  end
+end

data/app/jobs/network_user_sync_job.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+# Synchronize user with main site
+class NetworkUserSyncJob < ApplicationJob
+  queue_as :default
+
+  # @param [Integer] entity_id
+  # @param [TrueClass|FalseClass] for_update
+  def perform(entity_id, for_update = false)
+    return unless Rails.env.production?
+
+    entity = User.find_by(id: entity_id)
+
+    return if entity.nil?
+
+    handler = NetworkManager::UserHandler.new
+
+    for_update ? handler.update_remote(entity) : handler.create_remote(entity)
+  end
+end

data/app/mailers/appeals_mailer.rb

@@ -0,0 +1,12 @@
+class AppealsMailer < ApplicationMailer
+  # На обращение пользователя дан ответ
+  #
+  # @param [Integer] appeal_id
+  def appeal_reply(appeal_id)
+    @appeal = Appeal.find_by(id: appeal_id)
+
+    return if @appeal.nil? || @appeal.email.blank?
+
+    mail to: @appeal.email
+  end
+end

data/app/mailers/application_mailer.rb

@@ -0,0 +1,5 @@
+class ApplicationMailer < ActionMailer::Base
+  default from: 'from@example.com'
+  layout 'mailer'
+end
+

data/app/models/album.rb

@@ -0,0 +1,42 @@
+class Album < ApplicationRecord
+  include HasOwner
+  include Toggleable
+
+  PER_PAGE = 20
+
+  toggleable :show_on_front
+
+  mount_uploader :image, PhotoUploader
+
+  belongs_to :user
+  belongs_to :region, optional: true
+  has_many :photos, dependent: :destroy
+
+  after_initialize { self.uuid = SecureRandom.uuid if uuid.nil? }
+  before_validation { self.slug = Canonizer.transliterate(name.to_s) }
+
+  validates_presence_of :name, :image, :description
+
+  scope :ordered_by_name, -> { order('name asc') }
+  scope :recent, -> { order('id desc') }
+  scope :for_frontpage, -> { where(show_on_front: true) }
+
+  # @param [Integer] page
+  def self.page_for_administration(page = 1)
+    recent.page(page).per(PER_PAGE)
+  end
+
+  # @param [Integer] page
+  def self.page_for_visitors(page = 1)
+    recent.page(page).per(PER_PAGE)
+  end
+
+  def self.entity_parameters
+    %i(name image description)
+  end
+
+  # @param [User] user
+  def editable_by?(user)
+    owned_by?(user)
+  end
+end

data/app/models/appeal.rb

@@ -0,0 +1,50 @@
+class Appeal < ApplicationRecord
+  include Toggleable
+  include HasOwner
+
+  PER_PAGE      = 20
+  SUBJECT_LIMIT = 140
+  NAME_LIMIT    = 100
+  EMAIL_LIMIT   = 200
+  PHONE_LIMIT   = 30
+  BODY_LIMIT    = 5000
+
+  toggleable :processed
+
+  belongs_to :appeal_type, optional: true, counter_cache: true
+  belongs_to :user, optional: true
+  belongs_to :agent, optional: true
+  belongs_to :responder, class_name: User.to_s, foreign_key: :responder_id, optional: true
+
+  after_initialize { self.uuid = SecureRandom.uuid if uuid.nil? }
+  validates_presence_of :subject, :body
+  validates_length_of :subject, maximum: SUBJECT_LIMIT
+  validates_length_of :name, maximum: NAME_LIMIT
+  validates_length_of :email, maximum: EMAIL_LIMIT
+  validates_length_of :body, maximum: BODY_LIMIT
+  validates_length_of :phone, maximum:  PHONE_LIMIT
+  validates_length_of :response, maximum: BODY_LIMIT
+
+  scope :recent, -> { order('id desc') }
+
+  # @param [Integer] page
+  def self.page_for_administration(page = 1)
+    recent.page(page).per(PER_PAGE)
+  end
+
+  def self.creation_parameters
+    %i(name phone email subject body)
+  end
+
+  def self.entity_parameters
+    %i(response)
+  end
+
+  # @param [User] user
+  def apply_user(user)
+    return if user.nil?
+    self.name  = user.profile_name
+    self.email = user.email
+    self.phone = user.phone
+  end
+end

data/app/models/appeal_type.rb

@@ -0,0 +1,45 @@
+class AppealType < ApplicationRecord
+  include RequiredUniqueName
+  include Toggleable
+
+  NAME_LIMIT = 50
+  PRIORITY_RANGE = (1..100)
+
+  toggleable :visible
+
+  has_many :appeals, dependent: :nullify
+
+  after_initialize :set_next_priority
+  validates_length_of :name, maximum: NAME_LIMIT
+
+  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.list_for_visitors
+    visible.ordered_by_priority
+  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
+    self.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
+end

data/app/models/application_record.rb

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

data/app/models/campaign.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+# Election campaign
+#
+# Attributes:
+#   active [boolean]
+#   candidates_count [integer]
+#   created_at [DateTime]
+#   date [date], optional
+#   image [SimpleImageUploader], optional
+#   name [string]
+#   region_id [Region], optional
+#   slug [string]
+#   sync_state [JSON]
+#   updated_at [DateTime]
+#   uuid [uuid]
+class Campaign < ApplicationRecord
+  include Checkable
+  include RequiredUniqueName
+  include RequiredUniqueSlug
+  include Toggleable
+
+  NAME_LIMIT = 50
+  SLUG_LIMIT = 50
+  SLUG_PATTERN = /\A[a-z][-_a-z0-9]*[a-z0-9]\z/i.freeze
+  SLUG_PATTERN_HTML = '^[a-zA-Z][-_a-zA-Z0-9]*[a-zA-Z0-9]$'
+
+  toggleable :active
+
+  mount_uploader :image, SimpleImageUploader
+
+  belongs_to :region, optional: true
+  has_many :candidates, dependent: :delete_all
+
+  after_initialize { self.uuid = SecureRandom.uuid if uuid.nil? }
+  before_validation { self.slug = Canonizer.transliterate(name) if slug.blank? }
+
+  validates_uniqueness_of :uuid
+  validates_length_of :name, maximum: NAME_LIMIT
+  validates_length_of :slug, maximum: SLUG_LIMIT
+  validates_format_of :slug, with: SLUG_PATTERN
+
+  scope :active, -> { where(active: true) }
+  scope :forthcoming, -> { where('date >= date(now())') }
+  scope :ordered_by_date, -> { order('date asc nulls first') }
+  scope :list_for_visitors, -> { active.ordered_by_date }
+  scope :list_for_administration, -> { ordered_by_slug }
+
+  def self.entity_parameters
+    %i[active date image name region_id slug]
+  end
+
+  # @param [User] user
+  def self.user_can_join?(user)
+    total = list_for_visitors.count
+    taken = list_for_visitors.joins(:candidates).where(candidates: { user: user }).count
+    total > taken
+  end
+
+  def regional?
+    !region.nil?
+  end
+
+  # @param [Candidate] entity
+  def candidate?(entity)
+    candidates.where(id: entity.id).exists?
+  end
+
+  # @param [User] entity
+  def user?(entity)
+    candidates.owned_by(entity).exists?
+  end
+
+  # @param [User] user
+  def approved?(user)
+    candidates.find_by(user: user)&.approved?
+  end
+end