comunit-base 0.37.200628.0

data/app/models/deed_deed_category.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+# Link between deed and deed category
+#
+# Attributes:
+#   created_at [DateTime]
+#   deed_category_id [DeedCategory]
+#   deed_id [Deed]
+#   updated_at [DateTime]
+class DeedDeedCategory < ApplicationRecord
+  belongs_to :deed
+  belongs_to :deed_category, counter_cache: :deeds_count
+
+  validates_uniqueness_of :deed_category_id, scope: :deed_id
+end

data/app/models/deed_image.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+# Image for deed gallery
+#
+# Attributes:
+#   caption [String], optional
+#   created_at [DateTime]
+#   data [JSON]
+#   description [Text], optional
+#   image [SimpleImageUploader]
+#   priority [Integer]
+#   updated_at [DateTime]
+#   uuid [UUID]
+class DeedImage < ApplicationRecord
+  include Checkable
+  include NestedPriority
+  include HasUuid
+
+  CAPTION_LIMIT     = 100
+  DESCRIPTION_LIMIT = 32_767
+
+  mount_uploader :image, SimpleImageUploader
+
+  belongs_to :deed
+
+  validates_length_of :caption, maximum: CAPTION_LIMIT
+  validates_length_of :description, maximum: DESCRIPTION_LIMIT
+
+  # @param [DeedImage] entity
+  def self.siblings(entity)
+    where(deed: entity&.deed)
+  end
+end

data/app/models/entry.rb

@@ -0,0 +1,128 @@
+class Entry < ApplicationRecord
+  # include Elasticsearch::Model
+  include HasOwner
+
+  PER_PAGE = 10
+
+  # index_name Rails.configuration.entry_index_name
+
+  belongs_to :agent, optional: true
+  belongs_to :user, optional: true, counter_cache: true, touch: false
+  belongs_to :community, optional: true, counter_cache: true, touch: false
+  has_many :comments, as: :commentable, dependent: :destroy
+  has_many :posts, dependent: :destroy
+  has_many :news, dependent: :destroy
+
+  enum privacy: [:generally_accessible, :visible_to_community, :visible_to_followees, :personal]
+
+  mount_uploader :image, PostImageUploader
+
+  before_validation :normalize_title, :sanitize_body
+
+  validates_presence_of :body, :privacy
+
+  scope :not_deleted, -> { where(deleted: false) }
+  scope :with_privacy, -> (value) { where(privacy: value) unless value.blank? }
+  scope :public_entries, -> { where(privacy: Entry.privacies[:generally_accessible]) }
+  scope :recent, -> { order 'id desc' }
+  scope :archive, -> (year, month) { where "date_trunc('month', created_at) = ?", '%04d-%02d-01' % [year, month] }
+  scope :since, -> (time) { where('created_at > ?', time) }
+  scope :popular, -> { order('view_count desc') }
+
+  # @param [Integer] page
+  def self.page_for_administration(page)
+    not_deleted.with_privacy(Entry.community_privacies).recent.page(page).per(PER_PAGE)
+  end
+
+  # @param [User] user
+  # @param [Integer] page
+  def self.page_for_visitors(user, page)
+    not_deleted.with_privacy(Entry.privacy_for_user(user)).recent.page(page).per(PER_PAGE)
+  end
+
+  # @param [User] user
+  # @param [Integer] page
+  def self.page_for_owner(user, page)
+    owned_by(user).not_deleted.recent.page(page).per(PER_PAGE)
+  end
+
+  def self.community_privacies
+    [Entry.privacies[:generally_accessible], Entry.privacies[:visible_to_community]]
+  end
+
+  def self.entity_parameters
+    for_image = %i(image image_name image_author_name image_author_link)
+    for_image + %i(lead title body slug privacy show_name source source_link)
+  end
+
+  def self.creation_parameters
+    entity_parameters # + %i(community_id)
+  end
+
+  # @param [User] user
+  def self.privacy_for_user(user)
+    user.is_a?(User) ? Entry.community_privacies : Entry.privacies[:generally_accessible]
+  end
+
+  # @param [User] user
+  def can_be_reposted_by?(user)
+    generally_accessible? && UserPrivilege.user_in_group?(user, :editors)
+  end
+
+  # Is entry visible to user?
+  #
+  # @param [User|nil] user who tries to see the entry
+  # @return [Boolean]
+  def visible_to?(user)
+    method = "#{self.privacy}_to?".to_sym
+    respond_to?(method) ? send(method, user) : owned_by?(user)
+  end
+
+  # Is entry visible to user as generally accessible entry?
+  #
+  # @param [User|nil] user who tries to see the entry
+  # @return [Boolean]
+  def generally_accessible_to?(user)
+    user.nil? || user.is_a?(User)
+  end
+
+  # Is entry visible to user as entry for community?
+  #
+  # @param [User|nil] user who tries to see the entry
+  # @return [Boolean]
+  def visible_to_community_to?(user)
+    user.is_a? User
+  end
+
+  # Is entry visible to user as entry for followees?
+  #
+  # @param [User|nil] user who tries to see the entry
+  # @return [Boolean]
+  def visible_to_followees_to?(user)
+    owned_by?(user) || (self.user.is_a?(User) && self.user.follows?(user))
+  end
+
+  def editable_by?(user)
+    owned_by?(user) || (UserPrivilege.user_has_privilege?(user, :administrator) && visible_to?(user))
+  end
+
+  # @param [User] user
+  def commentable_by?(user)
+    user.is_a? User
+  end
+
+  private
+
+  def sanitize_body
+    self.body = body.gsub(/<\s*(?:no)?script/, '')
+  end
+
+  def normalize_title
+    if title.blank?
+      self.title, self.slug = nil, nil
+    else
+      self.title = title.strip[0..200]
+      self.slug  = Canonizer.transliterate title
+    end
+  end
+end

data/app/models/event.rb

@@ -0,0 +1,47 @@
+class Event < ApplicationRecord
+  include Toggleable
+
+  PER_PAGE = 10
+
+  NAME_LIMIT    = 150
+  LEAD_LIMIT    = 500
+  ADDRESS_LIMIT = 250
+  DAYS_LIMIT    = (1..99)
+
+  toggleable :visible, :active
+
+  has_many :event_participants, dependent: :destroy
+  has_many :event_speakers, dependent: :destroy
+  has_many :event_sponsors, dependent: :destroy
+  has_many :event_programs, dependent: :delete_all
+  has_many :event_materials, dependent: :destroy
+
+  mount_uploader :image, EventImageUploader
+
+  before_validation { self.name = name.to_s.strip }
+  before_validation { self.slug = Canonizer.transliterate(name.to_s) }
+
+  validates_presence_of :name, :body
+  validates_length_of :lead, maximum: LEAD_LIMIT
+  validates_length_of :name, maximum: NAME_LIMIT
+  validates_length_of :address, maximum: ADDRESS_LIMIT
+  validates_inclusion_of :day_count, in: DAYS_LIMIT
+
+  scope :recent, -> { order('start_date desc, id desc') }
+  scope :visible, -> { where(visible: true) }
+  scope :forthcoming, -> { where('start_date >= ?', Time.now) }
+
+  # @oaram [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)
+    visible.recent.page(page).per(PER_PAGE)
+  end
+
+  def self.entity_parameters
+    %i(name slug lead body start_date day_count price address coordinates visible active image)
+  end
+end

data/app/models/event_material.rb

@@ -0,0 +1,44 @@
+class EventMaterial < ApplicationRecord
+  include Toggleable
+
+  NAME_LIMIT = 250
+
+  toggleable :show_on_page
+
+  belongs_to :event
+
+  mount_uploader :attachment, EventAttachmentUploader
+
+  after_initialize { self.uuid = SecureRandom.uuid if uuid.nil? }
+
+  validates_presence_of :name
+  validates_length_of :name, maximum: NAME_LIMIT
+  validates_length_of :description, maximum: NAME_LIMIT
+
+  scope :ordered_by_name, -> { order('name asc') }
+  scope :for_main_page, -> { where(show_on_page: true) }
+
+  def self.page_for_administration
+    ordered_by_name
+  end
+
+  def self.page_for_visitors
+    for_main_page.ordered_by_name
+  end
+
+  def self.page_for_participants
+    ordered_by_name
+  end
+
+  def self.entity_parameters
+    %i(attachment name description show_on_page)
+  end
+
+  def self.creation_parameters
+    entity_parameters + %i(event_id)
+  end
+
+  def locked?
+    event.locked?
+  end
+end

data/app/models/event_participant.rb

@@ -0,0 +1,52 @@
+class EventParticipant < ApplicationRecord
+  include Toggleable
+
+  PER_PAGE = 20
+
+  NAME_LIMIT    = 100
+  EMAIL_LIMIT   = 250
+  PHONE_LIMIT   = 50
+  COMMENT_LIMIT = 10000
+  NOTICE_LIMIT  = 250
+  COMPANY_LIMIT = 250
+
+  METRIC_CREATED = 'events.participants.created.hit'
+
+  toggleable :processed
+
+  belongs_to :event, counter_cache: true
+  belongs_to :user, optional: true
+  belongs_to :agent, optional: true
+
+  validates_presence_of :name, :surname
+  validates_length_of :name, maximum: NAME_LIMIT
+  validates_length_of :surname, maximum: NAME_LIMIT
+  validates_length_of :email, maximum: EMAIL_LIMIT
+  validates_length_of :phone, maximum: PHONE_LIMIT
+  validates_length_of :comment, maximum: COMMENT_LIMIT
+  validates_length_of :notice, maximum: NOTICE_LIMIT
+  validates_length_of :company, maximum: COMPANY_LIMIT
+
+  scope :recent, -> { order('created_at desc') }
+  scope :surname_like, ->(val) { where('surname ilike ?', "%#{val}%") unless val.blank? }
+  scope :email_like, ->(val) { where('email ilike ?', "#{val}") unless val.blank? }
+  scope :filtered, ->(f) { surname_like(f[:name]).email_like(f[:email]) }
+
+  # @param [Integer] page
+  # @param [Hash] filter
+  def self.page_for_administration(page = 1, filter = {})
+    filtered(filter).recent.page(page).per(PER_PAGE)
+  end
+
+  def self.entity_parameters
+    %i(name surname email phone comment notice company)
+  end
+
+  def self.creation_parameters
+    entity_parameters - %i(notice) + %i(event_id)
+  end
+
+  def full_name
+    "#{surname} #{name}".strip
+  end
+end

data/app/models/event_program.rb

@@ -0,0 +1,50 @@
+class EventProgram < ApplicationRecord
+  PLACE_LIMIT = 100
+  BODY_LIMIT  = 65535
+
+  belongs_to :event
+
+  validates_presence_of :day_number
+  validate :day_number_range
+  validates_uniqueness_of :place, scope: [:day_number, :event_id]
+  validates_length_of :place, maximum: PLACE_LIMIT
+  validates_length_of :body, maximum: BODY_LIMIT
+
+  scope :ordered_by_day, -> { order('day_number asc, place asc') }
+
+  def self.page_for_administration
+    ordered_by_day
+  end
+
+  def self.page_for_visitors
+    ordered_by_day
+  end
+
+  def self.entity_parameters
+    %i(place day_number body)
+  end
+
+  def self.creation_parameters
+    entity_parameters + %i(event_id)
+  end
+
+  def locked?
+    event.locked?
+  end
+
+  def name
+    "#{place}: #{day_number}"
+  end
+
+  def max_day_number
+    event&.day_count || 1
+  end
+
+  private
+
+  def day_number_range
+    unless (1..max_day_number).include?(day_number)
+      errors.add(:day_number, I18n.t('activerecord.errors.models.event_program.attributes.program_day.out_of_range'))
+    end
+  end
+end

data/app/models/event_speaker.rb

@@ -0,0 +1,69 @@
+class EventSpeaker < ApplicationRecord
+  include Toggleable
+
+  NAME_LIMIT       = 100
+  OCCUPATION_LIMIT = 250
+  PRIORITY_LIMIT   = (1..999)
+
+  toggleable :visible
+
+  belongs_to :event
+
+  mount_uploader :image, EventPersonImageUploader
+
+  after_initialize :set_next_priority
+
+  before_validation :normalize_priority
+  validates_presence_of :name
+  validates_length_of :name, maximum: NAME_LIMIT
+  validates_length_of :occupation, maximum: OCCUPATION_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 occupation 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     = EventSpeaker.siblings(event).find_by(priority: new_priority)
+    if adjacent.is_a?(EventSpeaker) && (adjacent.id != id)
+      adjacent.update!(priority: priority)
+    end
+    self.update(priority: new_priority)
+
+    EventSpeaker.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 = EventSpeaker.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